if len(taskMgr.getTasksNamed("Tree step task")) == 0:

# FIXME: This assumes that all Terrain objects will be added at the

# very beginning of the simulation. (Any that are added after this task

# returns 'done' will not benefit from a collision traverser for

# trees). Give each Terrain object its own collision traverser and task

# which it can stop when it no longer needs it?

return Task.done

else:

cTrav.traverse(render)

"""Return a smoothed out copy of a given heightmap.

keyword arguments:

map -- a 2D list of numerical values.

n -- I can do it n times!

"""

newmap = list(map)

for x in range(0,n):

temp = list(newmap)

for i in range(1,len(temp)-1):

for j in range(1,len(temp)-1):

tl = temp[i-1][j+1]

t = temp[i][j+1]

tr = temp[i+1][j+1]

l = temp[i-1][j]

c = temp[i][j]

r = temp[i+1][j]

bl = temp[i-1][j-1]

b = temp[i][j-1]

br = temp[i+1][j-1]

newmap[i][j] = (tl+t+tr+l+(8*c)+r+bl+b+br)/16

"""Return a chainable size x sixe heightmap (2D list) computed using the

diamond-square algorithm.

A heightmap can be used (for example) to build terrain models, or sky,

water or detail textures.

Keyword arguments:

size -- the size of the terrain heightmap in pixels (default 33).

Acceptable values are 33,129,513

h -- the 'hilliness' factor (default 6)

smooth -- whether or not to smooth the heightmap after executing the

diamond-square algorithm (default True)

"""

# The number of times (n) the smoothHeightMap() is applied after generating

# the initial heightmap depends on the initial value of h ('hillier'

# heightmaps get smoothed out more than flat ones).

if h <= 2: n = 0

elif h <= 3: n = 2

elif h <= 12: n = 3

elif h <= 16: n = 4

else: n = 5

# 33, 129 and 513 are known to work...

# Any number that is a power of 2 plus one should work, but not all do,

# must be a bug in here somewhere.

if size not in [33,129,513]: size = 33

# Create a size x size 2D list of 0's

heightmap = [[x]*size for x in [0]*size]

# Fill in the heightmap using the diamond-square algorithm.

side = len(heightmap)-1 # Length of the side of the squares

while side > 0:

# Perform the diamond step for each square.

for i in range(0,len(heightmap)-1,side):

for j in range(0,len(heightmap)-1,side):

bl = heightmap[i][j]

tr = heightmap[i+side][j]

tl = heightmap[i+side][i+side]

br = heightmap[i][i+side]

height = ((bl+tr+tl+br)/4) + ((random.random()-0.5)*h)

heightmap[i+side/2][j+side/2] = height

# Perform the square step for each diamond.

side = side/2

for i in range(0,len(heightmap)-1,side):

for j in range(0,len(heightmap)-1,side):

l = heightmap[i][j+side/2]

b = heightmap[i+side/2][j]

t = heightmap[i+side/2][j+side]

r = heightmap[i+side][j+side/2]

height = ((l+b+t+r)/4) + ((random.random()-0.5)*h)

heightmap[i+side/2][j+side/2] = height

h = h/2

side = side/2

# It is possible to create 'paths' or 'rivers' through hilly terrain by

# flattening out a path through the heightmap after executing the

# diamond-square algorithm but before smoothing the heightmap. This

# flattening creates a path or riverbed with very jagged edges which are

# then smoothed with the surrounding terrain when smoothHeightMap is run.

#

# An interesting possibility to create curvy paths is to load a 'paths'

# image file at this stage in which black pixels will be flattened and

# white pixels will be ignored.

#

# You really need high-resolution hieghtmaps for this stuff to work well.

#

# This flattens a diagonal path through the middle of the heightmap:

#from math import floor

#width = 5

#for i in range(1,len(heightmap)-1):

# for a in range(i-floor(width/2),i+floor(width/2)):

# for b in range(i-floor(width/2),i+floor(width/2)):

# heightmap[a][b] = -1

# Flatten the edges of the heightmap to make it chainable with other

# heightmaps produced by this same method.

for i in range(0,len(heightmap)):

heightmap[0][i] = 0

heightmap[i][0] = 0

heightmap[0][len(heightmap)-1] = 0

heightmap[len(heightmap)-1][0] = 0

if smooth: return smoothHeightMap(heightmap,n)

"""Return a tuple of EggPolygons (renderQuad,collisionQuad): renderable and

collision geometry for a 4-vertex polygon.

Keyword arguments:

renderVP -- EggVertexPool to which vertices will be added for the

renderable quad

collisionVP -- EggVertexPool to which vertices will be added for the

collidable quad

bl -- bottom-left vertex of quad (Point3D). Default (-10,-10,0)

tr -- top-right vertex of quad (Point3D). Default (10,10,0)

br -- bottom-right vertex of quad (Point3D)

tl -- top-left vertex of quad (Point3D)

If either of br or tl is None then sensible defaults will be computed

according to the values of bl and tr.

"""

if bl is None: bl = P.Point3D(-10,-10,0)

if tr is None: tr = P.Point3D(10,10,0)

if br is None:

l = tr.getX() - bl.getX()

br = bl + P.Vec3D(l,0,0)

if tl is None:

w = tr.getY() - bl.getY()

tl = bl + P.Vec3D(0,w,0)

renderQuad = P.EggPolygon()

collisionQuad = P.EggPolygon()

for corner in [bl,br,tr,tl]:

vertex = P.EggVertex()

vertex.setPos(corner)

collisionVertex = P.EggVertex()

collisionVertex.setPos(corner)

renderQuad.addVertex(renderVP.addVertex(vertex))

collisionQuad.addVertex(collisionVP.addVertex(collisionVertex))

# A bug in Panda3D means that auto-triangulation of concave polygons

# fails for some combinations of vertices (the polygon is not properly

# transformed into triangles) creating gaps in a model where polygons are

# missing. We can check for this failure by calling

# EggPolygon.triangulateInto() and checking its return value. If False is

# returned we reverse the vertex order of the polygon (so it now faces

# downward instead of up) and reverse the backface flag so the downside

# (which is now facing up) is rendered instead of the upside (which is now

# facing down). The result looks more or less the same as if the polygon

# had triangulated correctly in the first place (except the shading will be

# different). Thanks to ynjh_jo for this workaround.

egn=P.EggGroupNode() # triangulateInto() stores the resulting polygons in

# an EggGroupNode, which we discard, we only care

# about the True or False return value

if not renderQuad.triangulateInto(egn,0):

# Triangulation failed, fix it.

renderQuad.reverseVertexOrdering()

renderQuad.setBfaceFlag(1)

collisionQuad.reverseVertexOrdering()

collisionQuad.setBfaceFlag(1)

renderQuad.recomputePolygonNormal() # Use faceted not smoothed lighting

"""Return a tuple of NodePaths (renderNodePath,collisionNodePath) to

renderable and collision geometry for a chainable terrain model built from

the given heightmap.

collisionNodePath is parented to renderNodePath. renderNodePath is not

parented to anything by this function.

Every 3x3 group of quads in the collision geometry is collected under a

PandaNode for efficient collision detection. This could be improved on by

building both the renderable and collision geometry as octrees.

Keyword arguments:

heightmap -- a 2D list of height values.

"""

size = len(heightmap)

renderNodePath = P.NodePath('')

renderEggData = P.EggData()

renderVertexPool = P.EggVertexPool('')

collisionNodePath = renderNodePath.attachNewNode('')

# Supply the EggGroup & EggVertexPool for the first node.

collisionVertexPool = P.EggVertexPool('')

collisionEggGroup = P.EggGroup('')

collisionEggGroup.addObjectType('barrier')

# We group every (numQuadGrid x numQuadGrid) quads under 1 collision node.

numQuadGrid=3

# The modulo of (size-2)/numQuadGrid marks when the quads must be grouped

# into 1 geom.

edgeMod=(size-2)%numQuadGrid

for i in range(0,len(heightmap)-1,numQuadGrid):

# Limit nextIrange to avoid it from jump over the edge.

nextIrange=min(numQuadGrid,len(heightmap)-1-i)

for j in range(0,len(heightmap)-1):

for nextI in range(0,nextIrange):

bl = P.Point3D(i+nextI,j,heightmap[i+nextI][j])

tr = P.Point3D(i+nextI+1,j+1,heightmap[i+nextI+1][j+1])

br = P.Point3D(i+nextI+1,j,heightmap[i+nextI+1][j])

tl = P.Point3D(i+nextI,j+1,heightmap[i+nextI][j+1])

# Construct polygons (quads) with makeQuads.

renderQuad,collisionQuad = makeQuad(renderVertexPool,

collisionVertexPool,

bl,tr,br,tl)

renderEggData.addChild(renderQuad)

collisionEggGroup.addChild(collisionQuad)

if j%numQuadGrid==edgeMod and nextI==nextIrange-1:

# Group the previous (numQuadGrid x numQuadGrid) quads under

# collision node.

collisionEggData = P.EggData()

collisionEggData.addChild(collisionEggGroup)

pandaNode = P.loadEggData(collisionEggData)

nodePath = collisionNodePath.attachNewNode(

pandaNode.getChild(0).getChild(0))

# Uncomment the next line to see the collision geom.

#nodePath.show()

# Supply the EggGroup & EggVertexPool for the next node.

collisionEggGroup = P.EggGroup('')

collisionEggGroup.addObjectType('barrier')

collisionVertexPool = P.EggVertexPool('')

pandaNode = P.loadEggData(renderEggData)

renderNodePath.attachNewNode(pandaNode)

"""Return a tuple of NodePaths (renderNodePath,collisionNodePath), already

attached into the Panda3D scene graph, to renderable and collision geometry

for a chainable fractal terrain model built to the given size and hilliness

values.

See also makeHeightMap() and makeTerrainFromHeightMap().

Keyword arguments:

size -- the size (in vertices) of one side of the square terriain model

(default 33) Note: only certain size values will be accepted, see

makeHeightMap().

h -- the 'hilliness' factor of the terrain (default 6)

"""

heightmap = makeHeightMap(size,h)

renderNodePath,collisionNodePath = makeTerrainFromHeightMap(heightmap)

"""Set a tag on the given model storing the models XY radius (ignoring how

short or tall it is in the Z dimension).

This radius tag can be retrieved later to (for example) create a collision

sphere that will bound the model

Arguments:

model -- the model to tag

"""

# Get the two points (in a list) that define the axis-aligned bounding

# box of the scaled model.

bounds=model.getTightBounds()

# Now subtract the two, giving a vector from one to the other, the

# length of which is the diameter of the aabb

vector=(bounds[1]-bounds[0])

# Take the greatest of the X and Y components of this vector, ignoring

# the Z component, and halve it go get the X/Y radius of the aabb

radius=max(vector[0],vector[1])*.5

# Store the radius in a tag attached to the model

"""Load a model from the file given by path, parent it to the given parent

node and return the NodePath to the newly loaded model.

Maintains a global dictionary of loaded models and if a model if called

twice for the same model the model is instanced instead of being loaded

again.

"""

global models

if models.has_key(path):

model = models[path].copyTo(parent)

scale = 0.75+random.random()/2

model.setScale(scale)

setRadiusTag(model)

else:

modelRoot = loader.loadModelCopy(path)

# New models are loaded in a non-standard way to allow flattenStrong

# to work effectively over them.

model = P.NodePath('model')

scale = 0.75+random.random()/2

model.setScale(scale)

modelRoot.getChildren().reparentTo(model)

model.reparentTo(parent)

setRadiusTag(model)

models[path] = model

def __init__(self,pos=None):

"""Initialise the tree."""

# Models and CollisionSolids are parented to one prime NodePath

if pos is None: pos = P.Vec3(0,0,0)

self.pos = pos

self.prime = P.NodePath('tree')

self.prime.setPos(self.pos)

dir = "models/trees" # FIXME: hardcoded models dir

# Choose a random model from dir and load it.

trees = [f for f in os.listdir(dir) if os.path.isfile(os.path.join(dir,f)) and f.endswith('.egg')]

tree = random.choice(trees)

self.np = loadModel(os.path.join(dir,tree),self.prime)

# TODO: Give each tree a random orientation

# Initialise the Tree's CollisionRay which is used with a

# CollisionHandlerQueue to find the height of the terrain below the

# tree and move the tree to that height (see self.step)

self.raynp = self.prime.attachNewNode(P.CollisionNode('colNode'))

self.raynp.node().addSolid(P.CollisionRay(0, 0, 3, 0, 0, -1))

self.handler = P.CollisionHandlerQueue()

cTrav.addCollider(self.raynp,self.handler)

#self.raynp.show()

# We only want our CollisionRay to collide with the collision

# geometry of the terrain, se we set a mask here.

self.raynp.node().setFromCollideMask(C.floorMASK)

self.raynp.node().setIntoCollideMask(C.offMASK)

# Add a task for this Tree to the global task manager.

taskMgr.add(self.step,"Tree step task")

def step(self,task):

if self.handler.getNumEntries() > 0:

self.handler.sortEntries()

entry = self.handler.getEntry(0)

point = entry.getSurfacePoint(render)

self.prime.setPos(render,point)

# Destroy the CollisionRay and related nodes and handlers, tell

# Panda that this function doesn't need to be called anymore.

cTrav.removeCollider(self.raynp)

self.handler = None

self.raynp.removeNode()

return Task.done

else:

# No collision with the terrain was found, wiggle the tree a bit

# (sometimes a tree's CollisionRay falls exactly through a tiny gap

# in the terrain model and does not collide).

self.prime.setX(self.prime.getX()+random.random())

self.prime.setY(self.prime.getY()+random.random())

def __init__(self,pos=None,color=(0.6,0.8,0.5,1),scale=12,h=8,size=33,trees=0.7):

# Initialise primary NodePath which everything else is parented to

if pos is None: pos = P.Vec3(0,0,0)

self.pos = pos

self.prime = P.NodePath('Terrain primary NodePath')

self.prime.setPos(self.pos)

# Create terrain models (rendering and collision)

self.tnp,self.collnp = makeTerrain(size=size,h=h)

self.tnp.reparentTo(self.prime)

self.tnp.setColor(*color)

self.tnp.setScale(scale)

# Shift the collision terrain a bit so rays from trees hit

self.collnp.setPos(self.collnp,.0001,.0001,0)

self.collnp.setCollideMask(C.floorMASK)

# All trees in the scene are parented to one NodePath for flattening

self.trees = self.prime.attachNewNode(P.PandaNode('trees'))

self.treesColl = self.prime.attachNewNode(P.CollisionNode('treesColl'))

self.treesColl.node().setIntoCollideMask(offMASK)

self.treesColl.node().setFromCollideMask(obstacleMASK)

#self.treesColl.show()

vehicleCTrav.addCollider(self.treesColl,obstacleHandler)

# Initialise trees

img = greenNoise(imgSize=(size,size),scale=0.25)

for x in range(0,size-1):

for y in range(0,size-1):

if img.getGreen(x,y) > trees:

treepos = P.Vec3(x*scale+0.5*scale,y*scale+0.5*scale,50)

tree = Tree(pos=treepos)

tree.prime.reparentTo(self.trees)

taskMgr.add(self.flatten,"Terrain flatten task")

def flatten(self,task):

if len(taskMgr.getTasksNamed("Tree step task")) == 0:

for t in self.trees.getChildrenAsList():

# Place a CollisionSphere over the model for obstacle avoidance

pos=t.getPos()

radius = t.getChild(0).getPythonTag('radius')

radius*=1.2 # Make CollisionSphere 20% wider than the model

s = SphereObstacle(pos[0],pos[1],pos[2]+radius,radius,show=True)

s.cnp.reparentTo(self.treesColl)

self.prime.flattenStrong()

print 'FLATTENED'

return Task.done

else:

"""A simple test/demo scene for this module."""

def __init__(self):

"""Initialise the test scene."""

# Show the framerate

base.setFrameRateMeter(True)

# Make 4 terrain nodepath objects with different hilliness values

# and arrange them side-by-side in a 2x2 grid, giving a big terrain

# with variable hilly and flat areas.

color = (0.6,0.8,0.5,1) # Bright green-ish

scale = 12

t1 = Terrain(color=color,scale=scale,trees=0.7)

t1.prime.reparentTo(render)

t2 = Terrain(color=color,scale=scale,h=24,pos=P.Vec3(32*scale,0,0),trees=0.5)

t2.prime.reparentTo(render)

t3 = Terrain(color=color,scale=scale,h=16,pos=P.Vec3(32*scale,32*scale,0),trees=0.3)

t3.prime.reparentTo(render)

t4 = Terrain(color=color,scale=scale,h=2,pos=P.Vec3(0,32*scale,0),trees=0.9)

t4.prime.reparentTo(render)

# Setup a camera.

base.disableMouse()

self.camera = Camera(P.Vec3(0,0,100))

self.camera.lookAt(320,320,0)

# Setup keyboard controls.

# Accept some keys to move the camera.

self.accept("a", self.camera.setControl, ["left",1])

self.accept("a-up", self.camera.setControl, ["left",0])

self.accept("d", self.camera.setControl, ["right",1])

self.accept("d-up", self.camera.setControl, ["right",0])

self.accept("w", self.camera.setControl, ["up",1])

self.accept("w-up", self.camera.setControl, ["up",0])

self.accept("s", self.camera.setControl, ["down",1])

self.accept("s-up", self.camera.setControl, ["down",0])

self.accept("arrow_up", self.camera.setControl, ["forward",1])

self.accept("arrow_up-up", self.camera.setControl, ["forward",0])

self.accept("arrow_down", self.camera.setControl, ["backward",1])

self.accept("arrow_down-up", self.camera.setControl, ["backward",0])

self.accept("arrow_left", self.camera.setControl, ["strafe-left",1])

self.accept("arrow_left-up", self.camera.setControl, ["strafe-left",0])

self.accept("arrow_right", self.camera.setControl, ["strafe-right",1])

self.accept("arrow_right-up", self.camera.setControl,["strafe-right",0])

# Accept the Esc key to exit.

self.accept("escape", sys.exit)

# Setup lighting.

self.alight = P.AmbientLight('alight')

self.alight.setColor(P.VBase4(0.35, 0.35, 0.35, 1))

self.alnp = render.attachNewNode(self.alight)

render.setLight(self.alnp)

self.dlight = P.DirectionalLight('dlight')

self.dlight.setColor(P.VBase4(0.4, 0.4, 0.4, 1))

self.dlnp = render.attachNewNode(self.dlight)

self.dlnp.setHpr(45, -45, 0)

render.setLight(self.dlnp)

self.plight = P.PointLight('plight')

self.plight.setColor(P.VBase4(0.8, 0.8, 0.5, 1))

self.plnp = render.attachNewNode(self.plight)

self.plnp.setPos(160, 160, 50)

self.slight = P.Spotlight('slight')

self.slight.setColor(P.VBase4(1, 1, 1, 1))

lens = P.PerspectiveLens()

self.slight.setLens(lens)

self.slnp = render.attachNewNode(self.slight)

self.slnp.setPos(-20, -20, 20)

self.slnp.lookAt(50,50,0)

# Setup some scene-wide exponential fog.

colour = (0.5,0.8,0.8)

self.expfog = P.Fog("Scene-wide exponential Fog object")

self.expfog.setColor(*colour)

self.expfog.setExpDensity(0.0005)

render.setFog(self.expfog)

base.setBackgroundColor(*colour)

# Event listeners. TODO: Register these with some keyboard or GUI

# events.

def toggleWireframe(self,status):

base.toggleWireframe()

def toggleFog(self,status):

if status:

render.setFog(self.expfog)

else:

render.clearFog()

def toggleAmbient(self,status):

if status:

render.setLight(self.alnp)

else:

render.clearLight(self.alnp)

def toggleDirectional(self,status):

if status:

render.setLight(self.dlnp)

else:

render.clearLight(self.dlnp)

def togglePoint(self,status):

if status:

render.setLight(self.plnp)

else:

render.clearLight(self.plnp)

def toggleSpot(self,status):

if status:

render.setLight(self.slnp)

else: