def SetupBulletTerrain(self):
self.worldNP = self.render.attachNewNode('World')
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
img = PNMImage(Filename(self.PngDEM))
if self.MeterScale < 1.1:
shape = BulletHeightfieldShape(img, self.HeightRange, ZUp)
else:
shape = BulletHeightfieldShape(img, self.HeightRange, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Heightfield'))
np.node().addShape(shape)
offset = self.MeterScale * self.PixelNr / 2.0
np.setPos(+offset, +offset,
+(self.HeightRange / 2.0) + self.OffsetHeight)
np.setSx(self.MeterScale)
np.setSy(self.MeterScale)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
def __init__(self, game, imgPath, height):
self.game = game
self.img = PNMImage(Filename(imgPath))
self.shape = BulletHeightfieldShape(self.img, height, 2)
self.node = BulletRigidBodyNode('Ground')
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(0, 0, 0)
self.np.setScale(1, 1, 1)
self.game.world.attachRigidBody(self.node)
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(self.img)
self.terrain.generate()
self.terrainNP = self.terrain.getRoot()
self.offset = self.img.getXSize() / 2.0 - 0.5
self.terrainNP.setSz(height)
self.terrainNP.setPos(-self.offset, -self.offset, -height / 2.0)
#self.terrainNP.flattenStrong()
self.terrainNP.reparentTo(self.np)
self.terrainNP.show()
self.debugOff()
self.slice_able = False
self.terrain.setBlockSize(32)
self.terrain.setNear(100)
self.terrain.setFar(400)
self.terrain.setFocalPoint(self.game.playerNp)
def patch_done(self, patch):
heightmap_patch = patch.owner.heightmap.get_heightmap(patch)
shape = BulletHeightfieldShape(heightmap_patch.texture,
patch.owner.heightmap.height_scale, ZUp)
shape.setUseDiamondSubdivision(True)
self.instance = NodePath(BulletRigidBodyNode('Heightfield'))
self.instance.node().add_shape(shape)
x = (heightmap_patch.x0 + heightmap_patch.x1) / 2.0
y = (heightmap_patch.y0 + heightmap_patch.y1) / 2.0
z = patch.owner.heightmap.height_scale / 2
size = heightmap_patch.x1 - heightmap_patch.x0
self.instance.set_pos(x, y, z)
self.instance.set_scale(size / heightmap_patch.width,
size / heightmap_patch.height, 1.0)
self.instance.setCollideMask(BitMask32.allOn())
self.physics.add(self.instance)
def createMap(self):
height = 10.0
img = PNMImage(Filename('resources/map1.bmp'))
shape = BulletHeightfieldShape(img, height, ZUp)
node = BulletRigidBodyNode('Map')
node.setMass(99999999)
node.addShape(shape)
self.world.attachRigidBody(node)
offset = img.getXSize() / 2.0 - 0.5
terrain = GeoMipTerrain('terrain')
terrain.setHeightfield(img)
terrainNP = terrain.getRoot()
terrainNP.setSz(height)
terrainNP.setPos(-offset, -offset, -height / 2.0)
#terrain.setColorMap('resources/map1color.bmp')
terrain.setAutoFlatten(GeoMipTerrain.AFMOff)
terrain.generate()
return Map(terrainNP, node)
def setup_terrain(self):
"""
Terrain info
Units are meters, which is preferable when working with Bullet.
"""
self.terrain_scale = LVector3(512, 512, 100)
self.terrain_pos = LVector3(-256, -256, -70)
# sample values for a 4096 x 4096px heightmap.
#self.terrain_scale = LVector3(4096, 4096, 1000)
#self.terrain_pos = LVector3(-2048, -2048, -70)
"""
Diamond_subdivision is an alternating triangulation scheme and may
produce better results.
"""
use_diamond_subdivision = True
"""
Construct the terrain
Without scaling, any ShaderTerrainMesh is 1x1x1 units.
"""
self.terrain_node = ShaderTerrainMesh()
"""
Set a heightfield, the heightfield should be a 16-bit png and
have a quadratic size of a power of two.
"""
heightfield = Texture()
heightfield.read(self.heightfield_fn)
heightfield.set_keep_ram_image(True)
self.terrain_node.heightfield = heightfield
# Display characteristic values of the heightfield texture
#minpoint, maxpoint, avg = LPoint3(), LPoint3(), LPoint3()
#heightfield.calc_min_max(minpoint, maxpoint)
#heightfield.calc_average_point(avg, 0.5, 0.5, 0.5)
#print("avg: {} min: {} max: {}".format(avg.x, minpoint.x, maxpoint.x))
"""
Set the target triangle width. For a value of 10.0 for example,
the ShaderTerrainMesh will attempt to make every triangle 10 pixels
wide on screen.
"""
self.terrain_node.target_triangle_width = 10.0
if use_diamond_subdivision:
"""
This has to be specified before calling .generate()
The default is false.
"""
load_prc_file_data("", "stm-use-hexagonal-layout true")
self.terrain_node.generate()
"""
Attach the terrain to the main scene and set its scale. With no scale
set, the terrain ranges from (0, 0, 0) to (1, 1, 1)
"""
self.terrain = self.render.attach_new_node(self.terrain_node)
self.terrain.set_scale(self.terrain_scale)
self.terrain.set_pos(self.terrain_pos)
"""
Set a vertex and a fragment shader on the terrain. The
ShaderTerrainMesh only works with an applied shader.
"""
terrain_shader = Shader.load(Shader.SL_GLSL,
"samples/shader-terrain/terrain.vert.glsl",
"samples/shader-terrain/terrain.frag.glsl")
self.terrain.set_shader(terrain_shader)
self.terrain.set_shader_input("camera", base.camera)
# Set some texture on the terrain
grass_tex = self.loader.load_texture(
"samples/shader-terrain/textures/grass.png")
grass_tex.set_minfilter(SamplerState.FT_linear_mipmap_linear)
grass_tex.set_anisotropic_degree(16)
self.terrain.set_texture(grass_tex)
"""
Set up the DynamicHeightfield (it's a type of PfmFile). We load the
same heightfield image as with ShaderTerrainMesh.
"""
self.DHF = DynamicHeightfield()
self.DHF.read(self.heightfield_fn)
"""
Set up empty PfmFiles to prepare stuff in that is going to
dynamically modify our terrain.
"""
self.StagingPFM = PfmFile()
self.RotorPFM = PfmFile()
"""
Set up the BulletHeightfieldShape (=collision terrain) and give it
some sensible physical properties.
"""
self.HFS = BulletHeightfieldShape(self.DHF, self.terrain_scale.z,
STM=True)
if use_diamond_subdivision:
self.HFS.set_use_diamond_subdivision(True)
HFS_rigidbody = BulletRigidBodyNode("BulletTerrain")
HFS_rigidbody.set_static(True)
friction = 2.0
HFS_rigidbody.set_anisotropic_friction(
LVector3(friction, friction, friction/1.3))
HFS_rigidbody.set_restitution(0.3)
HFS_rigidbody.add_shape(self.HFS)
self.world.attach(HFS_rigidbody)
HFS_NP = NodePath(HFS_rigidbody)
HFS_NP.reparent_to(self.worldNP)
"""
This aligns the Bullet terrain with the ShaderTerrainMesh rendered
terrain. It will be exact as long as the terrain vertex shader from
the STM sample is used and no additional tessellation shader.
For Bullet (as for other physics engines) the origin of objects is at
the center.
"""
HFS_NP.set_pos(self.terrain_pos + self.terrain_scale/2)
HFS_NP.set_sx(self.terrain_scale.x / heightfield.get_x_size())
HFS_NP.set_sy(self.terrain_scale.y / heightfield.get_y_size())
# Disables Bullet debug rendering for the terrain, because it is slow.
#HFS_NP.node().set_debug_enabled(False)
"""
Finally, link the ShaderTerrainMesh and the BulletHeightfieldShape to
the DynamicHeightfield. From now on changes to the DynamicHeightfield
will propagate to the (visible) ShaderTerrainMesh and the (collidable)
BulletHeightfieldShape.
"""
self.HFS.set_dynamic_heightfield(self.DHF)
self.terrain_node.set_dynamic_heightfield(self.DHF)
def setupHeightmap(self, name):
# Automatically generate a heightmap mesh from a monochrome image.
self.hmHeight = 120
hmPath = "../maps/map" + name + "/map" + name + "-h.png"
imPath = "../maps/map" + name + "/map" + name + "-i.png"
smPath = "../maps/map" + name + "/map" + name + "-s.png"
scmPath = "../maps/map" + name + "/map" + name + "-sc.png"
print(hmPath)
print(imPath)
print(smPath)
print(scmPath)
hmImg = PNMImage(Filename(hmPath))
hmShape = BulletHeightfieldShape(hmImg, self.hmHeight, ZUp)
hmNode = BulletRigidBodyNode('Terrain')
hmNode.addShape(hmShape)
hmNode.setMass(0)
self.hmNP = render.attachNewNode(hmNode)
self.worldBullet.attachRigidBody(hmNode)
self.hmOffset = hmImg.getXSize() / 2.0 - 0.5
self.hmTerrain = GeoMipTerrain('gmTerrain')
self.hmTerrain.setHeightfield(hmImg)
# Optimizations and fixes
self.hmTerrain.setBruteforce(
True) # I don't think this is actually needed.
self.hmTerrain.setMinLevel(3) # THIS is what triangulates the terrain.
self.hmTerrain.setBlockSize(
128) # This does a pretty good job of raising FPS.
# Level-of-detail (not yet working)
# self.hmTerrain.setNear(40)
# self.hmTerrain.setFar(200)
self.hmTerrain.generate()
self.hmTerrainNP = self.hmTerrain.getRoot()
self.hmTerrainNP.setSz(self.hmHeight)
self.hmTerrainNP.setPos(-self.hmOffset, -self.hmOffset,
-self.hmHeight / 2.0)
self.hmTerrainNP.flattenStrong(
) # This only reduces the number of nodes; nothing to do with polys.
self.hmTerrainNP.analyze()
# Here begins the scenery mapping
treeModel = loader.loadModel("../res/models/tree_1.egg")
rockModel = loader.loadModel("../res/models/rock_1.egg")
rock2Model = loader.loadModel("../res/models/rock_2.egg")
rock3Model = loader.loadModel("../res/models/rock_3.egg")
# caveModel = loader.loadModel("../res/models/cave_new.egg")
# planeFrontModel = loader.loadModel("../res/models/plane_front.egg")
# planeWingModel = loader.loadModel("../res/models/plane_wing.egg")
texpk = loader.loadTexture(scmPath).peek()
# GameObject nodepath for flattening
self.objNP = render.attachNewNode("gameObjects")
self.treeNP = self.objNP.attachNewNode("goTrees")
self.rockNP = self.objNP.attachNewNode("goRocks")
self.rock2NP = self.objNP.attachNewNode("goRocks2")
self.rock3NP = self.objNP.attachNewNode("goRocks3")
# self.caveNP = self.objNP.attachNewNode("goCave")
# self.planeFrontNP = self.objNP.attachNewNode("goPlaneFront")
# self.planeWingNP = self.objNP.attachNewNode("goPlaneWing")
for i in range(0, texpk.getXSize()):
for j in range(0, texpk.getYSize()):
color = VBase4(0, 0, 0, 0)
texpk.lookup(color,
float(i) / texpk.getXSize(),
float(j) / texpk.getYSize())
if (int(color.getX() * 255.0) == 255.0):
newTree = self.treeNP.attachNewNode("treeNode")
treeModel.instanceTo(newTree)
newTree.setPos(
i - texpk.getXSize() / 2, j - texpk.getYSize() / 2,
self.hmTerrain.get_elevation(i, j) * self.hmHeight -
self.hmHeight / 2)
# newTree.setScale(randint(0,4))
newTree.setScale(2)
if (int(color.getX() * 255.0) == 128):
newRock = self.rockNP.attachNewNode("newRock")
newRock.setPos(
i - texpk.getXSize() / 2, j - texpk.getYSize() / 2,
self.hmTerrain.get_elevation(i, j) * self.hmHeight -
self.hmHeight / 2)
rockModel.instanceTo(newRock)
if (int(color.getX() * 255.0) == 77):
newRock2 = self.rock2NP.attachNewNode("newRock2")
newRock2.setPos(
i - texpk.getXSize() / 2, j - texpk.getYSize() / 2,
self.hmTerrain.get_elevation(i, j) * self.hmHeight -
self.hmHeight / 2)
rock2Model.instanceTo(newRock2)
if (int(color.getX() * 255.0) == 102):
newRock3 = self.rock3NP.attachNewNode("newRock3")
newRock3.setPos(
i - texpk.getXSize() / 2, j - texpk.getYSize() / 2,
self.hmTerrain.get_elevation(i, j) * self.hmHeight -
self.hmHeight / 2)
rock3Model.instanceTo(newRock3)
# if(int(color.getX() * 255.0) == 64):
# newCave = self.caveNP.attachNewNode("newCave")
# newCave.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
# newCave.setScale(5)
# newCave.setP(180)
# caveModel.instanceTo(newCave)
# if(int(color.getX() * 255.0) == 191):
# newPlaneFront = self.planeFrontNP.attachNewNode("newPlaneFront")
# newPlaneFront.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
# newPlaneFront.setScale(6)
# planeFrontModel.instanceTo(newPlaneFront)
# if(int(color.getX() * 255.0) == 179):
# newPlaneWing = self.planeWingNP.attachNewNode("newPlaneWing")
# newPlaneWing.setPos(i - texpk.getXSize() / 2, j - texpk.getYSize() / 2, self.hmTerrain.get_elevation(i, j) * self.hmHeight - self.hmHeight / 2)
# newPlaneWing.setScale(6)
# newPlaneWing.setH(250)
# newPlaneWing.setR(180)
# newPlaneWing.setP(135)
# planeWingModel.instanceTo(newPlaneWing)
self.snowflakes = []
for i in xrange(0, self.snowflakeCount):
print("Call " + str(i))
sf = SMCollect(self.worldBullet, self.worldObj,
self.snowflakePositions[i])
self.snowflakes.append(sf)
# render.flattenStrong()
self.hmTerrainNP.reparentTo(render)
# Here begins the attribute mapping
ts = TextureStage("stage-alpha")
ts.setSort(0)
ts.setPriority(1)
ts.setMode(TextureStage.MReplace)
ts.setSavedResult(True)
self.hmTerrainNP.setTexture(ts, loader.loadTexture(imPath, smPath))
ts = TextureStage("stage-stone")
ts.setSort(1)
ts.setPriority(1)
ts.setMode(TextureStage.MReplace)
self.hmTerrainNP.setTexture(
ts, loader.loadTexture("../res/textures/stone_tex.png"))
self.hmTerrainNP.setTexScale(ts, 32, 32)
ts = TextureStage("stage-ice")
ts.setSort(2)
ts.setPriority(1)
ts.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture,
TextureStage.COSrcColor, TextureStage.CSPrevious,
TextureStage.COSrcColor,
TextureStage.CSLastSavedResult,
TextureStage.COSrcColor)
self.hmTerrainNP.setTexture(
ts, loader.loadTexture("../res/textures/ice_tex.png"))
self.hmTerrainNP.setTexScale(ts, 32, 32)
ts = TextureStage("stage-snow")
ts.setSort(3)
ts.setPriority(0)
ts.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture,
TextureStage.COSrcColor, TextureStage.CSPrevious,
TextureStage.COSrcColor,
TextureStage.CSLastSavedResult,
TextureStage.COSrcAlpha)
self.hmTerrainNP.setTexture(
ts, loader.loadTexture("../res/textures/snow_tex_1.png"))
self.hmTerrainNP.setTexScale(ts, 32, 32)
# print(self.snowflakes)
return hmNode
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showNormals(True)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box (dynamic)
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(0, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.boxNP = np # For applying force & torque
visualNP = loader.loadModel('models/box.egg')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
# Heightfield (static)
height = 8.0
img = PNMImage(Filename('models/elevation.png'))
shape = BulletHeightfieldShape(img, height, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Heightfield'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.hf = np.node() # To enable/disable debug visualisation
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(img)
self.terrain.setBlockSize(32)
self.terrain.setNear(50)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
rootNP = self.terrain.getRoot()
rootNP.reparentTo(render)
rootNP.setSz(8.0)
offset = img.getXSize() / 2.0 - 0.5
rootNP.setPos(-offset, -offset, -height / 2.0)
self.terrain.generate()
def setupPhysics(self, **kwargs):
self.barn = sceneModel(
modelName='models/environmentModels/sceneModels/New folder.egg',
world=kwargs['world'],
dynamic=False)
self.modelList.append(self.barn)
self.barn.model.setScale(.14)
self.barn.nodePath.setPos(8, -5, -1.2)
self.barn.nodePath.setScale(.4)
self.barn.model.setZ(self.barn.nodePath.getZ())
self.mainNp = kwargs['world'].attachNewNode(
BulletRigidBodyNode('Heightfield'))
self.debugNP = kwargs['world'].attachNewNode(BulletDebugNode('Debug'))
self.crate = sceneModel(
modelName='models/environmentModels/sceneModels/crate.egg',
world=kwargs['world'],
dynamic=True)
self.crate.nodePath.setScale(.06)
self.modelList.append(self.crate)
self.crate.nodePath.setPos(self.barn.nodePath, (-4, -3, -.9))
self.crate.model.setPos(self.crate.nodePath, (15.8, 5.6, -1.9))
self.crate.model.setScale(1.2)
self.debugNP.show()
self.debugNP.node().showNormals(True)
height = 10.0
skytexture = loader.loadTexture(
'models/environmentModels/sceneModels/sky/tex/skydome.png')
self.sky.setTexture(skytexture)
self.sky.reparentTo(kwargs['world'])
img = PNMImage(
Filename(
'models/environmentModels/eartharena/tex/terrainHeight.png'))
shape = BulletHeightfieldShape(img, height, ZUp)
shape.setUseDiamondSubdivision(True)
self.mainNp.node().addShape(shape)
self.mainNp.setPos(0, 0, .01)
self.mainNp.setScale(.340)
self.mainNp.setCollideMask(kwargs['mask'])
self.terrain.setHeightfield(
Filename(
'models/environmentModels/eartharena/tex/terrainHeight.png'))
self.terrain.setBlockSize(64)
self.terrain.setNear(50)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
rootNp = self.terrain.getRoot()
rootNp.reparentTo(render)
rootNp.setSz(15)
texture = loader.loadTexture(
'models/environmentModels/eartharena/tex/nova_TX.jpg')
rootNp.setTexture(texture)
offset = img.getXSize() / 2.0 - 0.25
rootNp.setPos(-offset, -offset, -height / 2.0)
self.terrain.generate()
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
#height map
# Filename:
# small -> 'Maps/HeightMapSmall.png'
# big -> 'Maps/HeightMapBig.png'
img = PNMImage(Filename('Maps/HeightMapSmall.png'))
shape = BulletHeightfieldShape(img, self.height, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Heightfield'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
#adding Texture
#setColorMap:
#small -> 'Maps/TextureMapSmall.jpg'
#big -> 'Maps/TextureMapBig.jpg'
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(img)
self.terrain.setColorMap('Maps/TextureMapSmall.jpg')
self.terrain.setBruteforce(True) # level of detail
self.terrain.setBlockSize(32)
self.terrain.setNear(50)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
rootNP = self.terrain.getRoot()
rootNP.reparentTo(render)
rootNP.setSz(self.height)
offset = img.getXSize() / 2.0 - 0.5
rootNP.setPos(-offset, -offset, -self.height / 2.0)
self.makeMapBorders(offset)
self.terrain.generate()
# creating vehicles
#controlled vehicles
self.controlVehicles = []
self.controlVehicles.append(
Vehicle(0, 00, 40, "B", self.worldNP, self.world))
#vehicles goint to a specific point
#self.squareVeh = Vehicle(0, 50, 40, "G", self.worldNP, self.world)
#thread.start_new_thread(self.goSquare, (self.squareVeh, 100))
#vehicles following user
#self.followVehicles = []
#self.followVehicles.append(Vehicle(-offset+10, -offset+10, 40, "R", self.worldNP, self.world))
#self.followVehicles.append(Vehicle(offset-10, offset-10, 60, "R", self.worldNP, self.world))
#for veh in self.followVehicles:
# thread.start_new_thread(follow, (veh, self.controlVehicles[0]))
#vehicles for hill climbing
self.hillVehicles = []
self.hillVehicles.append(
Vehicle(-offset + 10, -offset + 10, 40, "R", self.worldNP,
self.world))
self.hillVehicles.append(
Vehicle(offset - 10, offset - 10, 60, "R", self.worldNP,
self.world))
for veh in self.hillVehicles:
thread.start_new_thread(blindClimb, (veh, ))
