Need alittle help on the Static Geometry demo

sharky_151
04-01-2006 21:03:50
Hello, I've been modifying the Static Geometry Demo that's included with pyogre. My goal is to make it like the Demo_Grass.exe that's in the C++ ogre SDK. I've just about got it done, and it will run the way it is, the only thing left to do is convert the waveGrass function, but I don't know how to "spell it out" in pyogre. I was wondering if someone could help me get the waveGrass function working. The C++ waveGrass function is commented out near the bottom of the code. I'm still learning python and ogre so this would really help alot.

thanks.

Here is my modified Grass.py code.


# this code is in the public domain

from pyogre import ogre

import SampleFramework as sf



GRASS_HEIGHT = 300

GRASS_WIDTH = 250

GRASS_MESH_NAME = "grassblades"

GRASS_MATERIAL = "Examples/GrassBlades"

OFFSET_PARAM = 999



class GrassApplication(sf.Application):

    def __init__(self):

        sf.Application.__init__(self)

        self.minLightColour = ogre.ColourValue(0.5, 0.1, 0.0)

        self.maxLightColour = ogre.ColourValue(1.0, 0.6, 0.0)

        self.minFlareSize = 40

        self.maxFlareSize = 80

    

    def _createScene(self):

        sceneManager = self.sceneManager

        

        sceneManager.setSkyBox(True, "Examples/SpaceSkyBox")

        

        self.setupLighting()        

        

        plane = ogre.Plane()

        plane.normal = ogre.Vector3.UNIT_Y

        plane.d = 0        

        

        mm = ogre.MeshManager.getSingleton()

        mm.createPlane('MyPlane',

            ogre.ResourceManager.DEFAULT_RESOURCE_GROUP_NAME,

            plane, 14500, 14500, 10, 10, True, 1, 50, 50, ogre.Vector3.UNIT_Z)

        

        PlaneEnt = sceneManager.createEntity('plane', 'MyPlane')        

        PlaneEnt.setMaterialName("Examples/GrassFloor")

        PlaneEnt.castShadows = False

        sceneManager.rootSceneNode.createChildSceneNode().attachObject(

            PlaneEnt)

        

        self.createGrassMesh()

        

        grassEntity = sceneManager.createEntity("1", GRASS_MESH_NAME)

        staticGrass = sceneManager.createStaticGeometry("grassBladeGeometry")        

        staticGrass.regionDimensions = (1000, 1000, 1000)        

        # Set the region origin so the centre is at 0 world

        staticGrass.origin = (-500, -500, -500)

        

        for x in xrange(-1950, 1950, 150):

            for z in xrange(-1950, 1950, 150):

                pos = (x + ogre.Math.RangeRandom(-25, 25),

                    0, z + ogre.Math.RangeRandom(-25, 25))

                

                orientation = ogre.Quaternion()

                orientation.FromAngleAxis(ogre.Degree(

                    ogre.Math.RangeRandom(0,359)), ogre.Vector3.UNIT_Y)

                

                scale = ogre.Vector3(1, ogre.Math.RangeRandom(0.85, 1.15), 1)

                staticGrass.addEntity(grassEntity, pos, orientation, scale)

        

        staticGrass.build()

        self.staticGeom = staticGrass

        

        ogreMesh = ogre.MeshManager.getSingleton().load('ogrehead.mesh',

            ogre.ResourceManager.DEFAULT_RESOURCE_GROUP_NAME)

        

        tangentExist, src, dst = ogreMesh.suggestTangentVectorBuildParams()

        

        if not tangentExist:

            ogreMesh.buildTangentVectors(src, dst)

        

        ogreEntity = sceneManager.createEntity('head', 'ogrehead.mesh')

        ogreEntity.setMaterialName('Examples/OffsetMapping/Specular')

        headNode = sceneManager.rootSceneNode.createChildSceneNode()

        headNode.attachObject(ogreEntity)

        headNode.scale = (7, 7, 7)

        headNode.position = (0, 200, 0)

        ogreEntity.normaliseNormals = (True)

        self.camera.move(ogre.Vector3(0, 350, 0))



    def _createFrameListener(self):

        self.frameListener = GrassListener(self.renderWindow, self.camera,

            self.sceneManager, self.animationState)

        

        self.root.addFrameListener(self.frameListener)



    def setupLighting(self):

        sceneManager = self.sceneManager

        # Set ambient light

        self.sceneManager.ambientLight = (.2, .2, .2)

        

        # Point light, movable, reddish

        Light = sceneManager.createLight('Light2')

        Light.diffuseColour = (self.minLightColour)

        Light.specularColour = 1, 1, 1

        Light.setAttenuation(8000, 1, 0.0005, 0)

        

        # Create light node

        LightNode = sceneManager.rootSceneNode.createChildSceneNode(

            'MovingLightNode')

        

        LightNode.attachObject(Light)

        

        # Create billboard set

        bbs = sceneManager.createBillboardSet('lightbbs', 1)

        bbs.materialName = 'Examples/Flare'

        bb = bbs.createBillboard(0,0,0, (self.minLightColour))        

        LightNode.attachObject(bbs)

        

        # Light controller functions

        func = ogre.WaveformControllerFunction(ogre.WFT_SINE, 0.0, 0.5)

        

        # Light Wibbler

        val = LightWibbler(

            Light, bb, (self.minLightColour), (self.maxLightColour),

            (self.minFlareSize), (self.maxFlareSize))

        

        # Convert to shared pointers

        val = ogre.SharedPtr(val)

        func = ogre.SharedPtr(func)

        

        # Light controllers

        controllerManager = ogre.ControllerManager.getSingleton()

        

        self.LightController = controllerManager.createController(

            controllerManager.getFrameTimeSource(),

            val, func)

        

        LightNode.position = 300, 250, -300

        

        # Set up Animation

        anim = sceneManager.createAnimation('LightTrack', 20)

        anim.interpolationMode = ogre.Animation.IM_SPLINE

        track = anim.createTrack(0, LightNode)

        

        key = track.createKeyFrame(0)

        key.translation = 300,550,-300

        key = track.createKeyFrame(2)        

        key.translation = 150,600,-250

        key = track.createKeyFrame(4)

        key.translation = -150,650,-100        

        key = track.createKeyFrame(6)

        key.translation = -400,500,-200        

        key = track.createKeyFrame(8)

        key.translation = -200,500,-400        

        key = track.createKeyFrame(10)

        key.translation = -100,450,-200        

        key = track.createKeyFrame(12)

        key.translation = -100,400,180        

        key = track.createKeyFrame(14)

        key.translation = 0,250,600        

        key = track.createKeyFrame(16)

        key.translation = 100,650,100        

        key = track.createKeyFrame(18)

        key.translation = 250,600,0        

        key = track.createKeyFrame(20)

        key.translation = 300,550,-300

        

        # Create a new animation state to track this

        self.animationState = sceneManager.createAnimationState('LightTrack')

        self.animationState.enabled = True



    def createGrassMesh(self):

        # Each grass section is 3 planes at 60 degrees to each other

        # Normals point straight up to simulate correct lighting

        mesh = ogre.MeshManager.getSingleton().createManual(

            GRASS_MESH_NAME,

            ogre.ResourceManager.DEFAULT_RESOURCE_GROUP_NAME)

        

        subMesh = mesh.createSubMesh()

        subMesh.useSharedVertices = False

        subMesh.vertexData = ogre.VertexData()

        subMesh.vertexData.vertexStart = 0

        subMesh.vertexData.vertexCount = 12

        

        #work-around to prevent destruction

        self.vertexData = subMesh.vertexData

        

        vDec = subMesh.vertexData.vertexDeclaration

        vDec.addElement(0, vDec.getVertexSize(0), ogre.VET_FLOAT3,

            ogre.VES_POSITION, 0)

        

        vDec.addElement(0, vDec.getVertexSize(0), ogre.VET_FLOAT3,

            ogre.VES_NORMAL, 0)

        

        vDec.addElement(0, vDec.getVertexSize(0), ogre.VET_FLOAT2,

            ogre.VES_TEXTURE_COORDINATES, 0)

        

        vertexBuffer = ogre.HardwareBufferManager.                            \

            getSingleton().createVertexBuffer(

            vDec.getVertexSize(0), 12,

            ogre.HardwareBuffer.HBU_STATIC_WRITE_ONLY)

        

        vertexes = vertexBuffer.lock(subMesh.vertexData.vertexDeclaration,

            ogre.HardwareBuffer.HBL_DISCARD)

        

        baseVec = ogre.Vector3(GRASS_WIDTH/2.0, 0, 0)

        vec = ogre.Vector3(baseVec)

        rot = ogre.Quaternion()

        rot.FromAngleAxis(ogre.Degree(60), ogre.Vector3.UNIT_Y)

        vertexIndex = 0

        POSITION_ELEMENT = 0

        NORMAL_ELEMENT = 1

        UV_ELEMENT = 2

        for index in xrange(0,3):

            vertexes.setFloat(vertexIndex, POSITION_ELEMENT, -vec.x,

                GRASS_HEIGHT, -vec.z)

            

            vertexes.setFloat(vertexIndex, NORMAL_ELEMENT, 0, 1, 0)

            vertexes.setFloat(vertexIndex, UV_ELEMENT, 0, 0)

            vertexIndex += 1

            

            vertexes.setFloat(vertexIndex, POSITION_ELEMENT, vec.x,

                GRASS_HEIGHT, vec.z)

            

            vertexes.setFloat(vertexIndex, NORMAL_ELEMENT, 0, 1, 0)

            vertexes.setFloat(vertexIndex, UV_ELEMENT, 1, 0)

            vertexIndex += 1

            

            vertexes.setFloat(vertexIndex, POSITION_ELEMENT, -vec.x, 0, -vec.z)

            vertexes.setFloat(vertexIndex, NORMAL_ELEMENT, 0, 1, 0)

            vertexes.setFloat(vertexIndex, UV_ELEMENT, 0, 1)

            vertexIndex += 1

            

            vertexes.setFloat(vertexIndex, POSITION_ELEMENT, vec.x, 0, vec.z)

            vertexes.setFloat(vertexIndex, NORMAL_ELEMENT, 0, 1, 0)

            vertexes.setFloat(vertexIndex, UV_ELEMENT, 1, 1)

            vertexIndex += 1

            

            vec = rot * vec

        

        vertexBuffer.unlock()

        

        subMesh.vertexData.vertexBufferBinding.setBinding(0, vertexBuffer)

        subMesh.indexData.indexCount = 6*3

        subMesh.indexData.indexBuffer = ogre.HardwareBufferManager.           \

            getSingleton().createIndexBuffer(

            ogre.HardwareIndexBuffer.IT_16BIT, 6*3,

            ogre.HardwareBuffer.HBU_STATIC_WRITE_ONLY)

        

        indices = []

        for i in xrange(0,3):

            indices += [ x + i * 4 for x in [0,3,1, 0,2,3] ]

        

        subMesh.indexData.indexBuffer.writeIndexes(0, indices)

        subMesh.materialName = (GRASS_MATERIAL)

        

        #work-around to prevent destruction

        self.indexData = subMesh.indexData



# Light related classes

class LightWibbler(ogre.RealControllerValue):

    def __init__(self, light, billboard, minColour, maxColour, minSize,

        maxSize):

        

        ogre.RealControllerValue.__init__(self)

        self.light = light

        self.billboard = billboard

        self.colourRange = ogre.ColourValue((maxColour - minColour) * 0.5)

        self.halfColour = ogre.ColourValue(minColour + self.colourRange)

        self.minSize = minSize

        self.sizeRange = maxSize - minSize



    def getValue(self):

        return intensity



    def setValue(self, value):

        intensity = value

        newColour = self.halfColour + (self.colourRange * intensity)

        self.light.diffuseColour = newColour

        self.billboard.colour = newColour

        newSize = self.minSize + (intensity * self.sizeRange)

        self.billboard.setDimensions(newSize, newSize)



class GrassListener(sf.FrameListener):

    def __init__(self, renderWindow, camera, sceneManager, animationState):

        sf.FrameListener.__init__(self, renderWindow, camera)

        self.sceneManager = sceneManager

        self.animationState = animationState

        self.ShowBBs = False

        self.renderWindow.debugText = ('Press B to show Bounding Boxes')

        

##	void waveGrass(Real timeElapsed)

##	{

##		static Real xinc = Math::PI * 0.4;

##		static Real zinc = Math::PI * 0.55;

##		static Real xpos = Math::RangeRandom(-Math::PI, Math::PI);

##		static Real zpos = Math::RangeRandom(-Math::PI, Math::PI);

##

##		xpos += xinc * timeElapsed;

##		zpos += zinc * timeElapsed;

##

##		// Update vertex program parameters by binding a value to each renderable

##		static Vector4 offset(0,0,0,0);

##

##		StaticGeometry::RegionIterator rit =  mStaticGeom->getRegionIterator();

##		while (rit.hasMoreElements())

##		{

##			StaticGeometry::Region* reg = rit.getNext();

##

##			// a little randomness

##			xpos += reg->getCentre().x * 0.001;

##			zpos += reg->getCentre().z * 0.001;

##			offset.x = Math::Sin(xpos) * 0.05;

##			offset.z = Math::Sin(zpos) * 0.05;

##

##			StaticGeometry::Region::LODIterator lodit = reg->getLODIterator();

##			while (lodit.hasMoreElements())

##			{

##				StaticGeometry::LODBucket* lod = lodit.getNext();

##				StaticGeometry::LODBucket::MaterialIterator matit =

##					lod->getMaterialIterator();

##				while (matit.hasMoreElements())

##				{

##					StaticGeometry::MaterialBucket* mat = matit.getNext();

##					StaticGeometry::MaterialBucket::GeometryIterator geomit =

##						mat->getGeometryIterator();

##					while (geomit.hasMoreElements())

##					{

##						StaticGeometry::GeometryBucket* geom = geomit.getNext();

##						geom->setCustomParameter(OFFSET_PARAM, offset);

##

##					}

##				}

##			}

##		}

##

##	}

    

    def frameStarted(self, frameEvent):        

        if self._isToggleKeyDown(ogre.KC_B, 0.2):

            if (self.ShowBBs == True):

                self.ShowBBs = False

                self.renderWindow.debugText = (

                    'Press B to show Bounding Boxes')

            

            else:

                self.ShowBBs = True

                self.renderWindow.debugText = (

                    'Press B to hide Bounding Boxes')

            

            self.sceneManager.showBoundingBoxes = self.ShowBBs

        

        if self.animationState:

            self.animationState.addTime(frameEvent.timeSinceLastFrame)

            

##      waveGrass(evt.timeSinceLastFrame);

        

        return sf.FrameListener.frameStarted(self, frameEvent)



if __name__ == '__main__':

    application = GrassApplication()

    application.go()