def makeTextureMap(self):
'''Citymania function that generates and sets the 4 channel texture map'''
self.colorTextures = []
for terrain in self.terrains:
terrain.getRoot().clearTexture()
heightmap = terrain.heightfield()
colormap = PNMImage(heightmap.getXSize() - 1,
heightmap.getYSize() - 1)
colormap.addAlpha()
slopemap = terrain.makeSlopeImage()
for x in range(0, colormap.getXSize()):
for y in range(0, colormap.getYSize()):
# Else if statements used to make sure one channel is used per pixel
# Also for some optimization
# Snow. We do things funky here as alpha will be 1 already.
if heightmap.getGrayVal(x, y) < 200:
colormap.setAlpha(x, y, 0)
else:
colormap.setAlpha(x, y, 1)
# Beach. Estimations from http://www.simtropolis.com/omnibus/index.cfm/Main.SimCity_4.Custom_Content.Custom_Terrains_and_Using_USGS_Data
if heightmap.getGrayVal(x, y) < 62:
colormap.setBlue(x, y, 1)
# Rock
elif slopemap.getGrayVal(x, y) > 170:
colormap.setRed(x, y, 1)
else:
colormap.setGreen(x, y, 1)
colorTexture = Texture()
colorTexture.load(colormap)
colorTS = TextureStage('color')
colorTS.setSort(0)
colorTS.setPriority(1)
self.colorTextures.append((colorTexture, colorTS))
def makeTextureMap(self):
'''Citymania function that generates and sets the 4 channel texture map'''
self.colorTextures = []
for terrain in self.terrains:
terrain.getRoot().clearTexture()
heightmap = terrain.heightfield()
colormap = PNMImage(heightmap.getXSize()-1, heightmap.getYSize()-1)
colormap.addAlpha()
slopemap = terrain.makeSlopeImage()
for x in range(0, colormap.getXSize()):
for y in range(0, colormap.getYSize()):
# Else if statements used to make sure one channel is used per pixel
# Also for some optimization
# Snow. We do things funky here as alpha will be 1 already.
if heightmap.getGrayVal(x, y) < 200:
colormap.setAlpha(x, y, 0)
else:
colormap.setAlpha(x, y, 1)
# Beach. Estimations from http://www.simtropolis.com/omnibus/index.cfm/Main.SimCity_4.Custom_Content.Custom_Terrains_and_Using_USGS_Data
if heightmap.getGrayVal(x,y) < 62:
colormap.setBlue(x, y, 1)
# Rock
elif slopemap.getGrayVal(x, y) > 170:
colormap.setRed(x, y, 1)
else:
colormap.setGreen(x, y, 1)
colorTexture = Texture()
colorTexture.load(colormap)
colorTS = TextureStage('color')
colorTS.setSort(0)
colorTS.setPriority(1)
self.colorTextures.append((colorTexture, colorTS))
class Node:
def __init__(self, np, reflectiveness):
self.nodePath = np
self.stage = TextureStage(self.nodePath.getName() + "-cubemap_stage")
self.stage.setPriority(1)
self.stage.setMode(TextureStage.MModulate)
self.stage.setColor(
VBase4(reflectiveness, reflectiveness, reflectiveness, 1.0))
self.nodePath.setTexGen(self.stage, TexGenAttrib.MWorldCubeMap)
self.currentCube = None
def clearCurrentCube(self):
if self.currentCube:
if self.nodePath and not self.nodePath.isEmpty():
#self.nodePath.clearTexProjector(self.stage)
self.nodePath.clearTexture(self.stage)
self.currentCube = None
def setCurrentCube(self, cube):
self.clearCurrentCube()
self.currentCube = cube
if self.nodePath and not self.nodePath.isEmpty():
#self.nodePath.setTexProjector(self.stage, self.currentCube.projector, self.nodePath)
self.nodePath.setTexture(self.stage, self.currentCube.cubeTex)
def cleanup(self):
self.clearCurrentCube()
if self.nodePath and not self.nodePath.isEmpty():
self.nodePath.clearTexGen(self.stage)
self.nodePath = None
self.stage = None
class TerrainManager(DirectObject.DirectObject):
def __init__(self):
self.accept("mouse1", self.lclick)
self.waterType = 2
self.water = None
self.citycolors = {0: VBase3D(1, 1, 1)}
self.accept('generateRegion', self.generateWorld)
self.accept('regenerateRegion', self.regenerateWorld)
self.accept("regionView_normal", self.setSurfaceTextures)
self.accept("regionView_owners", self.setOwnerTextures)
self.accept("regionView_foundNew", self.regionViewFound)
self.accept("updateRegion", self.updateRegion)
self.accept("enterCityView", self.enterCity)
# View: 0, region, # cityid
self.view = 0
self.ownerview = False
def lclick(self):
cell = picker.getMouseCell()
print "Cell:", cell
blockCoords = self.terrain.getBlockFromPos(cell[0], cell[1])
block = self.terrain.getBlockNodePath(blockCoords[0], blockCoords[1])
print "Block coords:", blockCoords
print "NodePath:", block
print "Elevation:", self.terrain.getElevation(cell[0], cell[1])
if not self.view:
messenger.send("clickForCity", [cell])
def switchWater(self):
print "Switch Water"
self.waterType += 1
if self.waterType > 2:
self.waterType = 0
self.generateWater(self.waterType)
def generateWorld(self, heightmap, tiles, cities, container):
self.heightmap = heightmap
self.terrain = PagedGeoMipTerrain("surface")
#self.terrain = GeoMipTerrain("surface")
self.terrain.setHeightfield(self.heightmap)
#self.terrain.setFocalPoint(base.camera)
self.terrain.setBruteforce(True)
self.terrain.setBlockSize(64)
self.terrain.generate()
root = self.terrain.getRoot()
root.reparentTo(render)
#root.setSz(100)
self.terrain.setSz(100)
messenger.send('makePickable', [root])
if self.heightmap.getXSize() > self.heightmap.getYSize():
self.size = self.heightmap.getXSize() - 1
else:
self.size = self.heightmap.getYSize() - 1
self.xsize = self.heightmap.getXSize() - 1
self.ysize = self.heightmap.getYSize() - 1
# Set multi texture
# Source http://www.panda3d.org/phpbb2/viewtopic.php?t=4536
self.generateSurfaceTextures()
self.generateWaterMap()
self.generateOwnerTexture(tiles, cities)
#self.terrain.makeTextureMap()
colormap = PNMImage(heightmap.getXSize() - 1, heightmap.getYSize() - 1)
colormap.addAlpha()
slopemap = self.terrain.makeSlopeImage()
for x in range(0, colormap.getXSize()):
for y in range(0, colormap.getYSize()):
# Else if statements used to make sure one channel is used per pixel
# Also for some optimization
# Snow. We do things funky here as alpha will be 1 already.
if heightmap.getGrayVal(x, y) < 200:
colormap.setAlpha(x, y, 0)
else:
colormap.setAlpha(x, y, 1)
# Beach. Estimations from http://www.simtropolis.com/omnibus/index.cfm/Main.SimCity_4.Custom_Content.Custom_Terrains_and_Using_USGS_Data
if heightmap.getGrayVal(x, y) < 62:
colormap.setBlue(x, y, 1)
# Rock
elif slopemap.getGrayVal(x, y) > 170:
colormap.setRed(x, y, 1)
else:
colormap.setGreen(x, y, 1)
self.colorTexture = Texture()
self.colorTexture.load(colormap)
self.colorTS = TextureStage('color')
self.colorTS.setSort(0)
self.colorTS.setPriority(1)
self.setSurfaceTextures()
self.generateWater(2)
taskMgr.add(self.updateTerrain, "updateTerrain")
print "Done with terrain generation"
messenger.send("finishedTerrainGen", [[self.xsize, self.ysize]])
self.terrain.getRoot().analyze()
self.accept("h", self.switchWater)
def regenerateWorld(self):
'''Regenerates world, often upon city exit.'''
self.terrain.generate()
root = self.terrain.getRoot()
root.reparentTo(render)
self.terrain.setSz(100)
messenger.send('makePickable', [root])
# Set multi texture
# Source http://www.panda3d.org/phpbb2/viewtopic.php?t=4536
#self.generateSurfaceTextures()
self.generateWaterMap()
self.setSurfaceTextures()
self.generateWater(2)
print "Done with terrain regeneration"
messenger.send("finishedTerrainGen", [[self.xsize, self.ysize]])
def generateWaterMap(self):
''' Iterate through every pix of color map. This will be very slow so until faster method is developed, use sparingly
getXSize returns pixels length starting with 1, subtract 1 for obvious reasons
We also slip in checking for the water card size, which should only change when the color map does
'''
print "GenerateWaterMap"
self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax = -1, 0, -1, 0
for x in range(0, self.heightmap.getXSize() - 1):
for y in range(0, self.heightmap.getYSize() - 1):
# Else if statements used to make sure one channel is used per pixel
# Also for some optimization
# Snow. We do things funky here as alpha will be 1 already.
if self.heightmap.getGrayVal(x, y) < 62:
# Water card dimensions here
# Y axis flipped from texture space to world space
if self.waterXMin == -1 or x < self.waterXMin:
self.waterXMin = x
if not self.waterYMax:
self.waterYMax = y
if y < self.waterYMax:
self.waterYMax = y
if x > self.waterXMax:
self.waterXMax = x
if y > self.waterYMin:
self.waterYMin = y
# Transform y coords
self.waterYMin = self.size - 64 - self.waterYMin
self.waterYMax = self.size - 64 - self.waterYMax
def generateOwnerTexture(self, tiles, cities):
'''Generates a simple colored texture to be applied to the city info region overlay.
Due to different coordinate systems (terrain org bottom left, texture top left)
some conversions are needed,
Also creates and sends a citylabels dict for the region view
'''
self.citymap = PNMImage(self.xsize, self.ysize)
citylabels = cities
scratch = {}
# Setup for city labels
for ident in cities:
scratch[ident] = []
# conversion for y axis
ycon = []
s = self.ysize - 1
for y in range(self.ysize):
ycon.append(s)
s -= 1
for ident, city in cities.items():
if ident not in self.citycolors:
self.citycolors[ident] = VBase3D(random.random(),
random.random(),
random.random())
for tile in tiles:
self.citymap.setXel(tile.coords[0], ycon[tile.coords[1]],
self.citycolors[tile.cityid])
# Scratch for labeling
if tile.cityid:
scratch[tile.cityid].append((tile.coords[0], tile.coords[1]))
for ident, values in scratch.items():
xsum = 0
ysum = 0
n = 0
for coords in values:
xsum += coords[0]
ysum += coords[1]
n += 1
xavg = xsum / n
yavg = ysum / n
print "Elevation:", self.terrain.getElevation(xavg, yavg)
z = self.terrain.getElevation(xavg, yavg) * 100
citylabels[ident]["position"] = (xavg, yavg, z + 15)
print "Citylabels:", citylabels
messenger.send("updateCityLabels", [citylabels, self.terrain])
def generateSurfaceTextures(self):
# Textureize
self.grassTexture = loader.loadTexture("Textures/grass.png")
self.grassTS = TextureStage('grass')
self.grassTS.setSort(1)
self.rockTexture = loader.loadTexture("Textures/rock.jpg")
self.rockTS = TextureStage('rock')
self.rockTS.setSort(2)
self.rockTS.setCombineRgb(TextureStage.CMAdd,
TextureStage.CSLastSavedResult,
TextureStage.COSrcColor,
TextureStage.CSTexture,
TextureStage.COSrcColor)
self.sandTexture = loader.loadTexture("Textures/sand.jpg")
self.sandTS = TextureStage('sand')
self.sandTS.setSort(3)
self.sandTS.setPriority(5)
self.snowTexture = loader.loadTexture("Textures/ice.png")
self.snowTS = TextureStage('snow')
self.snowTS.setSort(4)
self.snowTS.setPriority(0)
# Grid for city placement and guide and stuff
self.gridTexture = loader.loadTexture("Textures/grid.png")
self.gridTexture.setWrapU(Texture.WMRepeat)
self.gridTexture.setWrapV(Texture.WMRepeat)
self.gridTS = TextureStage('grid')
self.gridTS.setSort(5)
self.gridTS.setPriority(10)
def enterCity(self, ident, city, position, tiles):
'''Identifies which terrain blocks city belogs to and disables those that are not
A lot of uneeded for loops in here. Will need to find a better way later.'''
#root = self.terrain.getRoot()
children = []
for terrain in self.terrain.terrains:
root = terrain.getRoot()
children += root.getChildren()
keepBlocks = []
# Reset water dimentions
self.waterXMin = 0
self.waterXMax = 0
self.waterYMin = 0
self.waterYMax = 0
for tile in tiles:
blockCoords = self.terrain.getBlockFromPos(tile.coords[0],
tile.coords[1])
block = self.terrain.getBlockNodePath(blockCoords[0],
blockCoords[1])
if block not in keepBlocks:
keepBlocks.append(block)
if self.heightmap.getGrayVal(tile.coords[0],
self.size - tile.coords[1]) < 62:
# Water card dimensions here
# Y axis flipped from texture space to world space
if not self.waterXMin:
self.waterXMin = tile.coords[0]
if not self.waterYMin:
self.waterYMin = tile.coords[1]
if tile.coords[1] > self.waterYMax:
self.waterYMax = tile.coords[1]
if tile.coords[0] > self.waterXMax:
self.waterXMax = tile.coords[0]
if tile.coords[0] < self.waterXMin:
self.waterXMin = tile.coords[0]
if tile.coords[1] < self.waterYMin:
self.waterYMin = tile.coords[1]
for child in children:
if child not in keepBlocks:
child.detachNode()
self.view = ident
self.generateWater(2)
def newTerrainOverlay(self, task):
root = self.terrain.getRoot()
position = picker.getMouseCell()
if position:
# Check to make sure we do not go out of bounds
if position[0] < 32:
position = (32, position[1])
elif position[0] > self.xsize - 32:
position = (self.xsize - 32, position[1])
if position[1] < 32:
position = (position[0], 32)
elif position[1] > self.ysize - 32:
position = (position[0], self.size - 32)
root.setTexOffset(self.tileTS, -(position[0] - 32) / 64,
-(position[1] - 32) / 64)
return task.cont
def regionViewFound(self):
'''Gui for founding a new city!'''
self.setOwnerTextures()
root = self.terrain.getRoot()
task = taskMgr.add(self.newTerrainOverlay, "newTerrainOverlay")
tileTexture = loader.loadTexture("Textures/tile.png")
tileTexture.setWrapU(Texture.WMClamp)
tileTexture.setWrapV(Texture.WMClamp)
self.tileTS = TextureStage('tile')
self.tileTS.setSort(6)
self.tileTS.setMode(TextureStage.MDecal)
#self.tileTS.setColor(Vec4(1,0,1,1))
root.setTexture(self.tileTS, tileTexture)
root.setTexScale(self.tileTS, self.terrain.xchunks,
self.terrain.ychunks)
self.acceptOnce("mouse1", self.regionViewFound2)
self.acceptOnce("escape", self.cancelRegionViewFound)
def regionViewFound2(self):
'''Grabs cell location for founding.
The texture coordinate is used as the mouse may enter an out of bounds area.
'''
root = self.terrain.getRoot()
root_position = root.getTexOffset(self.tileTS)
# We offset the position of the texture, so we will now put the origin of the new city not on mouse cursor but the "bottom left" of it. Just need to add 32 to get other edge
position = [
int(abs(root_position[0] * 64)),
int(abs(root_position[1] * 64))
]
self.cancelRegionViewFound()
messenger.send("found_city_name", [position])
def cancelRegionViewFound(self):
taskMgr.remove("newTerrainOverlay")
root = self.terrain.getRoot()
root.clearTexture(self.tileTS)
# Restore original mouse function
self.accept("mouse1", self.lclick)
messenger.send("showRegionGUI")
def setSurfaceTextures(self):
self.ownerview = False
root = self.terrain.getRoot()
root.clearTexture()
#self.terrain.setTextureMap()
root.setTexture(self.colorTS, self.colorTexture)
root.setTexture(self.grassTS, self.grassTexture)
root.setTexScale(self.grassTS, self.size / 8, self.size / 8)
root.setTexture(self.rockTS, self.rockTexture)
root.setTexScale(self.rockTS, self.size / 8, self.size / 8)
root.setTexture(self.sandTS, self.sandTexture)
root.setTexScale(self.sandTS, self.size / 8, self.size / 8)
root.setTexture(self.snowTS, self.snowTexture)
root.setTexScale(self.snowTS, self.size / 8, self.size / 8)
root.setTexture(self.gridTS, self.gridTexture)
root.setTexScale(self.gridTS, self.xsize, self.ysize)
root.setShaderInput('size', self.xsize, self.ysize, self.size,
self.size)
root.setShader(loader.loadShader('Shaders/terraintexture.sha'))
def setOwnerTextures(self):
self.ownerview = True
root = self.terrain.getRoot()
root.clearShader()
root.clearTexture()
cityTexture = Texture()
cityTexture.load(self.citymap)
cityTS = TextureStage('citymap')
cityTS.setSort(0)
root.setTexture(self.gridTS, self.gridTexture)
root.setTexScale(self.gridTS, self.terrain.xchunks,
self.terrain.ychunks)
root.setTexture(cityTS, cityTexture, 1)
def updateRegion(self, heightmap, tiles, cities):
self.generateOwnerTexture(tiles, cities)
if self.ownerview:
self.setOwnerTextures()
def updateTerrain(self, task):
'''Updates terrain and water'''
self.terrain.update()
# Water
if self.waterType is 2:
pos = base.camera.getPos()
render.setShaderInput('time', task.time)
mc = base.camera.getMat()
self.water.changeCameraPos(pos, mc)
self.water.changeCameraPos(pos, mc)
#print "Render diagnostics"
#render.analyze()
#base.cTrav.showCollisions(render)
return task.cont
def generateWater(self, style):
print "Generate Water:", self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax
'''Generates water
style 0: blue card
style 1: reflective card
style 2: reflective card with shaders
'''
self.waterHeight = 22.0
if self.water:
self.water.removeNode()
if style is 0:
cm = CardMaker("water")
#cm.setFrame(-1, 1, -1, 1)
cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin,
self.waterYMax)
cm.setColor(0, 0, 1, 0.9)
self.water = render.attachNewNode(cm.generate())
if self.waterYMax > self.waterXMax:
size = self.waterYMax
else:
size = self.waterXMax
self.water.lookAt(0, 0, -1)
self.water.setZ(self.waterHeight)
messenger.send('makePickable', [self.water])
elif style is 1:
# From Prosoft's super awesome terrain demo
cm = CardMaker("water")
#cm.setFrame(-1, 1, -1, 1)
cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin,
self.waterYMax)
self.water = render.attachNewNode(cm.generate())
if self.waterYMax > self.waterXMax:
size = self.waterYMax
else:
size = self.waterXMax
#self.water.setScale(size)
self.water.lookAt(0, 0, -1)
self.water.setZ(self.waterHeight)
self.water.setShaderOff(1)
self.water.setLightOff(1)
self.water.setAlphaScale(0.5)
self.water.setTransparency(TransparencyAttrib.MAlpha)
wbuffer = base.win.makeTextureBuffer("water", 512, 512)
wbuffer.setClearColorActive(True)
wbuffer.setClearColor(base.win.getClearColor())
self.wcamera = base.makeCamera(wbuffer)
self.wcamera.reparentTo(render)
self.wcamera.node().setLens(base.camLens)
self.wcamera.node().setCameraMask(BitMask32.bit(1))
self.water.hide(BitMask32.bit(1))
wtexture = wbuffer.getTexture()
wtexture.setWrapU(Texture.WMClamp)
wtexture.setWrapV(Texture.WMClamp)
wtexture.setMinfilter(Texture.FTLinearMipmapLinear)
self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, self.water.getZ()))
wplanenp = render.attachNewNode(PlaneNode("water", self.wplane))
tmpnp = NodePath("StateInitializer")
tmpnp.setClipPlane(wplanenp)
tmpnp.setAttrib(CullFaceAttrib.makeReverse())
self.wcamera.node().setInitialState(tmpnp.getState())
self.water.projectTexture(TextureStage("reflection"), wtexture,
self.wcamera)
messenger.send('makePickable', [self.water])
elif style is 2:
# From Clcheung just as super awesome demomaster
self.water_level = Vec4(0.0, 0.0, self.waterHeight, 1.0)
self.water = water.WaterNode(self.waterXMin, self.waterYMin,
self.waterXMax, self.waterYMax,
self.water_level.getZ())
self.water.setStandardControl()
self.water.changeParams(None)
wl = self.water_level
wl.setZ(wl.getZ() - 0.05)
#root.setShaderInput('waterlevel', self.water_level)
render.setShaderInput('time', 0)
messenger.send('makePickable', [self.water.waterNP])
class PlayerBase(DirectObject):
def __init__(self):
# Player Model setup
self.player = Actor("Player",
{"Run":"Player-Run",
"Sidestep":"Player-Sidestep",
"Idle":"Player-Idle"})
self.player.setBlend(frameBlend = True)
self.player.setPos(0, 0, 0)
self.player.pose("Idle", 0)
self.player.reparentTo(render)
self.player.hide()
self.footstep = base.audio3d.loadSfx('footstep.ogg')
self.footstep.setLoop(True)
base.audio3d.attachSoundToObject(self.footstep, self.player)
# Create a brush to paint on the texture
splat = PNMImage("../data/Splat.png")
self.colorBrush = PNMBrush.makeImage(splat, 6, 6, 1)
CamMask = BitMask32.bit(0)
AvBufMask = BitMask32.bit(1)
self.avbuf = None
if base.win:
self.avbufTex = Texture('avbuf')
self.avbuf = base.win.makeTextureBuffer('avbuf', 256, 256, self.avbufTex, True)
cam = Camera('avbuf')
cam.setLens(base.camNode.getLens())
self.avbufCam = base.cam.attachNewNode(cam)
dr = self.avbuf.makeDisplayRegion()
dr.setCamera(self.avbufCam)
self.avbuf.setActive(False)
self.avbuf.setClearColor((1, 0, 0, 1))
cam.setCameraMask(AvBufMask)
base.camNode.setCameraMask(CamMask)
# avbuf renders everything it sees with the gradient texture.
tex = loader.loadTexture('gradient.png')
np = NodePath('np')
np.setTexture(tex, 100)
np.setColor((1, 1, 1, 1), 100)
np.setColorScaleOff(100)
np.setTransparency(TransparencyAttrib.MNone, 100)
np.setLightOff(100)
cam.setInitialState(np.getState())
#render.hide(AvBufMask)
# Setup a texture stage to paint on the player
self.paintTs = TextureStage('paintTs')
self.paintTs.setMode(TextureStage.MDecal)
self.paintTs.setSort(10)
self.paintTs.setPriority(10)
self.tex = Texture('paint_av_%s'%id(self))
# Setup a PNMImage that will hold the paintable texture of the player
self.imageSizeX = 64
self.imageSizeY = 64
self.p = PNMImage(self.imageSizeX, self.imageSizeY, 4)
self.p.fill(1)
self.p.alphaFill(0)
self.tex.load(self.p)
self.tex.setWrapU(self.tex.WMClamp)
self.tex.setWrapV(self.tex.WMClamp)
# Apply the paintable texture to the avatar
self.player.setTexture(self.paintTs, self.tex)
# team
self.playerTeam = ""
# A lable that will display the players team
self.lblTeam = DirectLabel(
scale = 1,
pos = (0, 0, 3),
frameColor = (0, 0, 0, 0),
text = "TEAM",
text_align = TextNode.ACenter,
text_fg = (0,0,0,1))
self.lblTeam.reparentTo(self.player)
self.lblTeam.setBillboardPointEye()
# basic player values
self.maxHits = 3
self.currentHits = 0
self.isOut = False
self.TorsorControl = self.player.controlJoint(None,"modelRoot","Torsor")
# setup the collision detection
# wall and object collision
self.playerSphere = CollisionSphere(0, 0, 1, 1)
self.playerCollision = self.player.attachNewNode(CollisionNode("playerCollision%d"%id(self)))
self.playerCollision.node().addSolid(self.playerSphere)
base.pusher.addCollider(self.playerCollision, self.player)
base.cTrav.addCollider(self.playerCollision, base.pusher)
# foot (walk) collision
self.playerFootRay = self.player.attachNewNode(CollisionNode("playerFootCollision%d"%id(self)))
self.playerFootRay.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1))
self.playerFootRay.node().setIntoCollideMask(0)
self.lifter = CollisionHandlerFloor()
self.lifter.addCollider(self.playerFootRay, self.player)
base.cTrav.addCollider(self.playerFootRay, self.lifter)
# Player weapon setup
self.gunAttach = self.player.exposeJoint(None, "modelRoot", "WeaponSlot_R")
self.color = LPoint3f(1, 1, 1)
self.gun = Gun(id(self))
self.gun.reparentTo(self.gunAttach)
self.gun.hide()
self.gun.setColor(self.color)
self.hud = None
# Player controls setup
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0}
# screen sizes
self.winXhalf = base.win.getXSize() / 2
self.winYhalf = base.win.getYSize() / 2
self.mouseSpeedX = 0.1
self.mouseSpeedY = 0.1
# AI controllable variables
self.AIP = 0.0
self.AIH = 0.0
self.movespeed = 5.0
self.userControlled = False
self.accept("Bulet-hit-playerCollision%d" % id(self), self.hit)
self.accept("window-event", self.recalcAspectRatio)
def runBase(self):
self.player.show()
self.gun.show()
taskMgr.add(self.move, "moveTask%d"%id(self), priority=-4)
def stopBase(self):
taskMgr.remove("moveTask%d"%id(self))
self.ignoreAll()
self.gun.remove()
self.footstep.stop()
base.audio3d.detachSound(self.footstep)
self.player.delete()
def setKey(self, key, value):
self.keyMap[key] = value
def setPos(self, pos):
self.player.setPos(pos)
def setColor(self, color=LPoint3f(0,0,0)):
self.color = color
self.gun.setColor(color)
c = (color[0], color[1], color[2], 1.0)
self.lblTeam["text_fg"] = c
def setTeam(self, team):
self.playerTeam = team
self.lblTeam["text"] = team
def shoot(self, shotVec=None):
self.gun.shoot(shotVec)
if self.hud != None:
self.hud.updateAmmo(self.gun.maxAmmunition, self.gun.ammunition)
def reload(self):
self.gun.reload()
if self.hud != None:
self.hud.updateAmmo(self.gun.maxAmmunition, self.gun.ammunition)
def recalcAspectRatio(self, window):
self.winXhalf = window.getXSize() / 2
self.winYhalf = window.getYSize() / 2
def hit(self, entry, color):
self.currentHits += 1
# Create a brush to paint on the texture
splat = PNMImage("../data/Splat.png")
splat = splat * LColorf(color[0], color[1], color[2], 1.0)
self.colorBrush = PNMBrush.makeImage(splat, 6, 6, 1)
self.paintAvatar(entry)
if self.currentHits >= self.maxHits:
base.messenger.send("GameOver-player%d" % id(self))
self.isOut = True
def __paint(self, s, t):
""" Paints a point on the avatar at texture coordinates (s, t). """
x = (s * self.p.getXSize())
y = ((1.0 - t) * self.p.getYSize())
# Draw in color directly on the avatar
p1 = PNMPainter(self.p)
p1.setPen(self.colorBrush)
p1.drawPoint(x, y)
self.tex.load(self.p)
self.tex.setWrapU(self.tex.WMClamp)
self.tex.setWrapV(self.tex.WMClamp)
self.paintDirty = True
def paintAvatar(self, entry):
""" Paints onto an avatar. Returns true on success, false on
failure (because there are no avatar pixels under the mouse,
for instance). """
# First, we have to render the avatar in its false-color
# image, to determine which part of its texture is under the
# mouse.
if not self.avbuf:
return False
#mpos = base.mouseWatcherNode.getMouse()
mpos = entry.getSurfacePoint(self.player)
ppos = entry.getSurfacePoint(render)
self.player.showThrough(BitMask32.bit(1))
self.avbuf.setActive(True)
base.graphicsEngine.renderFrame()
self.player.show(BitMask32.bit(1))
self.avbuf.setActive(False)
# Now we have the rendered image in self.avbufTex.
if not self.avbufTex.hasRamImage():
print "Weird, no image in avbufTex."
return False
p = PNMImage()
self.avbufTex.store(p)
ix = int((1 + mpos.getX()) * p.getXSize() * 0.5)
iy = int((1 - mpos.getY()) * p.getYSize() * 0.5)
x = 1
if ix >= 0 and ix < p.getXSize() and iy >= 0 and iy < p.getYSize():
s = p.getBlue(ix, iy)
t = p.getGreen(ix, iy)
x = p.getRed(ix, iy)
if x > 0.5:
# Off the avatar.
return False
# At point (s, t) on the avatar's map.
self.__paint(s, t)
return True
def move(self, task):
if self is None: return task.done
if self.userControlled:
if not base.mouseWatcherNode.hasMouse(): return task.cont
self.pointer = base.win.getPointer(0)
mouseX = self.pointer.getX()
mouseY = self.pointer.getY()
if base.win.movePointer(0, self.winXhalf, self.winYhalf):
p = self.TorsorControl.getP() + (mouseY - self.winYhalf) * self.mouseSpeedY
if p <-80:
p = -80
elif p > 90:
p = 90
self.TorsorControl.setP(p)
h = self.player.getH() - (mouseX - self.winXhalf) * self.mouseSpeedX
if h <-360:
h = 360
elif h > 360:
h = -360
self.player.setH(h)
else:
self.TorsorControl.setP(self.AIP)
self.player.setH(self.AIH)
forward = self.keyMap["forward"] != 0
backward = self.keyMap["backward"] != 0
if self.keyMap["left"] != 0:
if self.player.getCurrentAnim() != "Sidestep" and not (forward or backward):
self.player.loop("Sidestep")
self.player.setPlayRate(5, "Sidestep")
self.player.setX(self.player, self.movespeed * globalClock.getDt())
elif self.keyMap["right"] != 0:
if self.player.getCurrentAnim() != "Sidestep" and not (forward or backward):
self.player.loop("Sidestep")
self.player.setPlayRate(5, "Sidestep")
self.player.setX(self.player, -self.movespeed * globalClock.getDt())
else:
self.player.stop("Sidestep")
if forward:
if self.player.getCurrentAnim() != "Run":
self.player.loop("Run")
self.player.setPlayRate(5, "Run")
self.player.setY(self.player, -self.movespeed * globalClock.getDt())
elif backward:
if self.player.getCurrentAnim() != "Run":
self.player.loop("Run")
self.player.setPlayRate(-5, "Run")
self.player.setY(self.player, self.movespeed * globalClock.getDt())
else:
self.player.stop("Run")
if not (self.keyMap["left"] or self.keyMap["right"] or
self.keyMap["forward"] or self.keyMap["backward"] or
self.player.getCurrentAnim() == "Idle"):
self.player.loop("Idle")
self.footstep.stop()
else:
self.footstep.play()
return task.cont
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 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
class TerrainManager(DirectObject.DirectObject):
def __init__(self):
self.accept("mouse1", self.lclick)
self.waterType = 2
self.water = None
self.citycolors = {0: VBase3D(1, 1, 1)}
self.accept('generateRegion', self.generateWorld)
self.accept('regenerateRegion', self.regenerateWorld)
self.accept("regionView_normal", self.setSurfaceTextures)
self.accept("regionView_owners", self.setOwnerTextures)
self.accept("regionView_foundNew", self.regionViewFound)
self.accept("updateRegion", self.updateRegion)
self.accept("enterCityView", self.enterCity)
# View: 0, region, # cityid
self.view = 0
self.ownerview = False
def lclick(self):
cell = picker.getMouseCell()
print "Cell:", cell
blockCoords = self.terrain.getBlockFromPos(cell[0], cell[1])
block = self.terrain.getBlockNodePath(blockCoords[0], blockCoords[1])
print "Block coords:", blockCoords
print "NodePath:", block
print "Elevation:", self.terrain.getElevation(cell[0], cell[1])
if not self.view:
messenger.send("clickForCity", [cell])
def switchWater(self):
print "Switch Water"
self.waterType += 1
if self.waterType > 2:
self.waterType = 0
self.generateWater(self.waterType)
def generateWorld(self, heightmap, tiles, cities, container):
self.heightmap = heightmap
self.terrain = PagedGeoMipTerrain("surface")
#self.terrain = GeoMipTerrain("surface")
self.terrain.setHeightfield(self.heightmap)
#self.terrain.setFocalPoint(base.camera)
self.terrain.setBruteforce(True)
self.terrain.setBlockSize(64)
self.terrain.generate()
root = self.terrain.getRoot()
root.reparentTo(render)
#root.setSz(100)
self.terrain.setSz(100)
messenger.send('makePickable', [root])
if self.heightmap.getXSize() > self.heightmap.getYSize():
self.size = self.heightmap.getXSize()-1
else:
self.size = self.heightmap.getYSize()-1
self.xsize = self.heightmap.getXSize()-1
self.ysize = self.heightmap.getYSize()-1
# Set multi texture
# Source http://www.panda3d.org/phpbb2/viewtopic.php?t=4536
self.generateSurfaceTextures()
self.generateWaterMap()
self.generateOwnerTexture(tiles, cities)
#self.terrain.makeTextureMap()
colormap = PNMImage(heightmap.getXSize()-1, heightmap.getYSize()-1)
colormap.addAlpha()
slopemap = self.terrain.makeSlopeImage()
for x in range(0, colormap.getXSize()):
for y in range(0, colormap.getYSize()):
# Else if statements used to make sure one channel is used per pixel
# Also for some optimization
# Snow. We do things funky here as alpha will be 1 already.
if heightmap.getGrayVal(x, y) < 200:
colormap.setAlpha(x, y, 0)
else:
colormap.setAlpha(x, y, 1)
# Beach. Estimations from http://www.simtropolis.com/omnibus/index.cfm/Main.SimCity_4.Custom_Content.Custom_Terrains_and_Using_USGS_Data
if heightmap.getGrayVal(x,y) < 62:
colormap.setBlue(x, y, 1)
# Rock
elif slopemap.getGrayVal(x, y) > 170:
colormap.setRed(x, y, 1)
else:
colormap.setGreen(x, y, 1)
self.colorTexture = Texture()
self.colorTexture.load(colormap)
self.colorTS = TextureStage('color')
self.colorTS.setSort(0)
self.colorTS.setPriority(1)
self.setSurfaceTextures()
self.generateWater(2)
taskMgr.add(self.updateTerrain, "updateTerrain")
print "Done with terrain generation"
messenger.send("finishedTerrainGen", [[self.xsize, self.ysize]])
self.terrain.getRoot().analyze()
self.accept("h", self.switchWater)
def regenerateWorld(self):
'''Regenerates world, often upon city exit.'''
self.terrain.generate()
root = self.terrain.getRoot()
root.reparentTo(render)
self.terrain.setSz(100)
messenger.send('makePickable', [root])
# Set multi texture
# Source http://www.panda3d.org/phpbb2/viewtopic.php?t=4536
#self.generateSurfaceTextures()
self.generateWaterMap()
self.setSurfaceTextures()
self.generateWater(2)
print "Done with terrain regeneration"
messenger.send("finishedTerrainGen", [[self.xsize, self.ysize]])
def generateWaterMap(self):
''' Iterate through every pix of color map. This will be very slow so until faster method is developed, use sparingly
getXSize returns pixels length starting with 1, subtract 1 for obvious reasons
We also slip in checking for the water card size, which should only change when the color map does
'''
print "GenerateWaterMap"
self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax = -1,0,-1,0
for x in range(0, self.heightmap.getXSize()-1):
for y in range(0, self.heightmap.getYSize()-1):
# Else if statements used to make sure one channel is used per pixel
# Also for some optimization
# Snow. We do things funky here as alpha will be 1 already.
if self.heightmap.getGrayVal(x,y) < 62:
# Water card dimensions here
# Y axis flipped from texture space to world space
if self.waterXMin == -1 or x < self.waterXMin:
self.waterXMin = x
if not self.waterYMax:
self.waterYMax = y
if y < self.waterYMax:
self.waterYMax = y
if x > self.waterXMax:
self.waterXMax = x
if y > self.waterYMin:
self.waterYMin = y
# Transform y coords
self.waterYMin = self.size-64 - self.waterYMin
self.waterYMax = self.size-64 - self.waterYMax
def generateOwnerTexture(self, tiles, cities):
'''Generates a simple colored texture to be applied to the city info region overlay.
Due to different coordinate systems (terrain org bottom left, texture top left)
some conversions are needed,
Also creates and sends a citylabels dict for the region view
'''
self.citymap = PNMImage(self.xsize, self.ysize)
citylabels = cities
scratch = {}
# Setup for city labels
for ident in cities:
scratch[ident] = []
# conversion for y axis
ycon = []
s = self.ysize - 1
for y in range(self.ysize):
ycon.append(s)
s -= 1
for ident, city in cities.items():
if ident not in self.citycolors:
self.citycolors[ident] = VBase3D(random.random(), random.random(), random.random())
for tile in tiles:
self.citymap.setXel(tile.coords[0], ycon[tile.coords[1]], self.citycolors[tile.cityid])
# Scratch for labeling
if tile.cityid:
scratch[tile.cityid].append((tile.coords[0], tile.coords[1]))
for ident, values in scratch.items():
xsum = 0
ysum = 0
n = 0
for coords in values:
xsum += coords[0]
ysum += coords[1]
n += 1
xavg = xsum/n
yavg = ysum/n
print "Elevation:", self.terrain.getElevation(xavg, yavg)
z = self.terrain.getElevation(xavg, yavg)*100
citylabels[ident]["position"] = (xavg, yavg, z+15)
print "Citylabels:", citylabels
messenger.send("updateCityLabels", [citylabels, self.terrain])
def generateSurfaceTextures(self):
# Textureize
self.grassTexture = loader.loadTexture("Textures/grass.png")
self.grassTS = TextureStage('grass')
self.grassTS.setSort(1)
self.rockTexture = loader.loadTexture("Textures/rock.jpg")
self.rockTS = TextureStage('rock')
self.rockTS.setSort(2)
self.rockTS.setCombineRgb(TextureStage.CMAdd, TextureStage.CSLastSavedResult, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcColor)
self.sandTexture = loader.loadTexture("Textures/sand.jpg")
self.sandTS = TextureStage('sand')
self.sandTS.setSort(3)
self.sandTS.setPriority(5)
self.snowTexture = loader.loadTexture("Textures/ice.png")
self.snowTS = TextureStage('snow')
self.snowTS.setSort(4)
self.snowTS.setPriority(0)
# Grid for city placement and guide and stuff
self.gridTexture = loader.loadTexture("Textures/grid.png")
self.gridTexture.setWrapU(Texture.WMRepeat)
self.gridTexture.setWrapV(Texture.WMRepeat)
self.gridTS = TextureStage('grid')
self.gridTS.setSort(5)
self.gridTS.setPriority(10)
def enterCity(self, ident, city, position, tiles):
'''Identifies which terrain blocks city belogs to and disables those that are not
A lot of uneeded for loops in here. Will need to find a better way later.'''
#root = self.terrain.getRoot()
children = []
for terrain in self.terrain.terrains:
root = terrain.getRoot()
children += root.getChildren()
keepBlocks = []
# Reset water dimentions
self.waterXMin = 0
self.waterXMax = 0
self.waterYMin = 0
self.waterYMax = 0
for tile in tiles:
blockCoords = self.terrain.getBlockFromPos(tile.coords[0], tile.coords[1])
block = self.terrain.getBlockNodePath(blockCoords[0], blockCoords[1])
if block not in keepBlocks:
keepBlocks.append(block)
if self.heightmap.getGrayVal(tile.coords[0], self.size-tile.coords[1]) < 62:
# Water card dimensions here
# Y axis flipped from texture space to world space
if not self.waterXMin:
self.waterXMin = tile.coords[0]
if not self.waterYMin:
self.waterYMin = tile.coords[1]
if tile.coords[1] > self.waterYMax:
self.waterYMax = tile.coords[1]
if tile.coords[0] > self.waterXMax:
self.waterXMax = tile.coords[0]
if tile.coords[0] < self.waterXMin:
self.waterXMin = tile.coords[0]
if tile.coords[1] < self.waterYMin:
self.waterYMin = tile.coords[1]
for child in children:
if child not in keepBlocks:
child.detachNode()
self.view = ident
self.generateWater(2)
def newTerrainOverlay(self, task):
root = self.terrain.getRoot()
position = picker.getMouseCell()
if position:
# Check to make sure we do not go out of bounds
if position[0] < 32:
position = (32, position[1])
elif position[0] > self.xsize-32:
position = (self.xsize-32, position[1])
if position[1] < 32:
position = (position[0], 32)
elif position [1] > self.ysize-32:
position = (position[0], self.size-32)
root.setTexOffset(self.tileTS, -(position[0]-32)/64, -(position[1]-32)/64)
return task.cont
def regionViewFound(self):
'''Gui for founding a new city!'''
self.setOwnerTextures()
root = self.terrain.getRoot()
task = taskMgr.add(self.newTerrainOverlay, "newTerrainOverlay")
tileTexture = loader.loadTexture("Textures/tile.png")
tileTexture.setWrapU(Texture.WMClamp)
tileTexture.setWrapV(Texture.WMClamp)
self.tileTS = TextureStage('tile')
self.tileTS.setSort(6)
self.tileTS.setMode(TextureStage.MDecal)
#self.tileTS.setColor(Vec4(1,0,1,1))
root.setTexture(self.tileTS, tileTexture)
root.setTexScale(self.tileTS, self.terrain.xchunks, self.terrain.ychunks)
self.acceptOnce("mouse1", self.regionViewFound2)
self.acceptOnce("escape", self.cancelRegionViewFound)
def regionViewFound2(self):
'''Grabs cell location for founding.
The texture coordinate is used as the mouse may enter an out of bounds area.
'''
root = self.terrain.getRoot()
root_position = root.getTexOffset(self.tileTS)
# We offset the position of the texture, so we will now put the origin of the new city not on mouse cursor but the "bottom left" of it. Just need to add 32 to get other edge
position = [int(abs(root_position[0]*64)), int(abs(root_position[1]*64))]
self.cancelRegionViewFound()
messenger.send("found_city_name", [position])
def cancelRegionViewFound(self):
taskMgr.remove("newTerrainOverlay")
root = self.terrain.getRoot()
root.clearTexture(self.tileTS)
# Restore original mouse function
self.accept("mouse1", self.lclick)
messenger.send("showRegionGUI")
def setSurfaceTextures(self):
self.ownerview = False
root = self.terrain.getRoot()
root.clearTexture()
#self.terrain.setTextureMap()
root.setTexture( self.colorTS, self.colorTexture )
root.setTexture( self.grassTS, self.grassTexture )
root.setTexScale(self.grassTS, self.size/8, self.size/8)
root.setTexture( self.rockTS, self.rockTexture )
root.setTexScale(self.rockTS, self.size/8, self.size/8)
root.setTexture( self.sandTS, self.sandTexture)
root.setTexScale(self.sandTS, self.size/8, self.size/8)
root.setTexture( self.snowTS, self.snowTexture )
root.setTexScale(self.snowTS, self.size/8, self.size/8)
root.setTexture( self.gridTS, self.gridTexture )
root.setTexScale(self.gridTS, self.xsize, self.ysize)
root.setShaderInput('size', self.xsize, self.ysize, self.size, self.size)
root.setShader(loader.loadShader('Shaders/terraintexture.sha'))
def setOwnerTextures(self):
self.ownerview = True
root = self.terrain.getRoot()
root.clearShader()
root.clearTexture()
cityTexture = Texture()
cityTexture.load(self.citymap)
cityTS = TextureStage('citymap')
cityTS.setSort(0)
root.setTexture( self.gridTS, self.gridTexture )
root.setTexScale(self.gridTS, self.terrain.xchunks, self.terrain.ychunks)
root.setTexture(cityTS, cityTexture, 1)
def updateRegion(self, heightmap, tiles, cities):
self.generateOwnerTexture(tiles, cities)
if self.ownerview:
self.setOwnerTextures()
def updateTerrain(self, task):
'''Updates terrain and water'''
self.terrain.update()
# Water
if self.waterType is 2:
pos = base.camera.getPos()
render.setShaderInput('time', task.time)
mc = base.camera.getMat( )
self.water.changeCameraPos(pos,mc)
self.water.changeCameraPos(pos,mc)
#print "Render diagnostics"
#render.analyze()
#base.cTrav.showCollisions(render)
return task.cont
def generateWater(self, style):
print "Generate Water:", self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax
'''Generates water
style 0: blue card
style 1: reflective card
style 2: reflective card with shaders
'''
self.waterHeight = 22.0
if self.water:
self.water.removeNode()
if style is 0:
cm = CardMaker("water")
#cm.setFrame(-1, 1, -1, 1)
cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax)
cm.setColor(0, 0, 1, 0.9)
self.water = render.attachNewNode(cm.generate())
if self.waterYMax > self.waterXMax:
size = self.waterYMax
else:
size = self.waterXMax
self.water.lookAt(0, 0, -1)
self.water.setZ(self.waterHeight)
messenger.send('makePickable', [self.water])
elif style is 1:
# From Prosoft's super awesome terrain demo
cm = CardMaker("water")
#cm.setFrame(-1, 1, -1, 1)
cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax)
self.water = render.attachNewNode(cm.generate())
if self.waterYMax > self.waterXMax:
size = self.waterYMax
else:
size = self.waterXMax
#self.water.setScale(size)
self.water.lookAt(0, 0, -1)
self.water.setZ(self.waterHeight)
self.water.setShaderOff(1)
self.water.setLightOff(1)
self.water.setAlphaScale(0.5)
self.water.setTransparency(TransparencyAttrib.MAlpha)
wbuffer = base.win.makeTextureBuffer("water", 512, 512)
wbuffer.setClearColorActive(True)
wbuffer.setClearColor(base.win.getClearColor())
self.wcamera = base.makeCamera(wbuffer)
self.wcamera.reparentTo(render)
self.wcamera.node().setLens(base.camLens)
self.wcamera.node().setCameraMask(BitMask32.bit(1))
self.water.hide(BitMask32.bit(1))
wtexture = wbuffer.getTexture()
wtexture.setWrapU(Texture.WMClamp)
wtexture.setWrapV(Texture.WMClamp)
wtexture.setMinfilter(Texture.FTLinearMipmapLinear)
self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, self.water.getZ()))
wplanenp = render.attachNewNode(PlaneNode("water", self.wplane))
tmpnp = NodePath("StateInitializer")
tmpnp.setClipPlane(wplanenp)
tmpnp.setAttrib(CullFaceAttrib.makeReverse())
self.wcamera.node().setInitialState(tmpnp.getState())
self.water.projectTexture(TextureStage("reflection"), wtexture, self.wcamera)
messenger.send('makePickable', [self.water])
elif style is 2:
# From Clcheung just as super awesome demomaster
self.water_level = Vec4(0.0, 0.0, self.waterHeight, 1.0)
self.water = water.WaterNode(self.waterXMin, self.waterYMin, self.waterXMax, self.waterYMax, self.water_level.getZ())
self.water.setStandardControl()
self.water.changeParams(None)
wl=self.water_level
wl.setZ(wl.getZ()-0.05)
#root.setShaderInput('waterlevel', self.water_level)
render.setShaderInput('time', 0)
messenger.send('makePickable', [self.water.waterNP])
class Terrain:
folder = os.path.dirname(os.path.abspath(__file__))
subfolder = "/Maps/"
file = "simple.jpg"
filepath = folder + subfolder + file
def __init__(self):
fn = Filename.fromOsSpecific(self.filepath)
self.terrain = GeoMipTerrain("mySimpleTerrain")
self.terrain.setHeightfield("Entities/Maps/heightmap.png")
self.terrain.getRoot().setSz(40)
#terrain.setBruteforce(True)
self.terrain.getRoot().reparentTo(render)
# Set terrain properties
self.terrain.setBlockSize(16)
self.terrain.setNear(500)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
# Store the root NodePath for convenience
root = self.terrain.getRoot()
root.reparentTo(render)
# some tinkering
"""
# tell renderer to repeat texture when reading over the edge.
texGrass.setWrapU(Texture.WM_repeat)
texGrass.setWrapV(Texture.WM_repeat)
# apply mipmapping: tell renderer how to handle multiple texture pixels being rendered t a single screen pixel (makes textures 30% larger in GPU mem.)
texGrass.setMinfilter(SamplerState.FT_linear_mipmap_linear)
"""
self.terrain.generate()
"""
new attempt to include blend mapping:
"""
# determine terrain size
self.heightmap = self.terrain.heightfield()
if self.heightmap.getXSize() > self.heightmap.getYSize():
self.size = self.heightmap.getXSize() - 1
else:
self.size = self.heightmap.getYSize() - 1
self.xsize = self.heightmap.getXSize() - 1
self.ysize = self.heightmap.getYSize() - 1
# Set multi texture
# Source http://www.panda3d.org/phpbb2/viewtopic.php?t=4536
self.generateSurfaceTextures()
# load a blend texture from file:
self.blendTexture = loader.loadTexture("Entities/Maps/blendMap.png")
self.blendTS = TextureStage('blend')
self.blendTS.setSort(0)
self.blendTS.setPriority(1)
# apply textures to the terrain and connect custom shader for blend mapping:
self.setSurfaceTextures()
# Add a task to keep updating the terrain (for changing terrain, or synamic resolution)
def updateTask(task):
self.terrain.update()
return task.cont
taskMgr.add(updateTask, "update")
# this is where we load the textures to be assigned to the terrain
def generateSurfaceTextures(self):
# Textureize
self.grassTexture = loader.loadTexture("Entities/Maps/grassy2.png")
self.grassTexture.setWrapU(Texture.WMRepeat)
self.grassTexture.setWrapV(Texture.WMRepeat)
self.grassTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
self.grassTexture.setAnisotropicDegree(8)
self.grassTS = TextureStage('grass')
self.grassTS.setSort(
1) # sorting order is relevent for assigning textures to the four
self.rockTexture = loader.loadTexture("Entities/Maps/simple.jpg")
self.rockTexture.setWrapU(Texture.WMRepeat)
self.rockTexture.setWrapV(Texture.WMRepeat)
self.rockTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
#self.grassTexture.setAnisotropicDegree(8)
self.rockTS = TextureStage('rock')
self.rockTS.setSort(2)
# self.rockTS.setCombineRgb(TextureStage.CMAdd, TextureStage.CSLastSavedResult, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcColor)
self.sandTexture = loader.loadTexture("Entities/Maps/stars.png")
self.sandTexture.setWrapU(Texture.WMRepeat)
self.sandTexture.setWrapV(Texture.WMRepeat)
self.sandTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
#self.sandTexture.setAnisotropicDegree(8)
self.sandTS = TextureStage('sand')
self.sandTS.setSort(3)
self.sandTS.setPriority(5) # TODO: figure out what this is for...
self.snowTexture = loader.loadTexture("Entities/Maps/grass.png")
self.snowTexture.setWrapU(Texture.WMRepeat)
self.snowTexture.setWrapV(Texture.WMRepeat)
self.snowTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
#self.snowTexture.setAnisotropicDegree(8)
self.snowTS = TextureStage('snow')
self.snowTS.setSort(4)
self.snowTS.setPriority(0)
# a background (or rather freground?) texture that will be present independently from the blend map (consider removal)
self.overlayTexture = loader.loadTexture("Entities/Maps/heightmap.png")
self.overlayTexture.setWrapU(Texture.WMRepeat)
self.overlayTexture.setWrapV(Texture.WMRepeat)
self.overlayTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear)
#self.overlayTexture.setAnisotropicDegree(8)
self.overlayTS = TextureStage('overlay')
self.overlayTS.setSort(5)
self.overlayTS.setPriority(10)
# this is where we assign loaded textures to be blended in the shader.
def setSurfaceTextures(self):
self.ownerview = False
root = self.terrain.getRoot()
root.clearTexture()
#self.terrain.setTextureMap()
root.setTexture(
self.blendTS, self.snowTexture
) # this texture determines where the other textures are visible
root.setTexture(self.grassTS, self.snowTexture)
#root.setTexScale(self.grassTS, self.size*5, self.size*5) # I try to make the texture 20 times smaller then the blend map...
root.setTexture(self.rockTS, self.snowTexture) #rockTexture
#root.setTexScale(self.rockTS, self.size*5, self.size*5)
root.setTexture(self.sandTS, self.snowTexture) #sandTexture
#root.setTexScale(self.sandTS, self.size*5, self.size*5)
root.setTexture(self.snowTS, self.snowTexture) #snowTexture
#root.setTexScale(self.snowTS, self.size*5, self.size*5)
#(consider removal)
root.setTexture(self.overlayTS, self.overlayTexture) #overlayTexture
#root.setTexScale(self.overlayTS, self.xsize, self.ysize)
root.setShaderInput('size', self.xsize, self.ysize, self.size,
self.size)
root.setShader(loader.loadShader('Entities/Maps/terrainblender.sha'))
