def loadEnvir(self):
terrain = GeoMipTerrain("terreno")
terrain.setHeightfield("terreno/preto.png")
terrain.setColorMap("terreno/tile_far.jpg")
terrain.getRoot().setScale(5,5,50)
terrain.getRoot().reparentTo(render)
terrain.generate()
def loadEnvir(self):
terrain = GeoMipTerrain("terreno")
terrain.setHeightfield("terreno/preto.png")
terrain.setColorMap("terreno/tile_far.jpg")
terrain.getRoot().setScale(5, 5, 50)
terrain.getRoot().reparentTo(render)
terrain.generate()
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
#standard GeoMipTerrain usage
self.terrain = GeoMipTerrain("worldTerrain")
self.terrain.setHeightfield("mapheight.png")
self.terrain.setColorMap("maptexture.png")
#self.terrain.setBruteforce(True)
#set dynamically updated terrain
self.terrain.setBlockSize(32)
self.terrain.setNearFar(128, 256) #distance in terrain coordinates
self.terrain.setMinLevel(0) #low means high quality
self.terrain.setFocalPoint(base.camera) #a NodePath
#get root
root = self.terrain.getRoot()
root.reparentTo(render)
root.setSz(100)
self.terrain.generate()
taskMgr.add(self.updateTask, "update")
self.camera.setPos(0, 0, 0)
#add person
self.player = Actor("girl4.x", {"girl03_03": "girl"})
print("girl loaded")
self.player.setPos(0, 5, -1)
self.player.reparentTo(self.render)
print("girl reparented")
def updateTask(self, task):
self.terrain.update()
return task.cont
def play(self, ai, difficult=False):
self.easyAI.destroy()
self.hardAI.destroy()
self.ai = None
self.cTrav = CollisionTraverser()
self.coll = CollisionHandlerEvent()
self.coll.addInPattern("%fn-into-%in")
self.clock = ClockObject()
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield("heightMap.png")
terrain.setColorMap("colormap.png")
terrain.setBruteforce(True)
root = terrain.getRoot()
root.reparentTo(self.render)
root.setSz(1)
terrain.generate()
self.player = Character("models/panda-model", 0.05, (300, 300, 0),
self.render, {"walk": "models/panda-walk4"},
self, self.path, 200, "player")
self.addControls()
self.loadUI()
self.startTasks()
self.accept("proj-into-player", self.player.changeLife, [-1])
self.others = dict()
self.roundOv = False
self.taskMgr.add(self.update, "Update")
self.gameOver = False
if ai:
self.aiBattle(difficult)
def __init__(self, data_source):
ShowBase.__init__(self)
if not os.path.isfile('world.bam'):
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield(os.path.join(RESOURCE_DIR, "uk_height_map_25.png"))
terrain.setColorMap(os.path.join(RESOURCE_DIR, "uk_flopped_rotated_25.png"))
terrain.setBruteforce(True)
root = terrain.getRoot()
root.reparentTo(render)
root.setSz(10)
terrain.generate()
root.writeBamFile('world.bam')
else:
world = loader.loadModel("world.bam")
world.reparentTo(render)
self.toasters = {}
self.toasters_by_zone = {}
for vm in data_source.get_vms():
height = len(self.toasters_by_zone.get(vm.zonename, []))
self.toasters[vm.name] = Toaster(vm.zonename, height, vm.state == "Running")
self.toasters_by_zone.setdefault(vm.zonename, []).append(self.toasters[vm.name])
# In Panda3D you have to cancel the default mouse control to set the camera explicitly
# Falsify the following 3 lines to allow it back again:
if True:
self.disableMouse()
self.camera.setPos(350, -100, 100)
self.camera.setHpr(0, -25, 0)
def __init__(self, data_source):
ShowBase.__init__(self)
if not os.path.isfile('world.bam'):
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield(
os.path.join(RESOURCE_DIR, "uk_height_map_25.png"))
terrain.setColorMap(
os.path.join(RESOURCE_DIR, "uk_flopped_rotated_25.png"))
terrain.setBruteforce(True)
root = terrain.getRoot()
root.reparentTo(render)
root.setSz(10)
terrain.generate()
root.writeBamFile('world.bam')
else:
world = loader.loadModel("world.bam")
world.reparentTo(render)
self.toasters = {}
self.toasters_by_zone = {}
for vm in data_source.get_vms():
height = len(self.toasters_by_zone.get(vm.zonename, []))
self.toasters[vm.name] = Toaster(vm.zonename, height,
vm.state == "Running")
self.toasters_by_zone.setdefault(vm.zonename,
[]).append(self.toasters[vm.name])
# In Panda3D you have to cancel the default mouse control to set the camera explicitly
# Falsify the following 3 lines to allow it back again:
if True:
self.disableMouse()
self.camera.setPos(350, -100, 100)
self.camera.setHpr(0, -25, 0)
def __init__(self):
ShowBase.__init__(self)
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield("height-map.png")
terrain.setColorMap("texture-map.png")
terrain.setBruteforce(True)
root = terrain.getRoot()
root.reparentTo(render)
root.setSz(60)
terrain.generate()
def __init__(self):
ShowBase.__init__(self) # initialise
terrain = GeoMipTerrain("worldTerrain") # create a terrain
terrain.setHeightfield("mapheight.png") # set the height map
terrain.setColorMap("maptex.png") # set the colour map
terrain.setBruteforce(True) # level of detail
root = terrain.getRoot() # capture root
root.reparentTo(render) # render from root
root.setSz(60) # maximum height
terrain.generate() # generate
def __init__(self):
ShowBase.__init__(self) # initialise
terrain = GeoMipTerrain("worldTerrain") # create a terrain
terrain.setHeightfield("gwadaHeightSmall.png") # set the height map
terrain.setColorMap("gwadaTextureSmall.jpg") # set the colour map
#terrain.setBruteforce(True) # level of detail
root = terrain.getRoot() # capture root
root.reparentTo(render) # render from root
root.setSz(60) # maximum height
terrain.generate() # generate
root.writeBamFile('world.bam') # create 3D model
def __init__(self):
ShowBase.__init__(self) # initialise
terrain = GeoMipTerrain("worldTerrain") # create a terrain
terrain.setHeightfield(height) # set the height map
terrain.setColorMap(texture) # set the colour map
terrain.setBruteforce(True) # level of detail
root = terrain.getRoot() # capture root
root.reparentTo(render) # render from root
root.setSz(2) # maximum height
terrain.generate() # generate
root.writeBamFile('models/world' + worldNameSuffix +
".bam") # create 3D model
def __init__(self):
ShowBase.__init__(self)
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield("models/issue1terrain.png")
terrain.setColorMap("models/issue2terrain.png")
terrain.setBruteforce(True) # level of detail
root = terrain.getRoot()
root.reparentTo(render)
root.setSz(60) # maximum height
terrain.generate()
root.writeBamFile("models/world.bam")
def __init__(self):
ShowBase.__init__(self)
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield("models/issue1terrain.png")
terrain.setColorMap("models/issue2terrain.png")
terrain.setBruteforce(True) # level of detail
root = terrain.getRoot()
root.reparentTo(render)
root.setSz(60) # maximum height
terrain.generate()
root.writeBamFile("models/world.bam")
def __init__(self):
ShowBase.__init__(self)
self.debug = False
self.statusLabel = self.makeStatusLabel(0)
self.collisionLabel = self.makeStatusLabel(1)
if os.path.isfile("assets/1stmap.bam"):
self.world = self.loader.loadModel("assets/1stmap.bam")
self.world.reparentTo(self.render)
else:
print "generating terrain and saving bam for future use"
terrain = GeoMipTerrain("worldTerrain")
terrain.setHeightfield("./assets/1stmap_HF.png")
terrain.setColorMap("./assets/1stmap_TM.png")
terrain.setBruteforce(True)
root = terrain.getRoot()
root.reparentTo(self.render)
root.setSz(60)
terrain.generate()
root.writeBamFile("./assets/1stmap.bam")
self.worldsize = 1024
# Player
self.maxspeed = 100.0
self.startPos = Vec3(200, 200, 35)
self.startHpr = Vec3(225, 0, 0)
self.player = self.loader.loadModel("assets/alliedflanker.egg")
self.player.setScale(0.2, 0.2, 0.2)
self.player.reparentTo(self.render)
self.resetPlayer()
# Player destruction
self.explosionModel = loader.loadModel("assets/explosion")
self.explosionModel.reparentTo(self.render)
self.explosionModel.setScale(0.0)
self.explosionModel.setLightOff()
# Only one explosion at a time
self.exploding = False
self.taskMgr.add(self.updateTask, "update")
self.keyboardSetup()
self.maxdistance = 600
self.camLens.setFar(self.maxdistance)
self.camLens.setFov(60)
self.createEnvironment()
self.setupCollisions()
self.textCounter = 0
class MyApp(ShowBase): # our 'class'
def __init__(self):
ShowBase.__init__(self) # initialise
self.terrain = GeoMipTerrain("worldTerrain") # create a terrain
self.terrain.setHeightfield(
"heightmapper-1567436259173.png") # set the height map
self.terrain.setColorMap(
"TexturesCom_Moss0138_2_L.jpg") # set the colour map
self.terrain.setBruteforce(True) # level of detail
root = self.terrain.getRoot() # capture root
root.reparentTo(self.render) # render from root
root.setSz(80) # maximum height
self.terrain.generate() # generate
self.sphere = self.loader.loadModel("skysphere-1.egg")
self.sphere.setScale(700)
self.sphere.setPos(500, 500, 0)
self.tex = self.loader.loadTexture("TexturesCom_Skies0282_L.jpg")
self.sphere.setTexture(self.tex)
self.sphere.reparentTo(self.render)
self.setupLight()
def setupLight(self):
self.sunLight = DirectionalLight("sun")
# sunLight.setColor(get_vbase4_from_hex('fbfcde'))
self.sunLight.setColor(VBase4(.99, .99, .99, 1))
self.light = self.render.attach_new_node(self.sunLight)
self.light.setHpr(45, -45, 0)
self.light.setPos(0, 0, 300)
self.render.setLight(self.light)
ambientLight = AmbientLight("ambient")
ambientLight.setColor(VBase4(0.2, 0.2, 0.2, 1))
self.ambientLight = self.render.attach_new_node(ambientLight)
self.render.setLight(self.ambientLight)
return
class Application(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.terrain = GeoMipTerrain("terrain")
#doesn't use search path
self.terrain.setHeightfield("../textures/height.png")
self.terrain.setColorMap("../textures/grass.png")
self.terrain.getRoot().setSz(35)
#self.terrain.setBlockSize(16)
#self.terrain.setNear(35)
#self.terrain.setFar(75)
self.terrain.getRoot().reparentTo(render)
self.terrain.generate()
z = self.terrain.getElevation(256, 256) * 40
self.cam.setPos(256, 256, z)
self.terrain.setFocalPoint(self.cam)
self.taskMgr.add(self.updateTerrain, "update terrain")
def updateTerrain(self, task):
self.terrain.update()
return task.cont
class Application(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.terrain = GeoMipTerrain("terrain")
self.terrain.setHeightfield("/e/models/height.bmp")
self.terrain.setColorMap("/e/models/grass.jpg")
#self.terrain.getRoot().setSz(100)
self.terrain.getRoot().reparentTo(self.render)
self.terrain.getRoot().setPos(0, 0, 0)
self.terrain.hide()
#z = self.terrain.getElevation(256, 256) * 40
#self.cam.setPos(0, 10, 50)
#self.cam.lookAt(5, 5, 0)
#self.terrain.setFocalPoint(self.cam)
self.taskMgr.add(self.updateTerrain, "updateTerrain")
def updateTerrain(self, task):
self.terrain.update()
return task.cont
class Application(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.height = 85.0
self.img = PNMImage(Filename('height1.png'))
self.shape = BulletHeightfieldShape(self.img, self.height, ZUp)
self.offset = self.img.getXSize() / 2.0 - 0.5
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(self.img)
self.terrain.setColorMap("grass.png")
self.terrainNP = self.terrain.getRoot()
self.terrainNP.setSz(self.height)
self.terrainNP.setPos(-self.offset, -self.offset, -self.height / 2.0)
self.terrain.getRoot().reparentTo(render)
self.terrain.generate()
self.node = BulletRigidBodyNode('Ground')
self.node.addShape(self.shape)
self.np = render.attachNewNode(self.node)
self.np.setPos(0, 0, 0)
self.world.attachRigidBody(self.node)
self.info = self.world.getWorldInfo()
self.info.setAirDensity(1.2)
self.info.setWaterDensity(0)
self.info.setWaterOffset(0)
self.info.setWaterNormal(Vec3(0, 0, 0))
self.cam.setPos(20, 20, 20)
self.cam.setHpr(0, 0, 0)
self.model = loader.loadModel('out6.egg')
#self.model.setPos(0.0, 0.0, 0.0)
self.model.flattenLight()
min, max = self.model.getTightBounds()
size = max
mmax = size[0]
if size[1] > mmax:
mmax = size[1]
if size[2] > mmax:
mmax = size[2]
self.rocketScale = 20.0/mmax / 2
shape = BulletBoxShape(Vec3(size[0]*self.rocketScale, size[1]*self.rocketScale, size[2]*self.rocketScale))
self.ghostshape = BulletBoxShape(Vec3(size[0]*self.rocketScale, size[1]*self.rocketScale, size[2]*self.rocketScale))
self.ghost = BulletRigidBodyNode('Ghost')
self.ghost.addShape(self.ghostshape)
self.ghostNP = render.attachNewNode(self.ghost)
self.ghostNP.setPos(19.2220401046, 17.5158313723, 35.2665607047 )
#self.ghostNP.setCollideMask(BitMask32(0x0f))
self.model.setScale(self.rocketScale)
self.world.attachRigidBody(self.ghost)
self.model.copyTo(self.ghostNP)
self.rocketnode = BulletRigidBodyNode('rocketBox')
self.rocketnode.setMass(1.0)
self.rocketnode.addShape(shape)
self.rocketnp = render.attachNewNode(self.rocketnode)
self.rocketnp.setPos(0.0, 0.0, 40.0)
tex = loader.loadTexture('crate.jpg')
self.model.find('**/Line001').setTexture(tex, 1)
#self.rocketnp.setTexture(tex)
self.model.setScale(self.rocketScale)
self.world.attachRigidBody(self.rocketnode)
self.model.copyTo(self.rocketnp)
self.hh = 35.0
print self.ghostNP.getPos()
self.accept('w', self.eventKeyW)
self.accept('r', self.eventKeyR)
self.taskMgr.add(self.update, 'update')
self.massive = self.getdata('data.txt')
self.massiveResampled = self.resample(self.massive)
self.posInArray = 0
self.x = 0.0
self.y = 0.0
self.z = 0.0
self.timerNow = 0.0
self.taskMgr.add(self.timerTask, 'timerTask')
def checkGhost(self):
'''
ghost = self.ghostNP.node()
if ghost.getNumOverlappingNodes() > 1:
print ghost.getNumOverlappingNodes()
for node in ghost.getOverlappingNodes():
print node
'''
result = self.world.contactTest(self.ghost)
for contact in result.getContacts():
print contact.getNode0()
print contact.getNode1()
def eventKeyW(self):
self.hh -= 1.0
def eventKeyR(self):
self.cam.setPos(self.x, self.y - 15.0, self.z + 2.50)
def resample(self, array):
len1 = len(array[0]) - 1
res = []
counter = 0
resamplerArray = []
bufArray = []
for i in xrange(len1):
resamplerArray.append(resampler(0.02, 0.125))
bufArray.append([])
for i in xrange(len(array)):
buf = []
for j in xrange(len1):
bufArray[j] = resamplerArray[j].feed(array[i][j+1])
for j in xrange(len(bufArray[0])):
buf.append(0.02*(counter))
for k in xrange(len1):
buf.append(bufArray[k][j])
res.append(buf)
counter += 1
buf = []
return res
def getdata(self, name):
array = []
with open(name) as f:
for line in f:
numbers_float = map(float, line.split())
array.append([numbers_float[0], numbers_float[1], numbers_float[2], numbers_float[3]])
return array
def update(self, task):
dt = globalClock.getDt()
#self.world.doPhysics(dt)
self.getMyPos(self.massiveResampled)
self.rocketnp.setPos(self.x, self.y, self.z)
self.cam.setPos(self.x, self.y - 15.0, self.z + 2.50)
return task.cont
def getMyPos(self, array):
flag = False
len1 = len(array)
if self.posInArray >= len1:
flag = True
while not flag:
if self.timerNow < array[self.posInArray][0]:
flag = True
self.x = array[self.posInArray][1]
self.y = array[self.posInArray][2]
self.z = array[self.posInArray][3]
break
else:
if self.posInArray >= len1:
flag = True
break
else:
self.posInArray += 1
self.checkGhost()
result = self.world.contactTest(self.rocketnode)
for contact in result.getContacts():
print contact.getNode0()
print contact.getNode1()
def timerTask(self, task):
self.timerNow = task.time
return Task.cont
class WorldGen(ShowBase): # our 'class'
def __init__(self):
if __name__ == '__main__':
ShowBase.__init__(self) # initialise
self.initTerrain()
self.initModels()
self.initPositions()
self.loadingStringParser(parameters["loadingString"])
# self.plotPosition()
if self.evenLoad:
self.evenInstance(self.evenObj,
scale=self.evenScale,
tex=self.evenTex,
z=self.evenZ)
if self.oddLoad:
self.oddInstance(self.oddObj,
scale=self.oddScale,
tex=self.oddTex,
z=self.oddZ)
# print " \n \n \n Generate is about to exit \n \n \n"
self.generate()
# print "kill is ", parameters["killWorldGen"]
# parameters["killWorldGen"]=False
if parameters["killWorldGen"]:
import sys
print " \n \n \n World Generate is about to exit \n \n \n"
sys.exit()
def initTerrain(self):
self.terrain = GeoMipTerrain("worldTerrain") # create a self.terrain
self.terrain.setHeightfield(
parameters["modelHeightMap"]) # set the height map
if parameters[
"loadNullModels"]: #if null, then create uniform back and sky
self.terrain.setColorMap(
parameters["modelTextureMapNull"]) # set the colour map
else:
self.terrain.setColorMap(
parameters["modelTextureMap"]) # set the colour map
self.terrain.setBruteforce(True) # level of detail
self.root = self.terrain.getRoot() # capture root
self.root.reparentTo(self.render) # render from root
self.root.setSz(0.2) # maximum height
self.terrain.generate() # generate
def initModels(self):
self.tree = self.loader.loadModel(parameters["treePath"])
self.greenSphere = self.loader.loadModel(parameters["spherePath"])
self.redSphere = self.loader.loadModel(parameters["spherePath"])
self.treeTex = self.loader.loadTexture(parameters["treeTexPath"])
self.greenTex = self.loader.loadTexture(parameters["greenTexPath"])
self.redTex = self.loader.loadTexture(parameters["redTexPath"])
def initPositions(self):
self.evenObj = self.oddObj = self.evenScale = self.oddScale = \
self.evenTex = self.oddTex = self.evenLoad = self.oddLoad =self.evenZ=self.oddZ= \
self.evenPlotColor=self.oddPlotColor=self.evenPlotMarker=self.oddPlotMarker=None
if parameters["hcp"]:
self.odd, self.even = self.hcpListGenerator(
heightObjects=parameters["heightObjects"],
widthObjects=parameters["widthObjects"],
lattice=parameters["lattice"])
elif parameters["quad"]:
self.odd, self.even = self.quadPositionGenerator()
# print "odd is",self.odd
# print "even is ", self.even
def hcpListGenerator(self, heightObjects, widthObjects, lattice):
self.posList = np.zeros([heightObjects * widthObjects, 2])
self.alternate = False
index = 0
for i in range(0, heightObjects):
y = i * lattice * (3**0.5) / 2
self.alternate = not self.alternate
for j in range(0, widthObjects):
if self.alternate:
x = j * lattice + (lattice / 2)
else:
x = j * lattice
self.posList[index, :] = [x, y]
index += 1
# self.posList[:,0]=np.linspace(0,100,num=(self.posList.shape)[0])
# self.posList[:,1]=np.linspace(0,100,num=(self.posList.shape)[0])
self.oddPosList = self.posList[1::2]
self.evenPosList = self.posList[0::2]
# print "odd is ",self.oddPosList
# print "even is", self.evenPosList
return self.oddPosList, self.evenPosList
def quadPositionGenerator(self):
offset = ((int(parameters["worldSize"]) - 1) / 2) + 1
quad3PosL = parameters["posL"]
quad3PosR = parameters["posR"]
quad4PosL = (parameters["posL"][0] + offset, parameters["posL"][1])
quad4PosR = (parameters["posR"][0] + offset, parameters["posR"][1])
quad2PosL = (parameters["posL"][0], parameters["posL"][1] + offset)
quad2PosR = (parameters["posR"][0], parameters["posR"][1] + offset)
quad1PosL = (parameters["posL"][0] + offset,
parameters["posL"][1] + offset)
quad1PosR = (parameters["posR"][0] + offset,
parameters["posR"][1] + offset)
#identical visual stim
# odd=np.array([quad1PosR,quad2PosR,quad3PosR,quad4PosR])
# even=np.array([quad1PosL,quad2PosL,quad3PosL,quad4PosL])
odd = np.array([quad1PosR, quad2PosL, quad3PosL, quad3PosR])
even = np.array([quad1PosL, quad2PosR, quad4PosL, quad4PosR])
# print offset
# print "even is ",odd
# print "even is ", even
return odd, even
def loadingStringParser(self, loadingString):
"""
Args:
loadingString:2 letter string,
r - red sphere
g - green sphere
t - tree
0 - None
1st letter is even instance
2nd letter is odd instance
Returns:
"""
if len(loadingString) > 2:
print "only 2 objects in world"
j = 0
for i in loadingString:
if i == "t":
obj = self.tree
tex = self.treeTex
scale = parameters["treeScale"]
z = parameters["treeZ"]
plotColor = "k"
plotMarker = "s"
load = True
elif i == "r":
obj = self.redSphere
tex = self.redTex
scale = parameters["sphereScale"]
z = parameters["sphereZ"]
plotColor = "r"
plotMarker = "o"
load = True
elif i == "g":
obj = self.greenSphere
tex = self.greenTex
scale = parameters["sphereScale"]
z = parameters["sphereZ"]
plotColor = "g"
plotMarker = "o"
load = True
else:
obj = None
tex = None
scale = None
z = None
plotColor = None
plotMarker = None
load = False
if j == 0:
self.evenObj = obj
self.evenTex = tex
self.evenScale = scale
self.evenZ = z
self.evenPlotColor = plotColor
self.evenPlotMarker = plotMarker
self.evenLoad = load
else:
self.oddObj = obj
self.oddTex = tex
self.oddScale = scale
self.oddZ = z
self.oddPlotColor = plotColor
self.oddPlotMarker = plotMarker
self.oddLoad = load
j += 1
def oddInstance(self, dummy, scale, tex, z):
dummy.setPos(tuple(parameters["origin"]))
dummy.setScale(scale)
dummy.setTexture(tex)
for i in range(self.odd.shape[0]):
self.oddPlaceholder = self.render.attach_new_node("odd Holder")
self.oddPlaceholder.setPos(self.odd[i][0], self.odd[i][1], z)
dummy.instanceTo(self.oddPlaceholder)
def evenInstance(self, dummy, scale, tex, z):
dummy.setPos(tuple(parameters["origin"]))
dummy.setScale(scale)
dummy.setTexture(tex)
for i in range(self.even.shape[0]):
evenPlaceholder = self.render.attach_new_node("even Holder")
evenPlaceholder.setPos(self.even[i][0], self.even[i][1], z)
dummy.instanceTo(evenPlaceholder)
def plotPositions(self):
self.tree = self.greenSphere = self.redSphere = self.treeTex = self.greenTex = self.redTex = None
self.loadingStringParser(parameters["loadingString"])
plt.scatter(self.odd[:, 0],
self.odd[:, 1],
color=self.oddPlotColor,
marker=self.oddPlotMarker,
s=80)
plt.scatter(self.even[:, 0],
self.even[:, 1],
color=self.evenPlotColor,
marker=self.evenPlotMarker,
s=80) #,marker='|',color='g')
def worldNameGen(self):
self.worldFilename = "models/world_" + "size:" + parameters["modelSizeSuffix"] \
+ "_obj:" + parameters["loadingString"] + "_num:" \
+ str(parameters["widthObjects"]) + "x" \
+ str(parameters["heightObjects"])+"_lattice:"\
+str(parameters["lattice"]) + ".bam"
print "world file name is ", self.worldFilename
def generate(self):
self.worldNameGen()
self.render.writeBamFile(self.worldFilename)
import direct.directbase.DirectStart
if True:
heightfieldIndex = 2
#zScale = sys.argv[1]
zScale = 60
#heightfieldFile = sys.argv[heightfieldIndex]
heightfieldFile = "a.png"
terrain = GeoMipTerrain("hey")
terrain.setHeightfield("terrain.png")
terrain.setColorMap("terrain_texture.png")
#terrain.setColorMap("colourmap.jpg")
#terrain.setBlockSize(512)
#terrain.setBruteforce(True)
terrain.generate()
root = terrain.getRoot()
root.setSz(60)
#textures1 = ["default_c.png", "maps/default_d.png", "maps/default_l.png",
# "textures/bigRockFace.png", "textures/hardDirt.png", "textures/grayRock.png", "textures/shortGrass.png"]
textures = ["hardDirt.png"]
class Simulation(ShowBase):
def __init__(self):
# Heightfield (static)
self.height = 38.0
ShowBase.__init__(self)
base.setBackgroundColor(0.1, 0.1, 0.8, 1)
base.setFrameRateMeter(True)
base.cam.setPos(0, -150, 200)
base.cam.lookAt(0, 0, 0)
# Light
alight = AmbientLight('ambientLight')
alight.setColor(Vec4(0.5, 0.5, 0.5, 1))
alightNP = render.attachNewNode(alight)
dlight = DirectionalLight('directionalLight')
dlight.setDirection(Vec3(1, 1, -1))
dlight.setColor(Vec4(0.7, 0.7, 0.7, 1))
dlightNP = render.attachNewNode(dlight)
render.clearLight()
render.setLight(alightNP)
render.setLight(dlightNP)
# Input
self.accept('escape', self.doExit)
inputState.watchWithModifiers('forward', 'w')
inputState.watchWithModifiers('left', 'a')
inputState.watchWithModifiers('reverse', 's')
inputState.watchWithModifiers('backward', 'x')
inputState.watchWithModifiers('right', 'd')
# Task
taskMgr.add(self.update, 'updateWorld')
# Physics
self.setup()
# _____HANDLER_____
def doExit(self):
self.cleanup()
sys.exit(1)
# ____TASK___
def processInput(self, dt):
for vehicle in self.controlVehicles:
engineForce = 0.0
brakeForce = 0.0
if inputState.isSet('forward'):
engineForce = 1000.0
brakeForce = 0.0
if inputState.isSet('backward'):
engineForce = -1000.0
brakeForce = 0.0
if inputState.isSet('reverse'):
engineForce = 0.0
brakeForce = 100.0
if inputState.isSet('left'):
vehicle.setAngle(True, dt)
if inputState.isSet('right'):
vehicle.setAngle(False, dt)
# Apply engine and brake to rear wheels
vehicle.setEngineForce(engineForce)
vehicle.setBrakeForce(brakeForce)
#print(vehicle.getAngle())
def update(self, task):
dt = globalClock.getDt()
self.processInput(dt)
self.world.doPhysics(dt, 10, 0.008)
self.terrain.update()
return task.cont
def cleanup(self):
self.world = None
self.worldNP.removeNode()
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, ))
#function that navigates a vehicle to go in a square
def goSquare(self, vehicle, size):
while (True):
goTo([size, size], vehicle)
goTo([size, -size], vehicle)
goTo([-size, -size], vehicle)
goTo([-size, size], vehicle)
#Borders around the map that vehicles won't fall from terrain
def makeMapBorders(self, offset):
plane1 = BulletPlaneShape(Vec3(1, 0, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border1'))
np.node().addShape(plane1)
np.setPos(-offset, -offset, -self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
plane2 = BulletPlaneShape(Vec3(0, 1, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border2'))
np.node().addShape(plane2)
np.setPos(-offset, -offset, -self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
plane3 = BulletPlaneShape(Vec3(0, -1, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border3'))
np.node().addShape(plane3)
np.setPos(offset, offset, self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
plane4 = BulletPlaneShape(Vec3(-1, 0, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border4'))
np.node().addShape(plane4)
np.setPos(offset, offset, self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
#getting height of map at some point
def getHeight(self):
line = CollisionLine(ox, oy, oz, dx, dy, dz)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
self.cam_away = 20
self.cam_elevation = 5
self.rot_rate = .5
self.cam_dist = (self.cam_away**2 + self.cam_elevation**2)**.5
#######
self.environ = GeoMipTerrain("terrain")
self.environ.setHeightfield("../terrain/first.png")
self.environ.setColorMap("../terrain/first-c.png")
self.environ.generate()
self.environ.getRoot().setScale(1, 1, 100)
self.environ.getRoot().setPos(0, 0, 0)
self.environ.getRoot().reparentTo(render)
self.environ.getRoot().setName("terrain")
self.environ.getRoot().setCollideMask(BitMask32.bit(0))
#######
self.pandaActor = Actor("models/panda", {"walk": "models/panda-walk"})
self.pandaActor.setScale(.5, .5, .5)
self.pandaActor.setHpr(180, 0, 0)
self.pandaActor.setPos(50, 50, 50)
self.pandaActor.reparentTo(render)
self.pandaActor.setPythonTag("moving", False)
self.avatarYawRot = 0
self.avatarPitchRot = 0
#self.teapot = loader.loadModel("models/teapot")
#self.teapot.setScale(1, 1, 1)
#self.teapot.setPos(60, 60, 50)
#self.teapot.reparentTo(render)
self.cam.setHpr(0, 0, 0)
self.taskMgr.add(self.updateTerrain, "update terrain", priority=35)
self.keys = {"w": 0, "s": 0, "a": 0, "d": 0}
self.accept("w", self.setKey, ["w", 1])
self.accept("w-up", self.setKey, ["w", 0])
self.accept("s", self.setKey, ["s", 1])
self.accept("s-up", self.setKey, ["s", 0])
self.accept("a", self.setKey, ["a", 1])
self.accept("a-up", self.setKey, ["a", 0])
self.accept("d", self.setKey, ["d", 1])
self.accept("d-up", self.setKey, ["d", 0])
self.accept("wheel_up", self.zoomCamera, [-1])
self.accept("wheel_down", self.zoomCamera, [1])
self.accept('window-event', self.handleWindowEvent)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.last_mouse_x = self.win.getPointer(0).getX()
#self.last_mouse_y = self.win.getPointer(0).getY()
self.cTrav = CollisionTraverser()
self.pandaGroundRay = CollisionRay(0, 0, 0, 0, 0, 1)
self.pandaGroundRayNode = CollisionNode('pandaGroundRay')
self.pandaGroundRayNode.addSolid(self.pandaGroundRay)
self.pandaGroundRayNode.setFromCollideMask(BitMask32.bit(0))
self.pandaGroundRayNode.setIntoCollideMask(BitMask32.allOff())
self.pandaGroundRayNodepath = self.pandaActor.attachNewNode(
self.pandaGroundRayNode)
self.pandaGroundRayNodepath.show()
self.pandaGroundCollisionHandler = CollisionHandlerFloor()
self.pandaGroundCollisionHandler.addCollider(
self.pandaGroundRayNodepath, self.pandaActor)
self.cTrav.addCollider(self.pandaGroundRayNodepath,
self.pandaGroundCollisionHandler)
#self.teapotRay = CollisionSphere(0,0,0,5)
#self.teapotGroundCol = CollisionNode('teapotRay')
#self.teapotGroundCol.addSolid(self.teapotRay)
#self.teapotGroundCol.setFromCollideMask(BitMask32.allOff())
#self.teapotGroundCol.setIntoCollideMask(BitMask32.bit(0))
#self.teapotGroundColNp = self.teapot.attachNewNode(self.teapotGroundCol)
#self.teapotGroundHandler = CollisionHandlerQueue()
#self.cTrav.addCollider(self.teapotGroundColNp, self.teapotGroundHandler)
def setKey(self, key, value):
self.keys[key] = value
def handleWindowEvent(self, window=None):
wp = window.getProperties()
self.win_center_x = wp.getXSize() / 2
self.win_center_y = wp.getYSize() / 2
def zoomCamera(self, direction):
self.cam_away += direction
def updateTerrain(self, task):
dt = globalClock.getDt()
self.pandaActor.setY(self.pandaActor, -50 * dt)
if self.keys["w"]: self.pandaActor.setZ(self.pandaActor, 20 * dt)
if self.keys["s"]: self.pandaActor.setZ(self.pandaActor, -20 * dt)
if self.keys["a"]: self.pandaActor.setX(self.pandaActor, 20 * dt)
if self.keys["d"]: self.pandaActor.setX(self.pandaActor, -20 * dt)
mouse_pos = self.win.getPointer(0)
#Mouse-based viewpoint rotation
current_mouse_x = mouse_pos.getX()
#current_mouse_y = mouse_pos.getY()
mouse_shift_x = current_mouse_x - self.last_mouse_x
#mouse_shift_y = current_mouse_y - self.last_mouse_y
self.last_mouse_x = current_mouse_x
#self.last_mouse_y = current_mouse_y
if current_mouse_x == 0 or current_mouse_x >= (self.win_center_x *
1.5):
base.win.movePointer(0, self.win_center_x, self.win_center_y)
self.last_mouse_x = self.win_center_x
#if current_mouse_y == 0 or current_mouse_y >= (self.win_center_y * 1.5):
# base.win.movePointer(0, self.win_center_x, self.win_center_y)
# self.last_mouse_y = self.win_center_y
yaw_shift = -((mouse_shift_x) * self.rot_rate)
#pitch_shift = -((mouse_shift_y) * self.rot_rate)
self.avatarYawRot += yaw_shift
#self.avatarPitchRot += pitch_shift
self.pandaActor.setH(self.pandaActor, yaw_shift)
self.cam.setH(self.cam, yaw_shift)
cam_x_adjust = self.cam_away * sin(radians(self.avatarYawRot))
cam_y_adjust = self.cam_away * cos(radians(self.avatarYawRot))
self.cam.setPos(self.pandaActor.getX() + cam_x_adjust,
self.pandaActor.getY() - cam_y_adjust,
self.pandaActor.getZ() + self.cam_elevation)
#self.cTrav.traverse(render)
#entries = []
#for i in range(self.pandaGroundCollisionHandler.getNumEntries()):
# entry = self.pandaGroundCollisionHandler.getEntry(i)
# entries.append(entry)
#for entry in entries:
# print entry.getIntoNode().getName()
# if entry.getIntoNode().getName() == "terrain":
# print "shiet"
# self.pandaActor.setZ(entry.getSurfacePoint(render).getZ())
return Task.cont
import direct.directbase.DirectStart
if True:
heightfieldIndex = 2
#zScale = sys.argv[1]
zScale = 60
#heightfieldFile = sys.argv[heightfieldIndex]
heightfieldFile = "a.png"
terrain = GeoMipTerrain("hey")
terrain.setHeightfield("bin/terrain.png")
terrain.setColorMap("bin/terrain_texure.png")
#terrain.setColorMap("colourmap.jpg")
#terrain.setBlockSize(512)
#terrain.setBruteforce(True)
terrain.generate()
root = terrain.getRoot()
root.setSz(5)
print root.getBounds()
for i in range(0, 128):
print terrain.getElevation(128, i + 1)
import direct.directbase.DirectStart
if True:
heightfieldIndex = 2
#zScale = sys.argv[1]
zScale = 60
#heightfieldFile = sys.argv[heightfieldIndex]
heightfieldFile = "a.png"
terrain = GeoMipTerrain("hey")
terrain.setHeightfield("bin/terrain.png")
terrain.setColorMap("bin/terrain_texure.png")
#terrain.setColorMap("colourmap.jpg")
#terrain.setBlockSize(512)
#terrain.setBruteforce(True)
terrain.generate()
root = terrain.getRoot()
root.setSz(5)
print root.getBounds()
for i in range(0, 128):
print terrain.getElevation(128, i+1)
import direct.directbase.DirectStart
if True:
heightfieldIndex = 2
#zScale = sys.argv[1]
zScale = 60
#heightfieldFile = sys.argv[heightfieldIndex]
heightfieldFile = "a.png"
terrain = GeoMipTerrain("hey")
terrain.setHeightfield("terrain.png")
terrain.setColorMap("terrain_texture.png")
#terrain.setColorMap("colourmap.jpg")
#terrain.setBlockSize(512)
#terrain.setBruteforce(True)
terrain.generate()
root = terrain.getRoot()
root.setSz(60)
#textures1 = ["default_c.png", "maps/default_d.png", "maps/default_l.png",
# "textures/bigRockFace.png", "textures/hardDirt.png", "textures/grayRock.png", "textures/shortGrass.png"]
textures = ["hardDirt.png"]
textures = []
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
self.cam_away = 20
self.cam_elevation = 5
self.rot_rate = .5
self.cam_dist = (self.cam_away**2 + self.cam_elevation**2) ** .5
#######
self.environ = GeoMipTerrain("terrain")
self.environ.setHeightfield("../terrain/first.png")
self.environ.setColorMap("../terrain/first-c.png")
self.environ.generate()
self.environ.getRoot().setScale(1, 1, 100)
self.environ.getRoot().setPos(0, 0, 0)
self.environ.getRoot().reparentTo(render)
self.environ.getRoot().setName("terrain")
self.environ.getRoot().setCollideMask(BitMask32.bit(0))
#######
self.pandaActor = Actor("models/panda",
{"walk": "models/panda-walk"})
self.pandaActor.setScale(.5, .5, .5)
self.pandaActor.setHpr(180, 0, 0)
self.pandaActor.setPos(50, 50, 50)
self.pandaActor.reparentTo(render)
self.pandaActor.setPythonTag("moving", False)
self.avatarYawRot = 0
self.avatarPitchRot = 0
#self.teapot = loader.loadModel("models/teapot")
#self.teapot.setScale(1, 1, 1)
#self.teapot.setPos(60, 60, 50)
#self.teapot.reparentTo(render)
self.cam.setHpr(0, 0, 0)
self.taskMgr.add(self.updateTerrain, "update terrain", priority = 35)
self.keys = {"w" : 0, "s" : 0, "a" : 0, "d" : 0}
self.accept("w", self.setKey, ["w", 1])
self.accept("w-up", self.setKey, ["w", 0])
self.accept("s", self.setKey, ["s", 1])
self.accept("s-up", self.setKey, ["s", 0])
self.accept("a", self.setKey, ["a", 1])
self.accept("a-up", self.setKey, ["a", 0])
self.accept("d", self.setKey, ["d", 1])
self.accept("d-up", self.setKey, ["d", 0])
self.accept("wheel_up", self.zoomCamera, [-1])
self.accept("wheel_down", self.zoomCamera, [1])
self.accept('window-event', self.handleWindowEvent)
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
self.last_mouse_x = self.win.getPointer(0).getX()
#self.last_mouse_y = self.win.getPointer(0).getY()
self.cTrav = CollisionTraverser()
self.pandaGroundRay = CollisionRay(0,0,0,0,0,1)
self.pandaGroundRayNode = CollisionNode('pandaGroundRay')
self.pandaGroundRayNode.addSolid(self.pandaGroundRay)
self.pandaGroundRayNode.setFromCollideMask(BitMask32.bit(0))
self.pandaGroundRayNode.setIntoCollideMask(BitMask32.allOff())
self.pandaGroundRayNodepath = self.pandaActor.attachNewNode(self.pandaGroundRayNode)
self.pandaGroundRayNodepath.show()
self.pandaGroundCollisionHandler = CollisionHandlerFloor()
self.pandaGroundCollisionHandler.addCollider(self.pandaGroundRayNodepath, self.pandaActor)
self.cTrav.addCollider(self.pandaGroundRayNodepath, self.pandaGroundCollisionHandler)
#self.teapotRay = CollisionSphere(0,0,0,5)
#self.teapotGroundCol = CollisionNode('teapotRay')
#self.teapotGroundCol.addSolid(self.teapotRay)
#self.teapotGroundCol.setFromCollideMask(BitMask32.allOff())
#self.teapotGroundCol.setIntoCollideMask(BitMask32.bit(0))
#self.teapotGroundColNp = self.teapot.attachNewNode(self.teapotGroundCol)
#self.teapotGroundHandler = CollisionHandlerQueue()
#self.cTrav.addCollider(self.teapotGroundColNp, self.teapotGroundHandler)
def setKey(self, key, value):
self.keys[key] = value
def handleWindowEvent(self, window=None):
wp = window.getProperties()
self.win_center_x = wp.getXSize() / 2
self.win_center_y = wp.getYSize() / 2
def zoomCamera(self, direction):
self.cam_away += direction
def updateTerrain(self, task):
dt = globalClock.getDt()
self.pandaActor.setY(self.pandaActor, -50 * dt)
if self.keys["w"]: self.pandaActor.setZ(self.pandaActor, 20 * dt)
if self.keys["s"]: self.pandaActor.setZ(self.pandaActor, -20 * dt)
if self.keys["a"]: self.pandaActor.setX(self.pandaActor, 20 * dt)
if self.keys["d"]: self.pandaActor.setX(self.pandaActor, -20 * dt)
mouse_pos = self.win.getPointer(0)
#Mouse-based viewpoint rotation
current_mouse_x = mouse_pos.getX()
#current_mouse_y = mouse_pos.getY()
mouse_shift_x = current_mouse_x - self.last_mouse_x
#mouse_shift_y = current_mouse_y - self.last_mouse_y
self.last_mouse_x = current_mouse_x
#self.last_mouse_y = current_mouse_y
if current_mouse_x == 0 or current_mouse_x >= (self.win_center_x * 1.5):
base.win.movePointer(0, self.win_center_x, self.win_center_y)
self.last_mouse_x = self.win_center_x
#if current_mouse_y == 0 or current_mouse_y >= (self.win_center_y * 1.5):
# base.win.movePointer(0, self.win_center_x, self.win_center_y)
# self.last_mouse_y = self.win_center_y
yaw_shift = -((mouse_shift_x) * self.rot_rate)
#pitch_shift = -((mouse_shift_y) * self.rot_rate)
self.avatarYawRot += yaw_shift
#self.avatarPitchRot += pitch_shift
self.pandaActor.setH(self.pandaActor, yaw_shift)
self.cam.setH(self.cam, yaw_shift)
cam_x_adjust = self.cam_away*sin(radians(self.avatarYawRot))
cam_y_adjust = self.cam_away*cos(radians(self.avatarYawRot))
self.cam.setPos(self.pandaActor.getX() + cam_x_adjust, self.pandaActor.getY() - cam_y_adjust,
self.pandaActor.getZ() + self.cam_elevation)
#self.cTrav.traverse(render)
#entries = []
#for i in range(self.pandaGroundCollisionHandler.getNumEntries()):
# entry = self.pandaGroundCollisionHandler.getEntry(i)
# entries.append(entry)
#for entry in entries:
# print entry.getIntoNode().getName()
# if entry.getIntoNode().getName() == "terrain":
# print "shiet"
# self.pandaActor.setZ(entry.getSurfacePoint(render).getZ())
return Task.cont
