def __init__(self):
"""Constructor
"""
BaseModeLogic.__init__(self)
#ogre.FrameListener.__init__(self)
self.gui = render_engine._gui
self.x, self.y = render_engine._ogreRenderWindow.getWidth(
), render_engine._ogreRenderWindow.getHeight()
self.panel = False
self.wpanel = None
self.isRoot = False
#self.kernel.ogreRoot.addFrameListener(self)
# video player
self.videoPlayer = None
self.videoFile = ""
self.materialName = None
self.playing = False
self.runTime = 0
self.needUpdateMaterial = True
# attach flags
# self.listenerRegistered = False
self.rectAttached = False
# creating rectangle (surface)
self.rect = ogre.Rectangle2D(True)
self.rect.setCorners(-1.0, 1.0, 1.0, -1.0)
self.rect.setRenderQueueGroup(ogre.RENDER_QUEUE_8)
self.rect.setBoundingBox(
ogre.AxisAlignedBox(ogre.Vector3(-100000.0, -100000.0, -100000.0),
ogre.Vector3(100000.0, 100000.0, 100000.0)))
def getBoundingBox(entity):
"""Mesh Extents AxisAligned Box"""
vertices = []
minExtent = ogre.Vector3(9999, 9999, 9999)
maxExtent = ogre.Vector3(-9999, -9999, -9999)
if entity.getMesh().sharedVertexData:
vertices += MeshInfo.GetVerticies(
entity.getMesh().sharedVertexData,
entity.getParentSceneNode()._getFullTransform())
for m in range(entity.getMesh().numSubMeshes):
sm = entity.getMesh().getSubMesh(m)
if not sm.useSharedVertices:
vertices += MeshInfo.GetVerticies(
sm.vertexData,
entity.getParentSceneNode()._getFullTransform())
for vert in vertices:
minExtent.x = min(minExtent.x, vert[0])
minExtent.y = min(minExtent.y, vert[1])
minExtent.z = min(minExtent.z, vert[2])
maxExtent.x = max(maxExtent.x, vert[0])
maxExtent.y = max(maxExtent.y, vert[1])
maxExtent.z = max(maxExtent.z, vert[2])
del vertices
return ogre.AxisAlignedBox(minExtent, maxExtent)
def updateBoundingBox(self):
max_zoom = abs(self.max_zoom_out * 1000)
min_zoom = abs(self.min_zoom_in * 1000)
maxima = ogre.Vector3(self.map_upper_right[0], self.map_upper_right[1],
max_zoom)
minima = ogre.Vector3(self.map_lower_left[0], self.map_lower_left[1],
min_zoom)
self.bounding_box = ogre.AxisAlignedBox(minima, maxima)
def _createRect(self):
""" Creates rectangle surface for root mode
"""
# FIXME: make thread safe
self.rect = ogre.Rectangle2D(True)
self.rect.setCorners(-0.7, 0.7, 0.7, -0.7)
self.rect.setRenderQueueGroup(ogre.RENDER_QUEUE_8)
self.rect.setBoundingBox(ogre.AxisAlignedBox(ogre.Vector3(-100000.0, -100000.0, -100000.0), ogre.Vector3(100000.0, 100000.0, 100000.0)))
self.sceneNodeRect.attachObject(self.rect)
def _createRect(self):
"""Creates rectangle surface for flash
"""
self.rect = ogre.Rectangle2D(True)
self.rect.setCorners(self.rect_corners[0], self.rect_corners[1],
self.rect_corners[2], self.rect_corners[3])
self.rect.setRenderQueueGroup(ogre.RENDER_QUEUE_8)
self.rect.setBoundingBox(
ogre.AxisAlignedBox(ogre.Vector3(-100000.0, -100000.0, -100000.0),
ogre.Vector3(100000.0, 100000.0, 100000.0)))
def create(self, cursorSize, arg):
if arg is not None:
self.name = arg["name"]
self.position = og.Vector3(arg["positionX"], arg["positionY"], arg["positionZ"])
self.extends = og.Vector3(arg["extendsX"], arg["extendsY"], arg["extendsZ"])
self.terrainHeight = arg["terrainHeight"]
self.terrainSize = arg["terrainSize"] + 1
self.splattingResGroup = "ETSplatting"
self.splattingTextureSize = self.terrainSize = arg["terrainSize"] + 1
self.splattingNumTextures = 6
# self.splattingBaseName = arg["splattingBaseName"]
# self.splattingResGroup = arg["splattingResGroup"]
# self.splattingTextureSize = arg["splattingTextureSize"]
# self.splattingNumTextures = arg["splattingNumTextures"]
self.terrainManager = ET.TerrainManager(self.sceneManager, self.name)
self.terrainManager.setLODErrorMargin(2, self.camera.getViewport().getActualHeight())
self.terrainManager.setUseLODMorphing(True, 0.2, "morphFactor")
## create a fresh, mid-high terrain for editing
# Note
heightMapValues = og.stdVectorFloat() ## ET.stdVectorFloat()
for i in xrange(self.terrainSize):
for j in xrange(self.terrainSize):
heightMapValues.append(self.terrainHeight)
# width, height, heightmapvalues as a float array
self.terrainInfo = ET.TerrainInfo (self.terrainSize, self.terrainSize, heightMapValues )
## save typing self
terrainInfo = self.terrainInfo
sceneManager = self.sceneManager
terrainMgr = self.terrainManager
## set position and size of the terrain
half = self.extends / 2
terrainInfo.setExtents(og.AxisAlignedBox(-half.x, -half.y, -half.z, half.x, half.y, half.z))
## now render it
terrainMgr.createTerrain(terrainInfo)
## create the splatting manager
# * @param baseName base name for the map textures (will be appended by their number)
# * @param group the resource group the textures will be placed in
# * @param width width of the textures in pixels
# * @param height height of the textures in pixels
# * @param channels Number of channels per texture (must be in {1, 2, 3, 4})
self.splatMgr = ET.SplattingManager(self.splattingBaseName, self.splattingResGroup, self.terrainSize, self.terrainSize, 3)
## specify number of splatting textures we need to handle
self.splatMgr.setNumTextures(self.splattingNumTextures)
## create a manual lightmap texture
lightmapTex = og.TextureManager.getSingleton().createManual(
"ETLightmap", self.splattingResGroup, og.TEX_TYPE_2D, self.splattingTextureSize, self.splattingTextureSize, 1, og.PF_BYTE_RGB)
lightmap = og.Image()
ET.createTerrainLightmap(terrainInfo, lightmap, 128, 128,\
og.Vector3(1, -1, 1),\
og.ColourValue().White,\
og.ColourValue(0.3, 0.3, 0.3,1.0))
lightmapTex.getBuffer(0, 0).blitFromMemory(lightmap.getPixelBox(0, 0))
## load the terrain material and assign it
material = og.MaterialManager.getSingleton().getByName("ETTerrainMaterial")
# material = og.MaterialManager.getSingleton().getByName("Lockenwickler_Area")
self.terrainManager.setMaterial(material)
self.sceneNode = self.sceneManager.getSceneNode(self.name + "/Terrain")
self.sceneNode.setPosition(self.position)
self.parentSceneNode = self.sceneNode.getParentSceneNode()
self.created = True
self.decalCursor = TerrainDecalCursor.TerrainDecalCursor(self.sceneManager, material, og.Vector2(cursorSize, cursorSize), "cursorTex.png")
