def __init__(self, world, name, basedir):
self.world = world
self.name = name
self.basedir = basedir
self.load_complete = 0
self.world.consoleOut('zone initializing: ' + self.name)
# store the in memory WLDFile objects that make uo the zone for direct access
self.wld_containers = {} # and as a directory
self.zone_wld_container = None
self.obj1_wld_container = None
self.obj2_wld_container = None
self.chr_wld_container = None
# init our texture manager
self.tm = TextureManager()
# init our model manager
self.mm = ModelManager(self)
self.nulltex = Texture(
) # create dummy exture object for use in non textured polys
self.rootNode = NodePath(PandaNode("zone_root"))
self.rootNode.reparentTo(render)
self.delta_t = 0
def __init__(self, world, name, basedir):
self.world = world
self.name = name
self.basedir = basedir
self.load_complete = 0
self.world.consoleOut('zone initializing: '+self.name)
# store the in memory WLDFile objects that make uo the zone for direct access
self.wld_containers = {} # and as a directory
self.zone_wld_container = None
self.obj1_wld_container = None
self.obj2_wld_container = None
self.chr_wld_container = None
# init our texture manager
self.tm = TextureManager()
# init our model manager
self.mm = ModelManager(self)
self.nulltex = Texture() # create dummy exture object for use in non textured polys
self.rootNode = NodePath(PandaNode("zone_root"))
self.rootNode.reparentTo(render)
self.delta_t = 0
class Zone():
def __init__(self, world, name, basedir):
self.world = world
self.name = name
self.basedir = basedir
self.load_complete = 0
self.world.consoleOut('zone initializing: ' + self.name)
# store the in memory WLDFile objects that make uo the zone for direct access
self.wld_containers = {} # and as a directory
self.zone_wld_container = None
self.obj1_wld_container = None
self.obj2_wld_container = None
self.chr_wld_container = None
# init our texture manager
self.tm = TextureManager()
# init our model manager
self.mm = ModelManager(self)
self.nulltex = Texture(
) # create dummy exture object for use in non textured polys
self.rootNode = NodePath(PandaNode("zone_root"))
self.rootNode.reparentTo(render)
self.delta_t = 0
# This currently only updates the direct zone sprites
def update(self):
if self.load_complete != 1:
return
# print 'update delta_t:', globalClock.getDt()
self.delta_t += globalClock.getDt()
if self.delta_t > 0.2:
self.delta_t = 0
for container in self.wld_containers:
for sprite in self.wld_containers[container].animated_sprites:
sprite.update()
# build the main zone geometry mesh
def prepareZoneMesh(self):
wld_container = self.wld_containers['zone']
wld_obj = wld_container.wld_file_obj
# load the 0x36 bsp region fragments (sub meshes): all these meshes together
# make up the main zone geometry
for f in wld_obj.fragments.values():
if f.type == 0x36:
# print 'adding fragment_36 to main zone mesh'
# f.dump()
m = Mesh(self.name)
m.buildFromFragment(f, wld_container)
m.root.reparentTo(
self.rootNode) # "hang" the mesh under our root node
# ---------------------------------------------------------------------
# create the SPRITE objects: these can reference a single texture or
# a list of them (for animated textures like water, lava etc.)
# we need to step through all entries of the 0x31 list fragment for the zone
# We store the SPRITEs using their index within the 0x31 fragments list as the key
# because this is exactly how the meshes (0x36 fragments) reference them
# The lists them selves are keyed by the 0x31 fragmemts id (=index in the diskfile)
def loadSpriteList(self, wld_container, f31):
wld = wld_container.wld_file_obj
wld_container.sprite_list[f31.id] = {}
sprite_list = wld_container.sprite_list[f31.id]
idx = 0
for ref30 in f31.nameRefs:
sprite_error = 0
sprite = None
# print ref30
f30 = wld.getFragment(ref30)
# f30.dump()
material_name = wld.getName(f30.nameRef)
# Note on TRANSPARENCY: as far as I can tell so far, bit 2 in the params1 field of f30
# is the "semi-transparent" indicator used for all types of water surfaces for the old
# zones (pre POP? Seems to not work like this in zones like POV for example anymore)
# lets go by this theory anyway for now
'''
if f30.params1 & 0x00000004:
print 'SEMI TRANSPARENT MATERIAL:'
f30.dump()
'''
# print 'looking up 0x05 fragment with id_plus_1:', f30.frag05Ref
# Note that there are frag05Refs inside some 0x30 fragments with value <=0
# these named references seem to point directly to 0x03 texture fragments
# instead of the usual indirection chain 0x05->0x04->0x03
# in some instances these point nowhere meaningful at all though. Need to catch all these
frag = wld.getFragment(f30.frag05Ref)
if frag != None:
if frag.type == 0x03: # this is a direct 0x03 ref (see note above)
f03 = frag
texfile_name = f03.names[0]
tx = self.tm.getTexture(texfile_name)
if tx != None:
# we dont have a sprite def (0x04) for these, so we use the material (0x30) name
sprite = Sprite(material_name, idx, f30.params1,
self.tm)
sprite.addTexture(texfile_name, tx)
else:
sprite_error = 1
print 'Error in Sprite:', material_name, 'Texture not found:', texfile_name
elif frag.type == 0x05: # this is the "normal" indirection chain 0x30->0x05->0x04->0x03
f05 = frag
# f05.dump()
f04 = wld.getFragment(f05.frag04Ref)
# f04.dump()
name = wld.getName(f04.nameRef)
sprite = Sprite(name, idx, f30.params1, self.tm)
sprite.setAnimDelay(f04.params2)
for f03ref in f04.frag03Refs:
f03 = wld.getFragment(f03ref)
# f03.dump()
# NOTE that this assumes the zone 0x03 fragments only ever reference one single texture
texfile_name = f03.names[0]
tx = self.tm.getTexture(texfile_name)
if tx != None:
sprite.addTexture(texfile_name, tx)
else:
sprite_error = 1
print 'Error in Sprite:', name, 'Texure not found:', texfile_name
else:
# This is the "does point nowhere meaningful at all" case
# infact the reference points back to the same fragment (circular)
# This type of 0x30 fragment seems to only have been used for zone boundary polygons
# in the original EQ classic zones
# Note that we create a sprite with just a dummy texture in it for these
# sprite_error = 1
print 'Warning : Non standard material:%s. Texture ref in 0x30 frag is not type 0x5 or 0x3 but 0x%x' % (
material_name, frag.type)
# print 'F30 DUMP:'
# f30.dump()
# print 'Referenced Fragment DUMP:'
# frag.dump()
# this will be a sprite with just the dummy nulltex textures
# we need this so that transparent zonewalls in the very old classic zones work
# newer zones have actually textured ("collide.dds") zone walls
sprite = Sprite(material_name, idx, f30.params1, self.tm)
sprite.addTexture('nulltexture', self.nulltex)
else:
sprite_error = 1
print 'Error in Sprite: could not resolve frag05ref:%i in 0x30 fragment:%i' % (
f30.frag05Ref, f30.id)
if sprite_error != 1: # only add error free sprites
# sprite.dump()
# new style sprite list
sprite_list[idx] = sprite
if sprite.anim_delay != 0:
print("Adding animated sprite to master list " +
sprite.name)
wld_container.animated_sprites.append(sprite)
idx += 1 # need to increment regardless of whether we stored or not
# so that the index lookup using the refs in the 0x36's works
# preloadWldTextures actually does quite a bit more than just preloading texture files
# the main task of this code is to generate our SPRITES
# Params
# wld_container is a WldContainer object
def preloadWldTextures(self, wld_container):
self.world.consoleOut('preloading textures for container: ' +
wld_container.name)
wld = wld_container.wld_file_obj # the in memory wld file
# loop over all 0x03 fragments and PRELOAD all referenced texture files from the s3d
f31 = None
f31_list = []
for f in wld.fragments.values():
if f.type == 0x03:
# f.dump()
# NOTE
# in VERSION 2 WLD zones (ex. povalor, postorms) I've found texture names
# that have three parameters prepended like this for example: 1, 4, 0, POVSNOWDET01.DDS
# no idea yet as to what these mean but in order to be able to load the texture from
# the s3d container we need to strip this stuff
for name in f.names:
i = name.rfind(',')
if i != -1:
# See NOTE above
print 'parametrized texture name found:%s wld version:0x%x' % (
name, self.wldZone.version)
name = name[i + 1:].strip()
self.tm.loadTexture(name.lower(), wld_container)
# need to store the 0x31 texture lists
if f.type == 0x31:
f31_list.append(f)
# not all wld files define sprites
if len(f31_list) == 0:
return
for f31 in f31_list:
self.loadSpriteList(wld_container, f31)
#print("Loaded sprites got this many: " + str(len(wld_container.animated_sprites)))
# preload the textures/sprites for all loaded containers
def preloadTextures(self):
# self.preloadWldTextures(self.zone_wld_container)
for wld_obj in self.wld_containers.values():
self.preloadWldTextures(wld_obj)
# We let Panda3D "flatten" the plethora of GEOMs we created from the original bsp tree
# ==> this process creates a complete new NodePath->GeomNode tree from our original
# In order to implement texture animation and transparency we need to map the new Geom's textures
# back to our Sprites so we can change texture assignments and transparency on a Geom level in
# the new structure
# Remap the Textures in use for the main Zone Geometry
def remapTextures(self):
# -------------------------------------------------------------------------------------
# ANIMATED TEXTURE SETUP AND TRANSPARENCY FOR ZONE GEOMETRY (NOT PLACEABLES etc!)
# trying to evaluate the scene graph structure under our root node here
# since flattenStrong() totally changes the structure of our scene from how we
# originally created it, we need to find a way to:
# - get a the geoms that the flatten process has produced
# - find their textures
# - map those back to our sprites
# - and finally set up the update process for texture animations based on the above
#
# NOTE this code will fail if there is more than one sprite useing a single texture!
# Not encountered this yet though.
self.world.consoleOut('setting up animated textures for zone geometry')
for child in self.rootNode.getChildren():
# print child
geom_node = child.node()
for geom_number in range(0, geom_node.getNumGeoms()):
geom_render_state = geom_node.getGeomState(geom_number)
attr = geom_render_state.getAttrib(
26
) # attrib 26 is the texture attribute (hope this is static)
if attr != None:
# print attr
tex = attr.getTexture()
# print tex # BINGO! now we have the texture for this GEOM, lets find the sprite
sprite = self.zone_wld_container.findSpriteUsing(tex)
if sprite != None:
# print sprite
# set general texture alpha based tansparency for masked textures
# if sprite.masked == 1:
# child.setTransparency(TransparencyAttrib.MAlpha)
if sprite.transparent == 1 or sprite.masked == 1:
# EXPERIMENTAL TRANSPARENCY SUPPORT ###############
# This is for semi-transparent polygons (water surfaces etc)
# we implement the transparency via the alpha component of the GEOM's ColorAttrib
ta = TransparencyAttrib.make(
TransparencyAttrib.MAlpha)
geom_render_state = geom_render_state.setAttrib(
ta, 1
) # potentialy needs passing "int override" (=1?) as second param
if not sprite.masked == 1:
ca = ColorAttrib.makeFlat(
Vec4(1, 1, 1, sprite.alpha))
geom_render_state = geom_render_state.setAttrib(
ca, 1
) # potentialy needs passing "int override" (=1?) as second param
geom_node.setGeomState(geom_number,
geom_render_state)
# #####################################################
if sprite.anim_delay > 0:
# ANIMATED SPRITE
# sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
sprite.addAnimGeomRenderState(
(geom_node, geom_number, geom_render_state))
else:
print 'could not find sprite for geom node, node texture cant be animated'
# load up everything related to this zone
def load(self):
# ---- ZONE GEOMETRY ----
# load main zone s3d
s3dfile_name = self.name + '.s3d'
self.world.consoleOut('zone loading zone s3dfile: ' + s3dfile_name)
s3d = S3DFile(self.basedir + self.name)
if s3d.load() != 0:
self.world.consoleOut('ERROR loading s3dfile:' + self.basedir +
s3dfile_name)
return -1
# s3d.dumpListing()
# load main zone wld
wldZone = WLDFile(self.name)
# wldZone.setDumpList([0x14, 0x15])
wldZone.load(s3d)
self.zone_wld_container = WLDContainer('zone', self, wldZone, s3d)
self.wld_containers['zone'] = self.zone_wld_container
# load the objects.wld file from the same container
# this basically consists of 0x15 model references for putting all placeables in place
wldZoneObj = WLDFile('objects')
# wldZoneObj.setDumpList([0x14, 0x15])
wldZoneObj.load(s3d)
self.zone_obj_wld_container = WLDContainer('zone_obj', self,
wldZoneObj, s3d)
self.wld_containers['zone_obj'] = self.zone_obj_wld_container
# ---- placeables definitions ------------------------------------
s3dfile_name = self.name + '_obj.s3d'
print '-------------------------------------------------------------------------------------'
self.world.consoleOut('zone loading placeable objects s3dfile: ' +
s3dfile_name)
s3d = S3DFile(self.basedir + self.name + '_obj')
if s3d.load() == 0:
# s3d.dumpListing()
wldObj1 = WLDFile(self.name + '_obj')
wldObj1.setDumpList([0x14, 0x13, 0x12, 0x11, 0x10])
wldObj1.load(s3d)
self.obj1_wld_container = WLDContainer('obj', self, wldObj1, s3d)
self.wld_containers['obj1'] = self.obj1_wld_container
else:
self.world.consoleOut('zone object 1 s3dfile does not exist:' +
self.basedir + s3dfile_name)
s3dfile_name = self.name + '_2_obj.s3d'
print '-------------------------------------------------------------------------------------'
self.world.consoleOut('zone loading placeable objects 2 s3dfile: ' +
s3dfile_name)
s3d = S3DFile(self.basedir + self.name + '_2_obj')
if s3d.load() == 0:
# s3d.dumpListing()
wldObj2 = WLDFile(self.name + '_2_obj')
# wldObj2.setDumpList([0x14, 0x15, 0x2D, 0x36])
wldObj2.load(s3d)
self.obj2_wld_container = WLDContainer('obj', self, wldObj2, s3d)
self.wld_containers['obj2'] = self.obj2_wld_container
else:
self.world.consoleOut('zone object 2 s3dfile does not exist:' +
self.basedir + s3dfile_name)
s3dfile_name = self.name + '_chr.s3d'
print '-------------------------------------------------------------------------------------'
self.world.consoleOut('zone loading character s3dfile: ' +
s3dfile_name)
s3d = S3DFile(self.basedir + self.name + '_chr')
if s3d.load() == 0:
# s3d.dumpListing()
wldChr = WLDFile(self.name + '_chr')
# wldChr.setDumpList([0x14, 0x15, 0x2D, 0x36])
wldChr.load(s3d)
self.chr_wld_container = WLDContainer('chr', self, wldChr, s3d)
self.wld_containers['chr'] = self.chr_wld_container
else:
self.world.consoleOut('zone character s3dfile does not exist:' +
self.basedir + s3dfile_name)
# --- TEXTURES ----
self.world.consoleOut('preloading textures')
self.preloadTextures()
# ---- Generate main Zone Geometry ----
self.world.consoleOut('preparing zone mesh')
self.prepareZoneMesh()
# let Panda3D attempt to flatten the zone geometry (reduce the excessive
# Geom count resulting from the layout of the .wld zone data as a huge
# bunch of tiny bsp regions)
self.world.consoleOut('flattening zone mesh geom tree')
# self.rootNode.ls()
self.rootNode.flattenStrong()
self.rootNode.ls()
# texture->sprite remapping after the flatten above
self.remapTextures()
# COLLISION:
# The following makes the complete zone base geometry eligible for collisions
# this is of course extremely inefficient. TODO: at some point we need to use the
# bsp structures already provided in the wld file to optimize whats in our scene graph
# and also to build a more intelligent collision system
self.rootNode.setCollideMask(BitMask32.bit(0))
# ---- load MODELS and spawn placeables -----------------------
# go through all the 0x15 refs and create empty model "shells"
# for every unique entry
self.world.consoleOut('loading placeables models')
self.mm.loadPlaceables(wldZoneObj)
# self.rootNode.ls()
print 'zone load complete'
self.load_complete = 1
return 0
class Zone():
def __init__(self, world, name, basedir):
self.world = world
self.name = name
self.basedir = basedir
self.load_complete = 0
self.world.consoleOut('zone initializing: '+self.name)
# store the in memory WLDFile objects that make uo the zone for direct access
self.wld_containers = {} # and as a directory
self.zone_wld_container = None
self.obj1_wld_container = None
self.obj2_wld_container = None
self.chr_wld_container = None
# init our texture manager
self.tm = TextureManager()
# init our model manager
self.mm = ModelManager(self)
self.nulltex = Texture() # create dummy exture object for use in non textured polys
self.rootNode = NodePath(PandaNode("zone_root"))
self.rootNode.reparentTo(render)
self.delta_t = 0
# This currently only updates the direct zone sprites
def update(self):
if self.load_complete != 1:
return
# print 'update delta_t:', globalClock.getDt()
self.delta_t += globalClock.getDt()
if self.delta_t > 0.2:
self.delta_t = 0
for container in self.wld_containers:
for sprite in self.wld_containers[container].animated_sprites:
sprite.update()
# build the main zone geometry mesh
def prepareZoneMesh(self):
wld_container = self.wld_containers['zone']
wld_obj = wld_container.wld_file_obj
# load the 0x36 bsp region fragments (sub meshes): all these meshes together
# make up the main zone geometry
for f in wld_obj.fragments.values():
if f.type == 0x36:
# print 'adding fragment_36 to main zone mesh'
# f.dump()
m = Mesh(self.name)
m.buildFromFragment(f, wld_container)
m.root.reparentTo(self.rootNode) # "hang" the mesh under our root node
# ---------------------------------------------------------------------
# create the SPRITE objects: these can reference a single texture or
# a list of them (for animated textures like water, lava etc.)
# we need to step through all entries of the 0x31 list fragment for the zone
# We store the SPRITEs using their index within the 0x31 fragments list as the key
# because this is exactly how the meshes (0x36 fragments) reference them
# The lists them selves are keyed by the 0x31 fragmemts id (=index in the diskfile)
def loadSpriteList(self, wld_container, f31):
wld = wld_container.wld_file_obj
wld_container.sprite_list[f31.id] = {}
sprite_list = wld_container.sprite_list[f31.id]
idx = 0
for ref30 in f31.nameRefs:
sprite_error = 0
sprite = None
# print ref30
f30 = wld.getFragment(ref30)
# f30.dump()
material_name = wld.getName(f30.nameRef)
# Note on TRANSPARENCY: as far as I can tell so far, bit 2 in the params1 field of f30
# is the "semi-transparent" indicator used for all types of water surfaces for the old
# zones (pre POP? Seems to not work like this in zones like POV for example anymore)
# lets go by this theory anyway for now
'''
if f30.params1 & 0x00000004:
print 'SEMI TRANSPARENT MATERIAL:'
f30.dump()
'''
# print 'looking up 0x05 fragment with id_plus_1:', f30.frag05Ref
# Note that there are frag05Refs inside some 0x30 fragments with value <=0
# these named references seem to point directly to 0x03 texture fragments
# instead of the usual indirection chain 0x05->0x04->0x03
# in some instances these point nowhere meaningful at all though. Need to catch all these
frag = wld.getFragment(f30.frag05Ref)
if frag != None:
if frag.type == 0x03: # this is a direct 0x03 ref (see note above)
f03 = frag
texfile_name = f03.names[0]
tx = self.tm.getTexture(texfile_name)
if tx != None:
# we dont have a sprite def (0x04) for these, so we use the material (0x30) name
sprite = Sprite(material_name, idx, f30.params1, self.tm)
sprite.addTexture(texfile_name, tx)
else:
sprite_error = 1
print 'Error in Sprite:', material_name, 'Texture not found:', texfile_name
elif frag.type == 0x05: # this is the "normal" indirection chain 0x30->0x05->0x04->0x03
f05 = frag
# f05.dump()
f04 = wld.getFragment(f05.frag04Ref)
# f04.dump()
name = wld.getName(f04.nameRef)
sprite = Sprite(name, idx, f30.params1, self.tm)
sprite.setAnimDelay(f04.params2)
for f03ref in f04.frag03Refs:
f03 = wld.getFragment(f03ref)
# f03.dump()
# NOTE that this assumes the zone 0x03 fragments only ever reference one single texture
texfile_name = f03.names[0]
tx = self.tm.getTexture(texfile_name)
if tx != None:
sprite.addTexture(texfile_name, tx)
else:
sprite_error = 1
print 'Error in Sprite:', name, 'Texure not found:', texfile_name
else:
# This is the "does point nowhere meaningful at all" case
# infact the reference points back to the same fragment (circular)
# This type of 0x30 fragment seems to only have been used for zone boundary polygons
# in the original EQ classic zones
# Note that we create a sprite with just a dummy texture in it for these
# sprite_error = 1
print 'Warning : Non standard material:%s. Texture ref in 0x30 frag is not type 0x5 or 0x3 but 0x%x' % (material_name, frag.type)
# print 'F30 DUMP:'
# f30.dump()
# print 'Referenced Fragment DUMP:'
# frag.dump()
# this will be a sprite with just the dummy nulltex textures
# we need this so that transparent zonewalls in the very old classic zones work
# newer zones have actually textured ("collide.dds") zone walls
sprite = Sprite(material_name, idx, f30.params1, self.tm)
sprite.addTexture('nulltexture', self.nulltex)
else:
sprite_error = 1
print 'Error in Sprite: could not resolve frag05ref:%i in 0x30 fragment:%i' % (f30.frag05Ref, f30.id)
if sprite_error != 1: # only add error free sprites
# sprite.dump()
# new style sprite list
sprite_list[idx] = sprite
if sprite.anim_delay != 0:
print("Adding animated sprite to master list " + sprite.name)
wld_container.animated_sprites.append(sprite)
idx += 1 # need to increment regardless of whether we stored or not
# so that the index lookup using the refs in the 0x36's works
# preloadWldTextures actually does quite a bit more than just preloading texture files
# the main task of this code is to generate our SPRITES
# Params
# wld_container is a WldContainer object
def preloadWldTextures(self, wld_container):
self.world.consoleOut('preloading textures for container: '+ wld_container.name)
wld = wld_container.wld_file_obj # the in memory wld file
# loop over all 0x03 fragments and PRELOAD all referenced texture files from the s3d
f31 = None
f31_list = []
for f in wld.fragments.values():
if f.type == 0x03:
# f.dump()
# NOTE
# in VERSION 2 WLD zones (ex. povalor, postorms) I've found texture names
# that have three parameters prepended like this for example: 1, 4, 0, POVSNOWDET01.DDS
# no idea yet as to what these mean but in order to be able to load the texture from
# the s3d container we need to strip this stuff
for name in f.names:
i = name.rfind(',')
if i != -1:
# See NOTE above
print 'parametrized texture name found:%s wld version:0x%x' % (name, self.wldZone.version)
name = name[i+1:].strip()
self.tm.loadTexture(name.lower(), wld_container)
# need to store the 0x31 texture lists
if f.type == 0x31:
f31_list.append(f)
# not all wld files define sprites
if len(f31_list) == 0:
return
for f31 in f31_list:
self.loadSpriteList(wld_container, f31)
#print("Loaded sprites got this many: " + str(len(wld_container.animated_sprites)))
# preload the textures/sprites for all loaded containers
def preloadTextures(self):
# self.preloadWldTextures(self.zone_wld_container)
for wld_obj in self.wld_containers.values():
self.preloadWldTextures(wld_obj)
# We let Panda3D "flatten" the plethora of GEOMs we created from the original bsp tree
# ==> this process creates a complete new NodePath->GeomNode tree from our original
# In order to implement texture animation and transparency we need to map the new Geom's textures
# back to our Sprites so we can change texture assignments and transparency on a Geom level in
# the new structure
# Remap the Textures in use for the main Zone Geometry
def remapTextures(self):
# -------------------------------------------------------------------------------------
# ANIMATED TEXTURE SETUP AND TRANSPARENCY FOR ZONE GEOMETRY (NOT PLACEABLES etc!)
# trying to evaluate the scene graph structure under our root node here
# since flattenStrong() totally changes the structure of our scene from how we
# originally created it, we need to find a way to:
# - get a the geoms that the flatten process has produced
# - find their textures
# - map those back to our sprites
# - and finally set up the update process for texture animations based on the above
#
# NOTE this code will fail if there is more than one sprite useing a single texture!
# Not encountered this yet though.
self.world.consoleOut('setting up animated textures for zone geometry')
for child in self.rootNode.getChildren():
# print child
geom_node = child.node()
for geom_number in range(0, geom_node.getNumGeoms()):
geom_render_state = geom_node.getGeomState(geom_number)
attr = geom_render_state.getAttrib(26) # attrib 26 is the texture attribute (hope this is static)
if attr != None:
# print attr
tex = attr.getTexture()
# print tex # BINGO! now we have the texture for this GEOM, lets find the sprite
sprite = self.zone_wld_container.findSpriteUsing(tex)
if sprite != None:
# print sprite
# set general texture alpha based tansparency for masked textures
# if sprite.masked == 1:
# child.setTransparency(TransparencyAttrib.MAlpha)
if sprite.transparent == 1 or sprite.masked == 1:
# EXPERIMENTAL TRANSPARENCY SUPPORT ###############
# This is for semi-transparent polygons (water surfaces etc)
# we implement the transparency via the alpha component of the GEOM's ColorAttrib
ta = TransparencyAttrib.make(TransparencyAttrib.MAlpha)
geom_render_state = geom_render_state.setAttrib(ta, 1) # potentialy needs passing "int override" (=1?) as second param
if not sprite.masked == 1:
ca = ColorAttrib.makeFlat(Vec4(1, 1, 1, sprite.alpha))
geom_render_state = geom_render_state.setAttrib(ca, 1) # potentialy needs passing "int override" (=1?) as second param
geom_node.setGeomState(geom_number, geom_render_state)
# #####################################################
if sprite.anim_delay > 0:
# ANIMATED SPRITE
# sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
sprite.addAnimGeomRenderState((geom_node, geom_number, geom_render_state))
else:
print 'could not find sprite for geom node, node texture cant be animated'
# load up everything related to this zone
def load(self):
# ---- ZONE GEOMETRY ----
# load main zone s3d
s3dfile_name = self.name+'.s3d'
self.world.consoleOut('zone loading zone s3dfile: ' + s3dfile_name)
s3d = S3DFile(self.basedir+self.name)
if s3d.load() != 0:
self.world.consoleOut( 'ERROR loading s3dfile:' + self.basedir+s3dfile_name)
return -1
# s3d.dumpListing()
# load main zone wld
wldZone = WLDFile(self.name)
# wldZone.setDumpList([0x14, 0x15])
wldZone.load(s3d)
self.zone_wld_container = WLDContainer('zone', self, wldZone, s3d)
self.wld_containers['zone'] = self.zone_wld_container
# load the objects.wld file from the same container
# this basically consists of 0x15 model references for putting all placeables in place
wldZoneObj = WLDFile('objects')
# wldZoneObj.setDumpList([0x14, 0x15])
wldZoneObj.load(s3d)
self.zone_obj_wld_container = WLDContainer('zone_obj', self, wldZoneObj, s3d)
self.wld_containers['zone_obj'] = self.zone_obj_wld_container
# ---- placeables definitions ------------------------------------
s3dfile_name = self.name+'_obj.s3d'
print '-------------------------------------------------------------------------------------'
self.world.consoleOut('zone loading placeable objects s3dfile: ' + s3dfile_name)
s3d = S3DFile(self.basedir+self.name+'_obj')
if s3d.load() == 0:
# s3d.dumpListing()
wldObj1 = WLDFile(self.name+'_obj')
wldObj1.setDumpList([0x14, 0x13, 0x12, 0x11, 0x10])
wldObj1.load(s3d)
self.obj1_wld_container = WLDContainer('obj', self, wldObj1, s3d)
self.wld_containers['obj1'] = self.obj1_wld_container
else:
self.world.consoleOut( 'zone object 1 s3dfile does not exist:' + self.basedir+s3dfile_name)
s3dfile_name = self.name+'_2_obj.s3d'
print '-------------------------------------------------------------------------------------'
self.world.consoleOut('zone loading placeable objects 2 s3dfile: ' + s3dfile_name)
s3d = S3DFile(self.basedir+self.name+'_2_obj')
if s3d.load() == 0:
# s3d.dumpListing()
wldObj2 = WLDFile(self.name+'_2_obj')
# wldObj2.setDumpList([0x14, 0x15, 0x2D, 0x36])
wldObj2.load(s3d)
self.obj2_wld_container = WLDContainer('obj', self, wldObj2, s3d)
self.wld_containers['obj2'] = self.obj2_wld_container
else:
self.world.consoleOut( 'zone object 2 s3dfile does not exist:' + self.basedir+s3dfile_name)
s3dfile_name = self.name+'_chr.s3d'
print '-------------------------------------------------------------------------------------'
self.world.consoleOut('zone loading character s3dfile: ' + s3dfile_name)
s3d = S3DFile(self.basedir+self.name+'_chr')
if s3d.load() == 0:
# s3d.dumpListing()
wldChr = WLDFile(self.name+'_chr')
# wldChr.setDumpList([0x14, 0x15, 0x2D, 0x36])
wldChr.load(s3d)
self.chr_wld_container = WLDContainer('chr', self, wldChr, s3d)
self.wld_containers['chr'] = self.chr_wld_container
else:
self.world.consoleOut( 'zone character s3dfile does not exist:' + self.basedir+s3dfile_name)
# --- TEXTURES ----
self.world.consoleOut('preloading textures')
self.preloadTextures()
# ---- Generate main Zone Geometry ----
self.world.consoleOut( 'preparing zone mesh')
self.prepareZoneMesh()
# let Panda3D attempt to flatten the zone geometry (reduce the excessive
# Geom count resulting from the layout of the .wld zone data as a huge
# bunch of tiny bsp regions)
self.world.consoleOut('flattening zone mesh geom tree')
# self.rootNode.ls()
self.rootNode.flattenStrong()
self.rootNode.ls()
# texture->sprite remapping after the flatten above
self.remapTextures()
# COLLISION:
# The following makes the complete zone base geometry eligible for collisions
# this is of course extremely inefficient. TODO: at some point we need to use the
# bsp structures already provided in the wld file to optimize whats in our scene graph
# and also to build a more intelligent collision system
self.rootNode.setCollideMask(BitMask32.bit(0))
# ---- load MODELS and spawn placeables -----------------------
# go through all the 0x15 refs and create empty model "shells"
# for every unique entry
self.world.consoleOut( 'loading placeables models')
self.mm.loadPlaceables(wldZoneObj)
# self.rootNode.ls()
print 'zone load complete'
self.load_complete = 1
return 0
