def __init__(self,parent,name="unnamed",type=None):
plObjInterface.__init__(self,parent,name,type)
try: #Quick, dirty fix for NameError bug with classes from prp_GeomClasses
self.ambient = RGBA('1.0','1.0','1.0','1.0',type=1)
except NameError:
#print "Damnit! Need reimport prp_GeomClasses.py"
from prp_GeomClasses import RGBA,hsMatrix44
self.ambient = RGBA('1.0','1.0','1.0','1.0',type=1)
self.diffuse = RGBA()
self.specular = RGBA()
self.LightToLocal = hsMatrix44()
self.LocalToLight = hsMatrix44()
self.LightToWorld = hsMatrix44()
self.WorldToLight = hsMatrix44()
self.fProjection = UruObjectRef(self.getVersion()) #plLayerInterface
self.softvol = UruObjectRef(self.getVersion()) #plSoftVolume
self.scenenode = UruObjectRef(self.getVersion()) #Dunno
self.visregs = hsTArray([],self.getVersion()) #plVisRegion[]
class plLightInfo(plObjInterface): #Type 0x54 (Uru)
Props = \
{ \
"kDisable" : 0, \
"kLPObsolete" : 1, \
"kLPCastShadows" : 2, \
"kLPMovable" : 3, \
"kLPHasIncludes" : 4, \
"kLPIncludesChars" : 5, \
"kLP_OBSOLECTE_0" : 6, \
"kLPOverAll" : 7, \
"kLPHasSpecular" : 8, \
"kLPShadowOnly" : 9, \
"kLPShadowLightGroup" : 10, \
"kLPForceProj" : 11, \
"kNumProps" : 12 \
}
scriptProps = \
{ \
"disable" : 0, \
"obsolete" : 1, \
"castshadows" : 2, \
"movable" : 3, \
"hasincludes" : 4, \
"includeschars" : 5, \
"obsolecte_0" : 6, \
"overall" : 7, \
"hasspecular" : 8, \
"shadowonly" : 9, \
"shadowlightgroup" : 10, \
"forceproj" : 11, \
}
def __init__(self,parent,name="unnamed",type=None):
plObjInterface.__init__(self,parent,name,type)
try: #Quick, dirty fix for NameError bug with classes from prp_GeomClasses
self.ambient = RGBA('1.0','1.0','1.0','1.0',type=1)
except NameError:
#print "Damnit! Need reimport prp_GeomClasses.py"
from prp_GeomClasses import RGBA,hsMatrix44
self.ambient = RGBA('1.0','1.0','1.0','1.0',type=1)
self.diffuse = RGBA()
self.specular = RGBA()
self.LightToLocal = hsMatrix44()
self.LocalToLight = hsMatrix44()
self.LightToWorld = hsMatrix44()
self.WorldToLight = hsMatrix44()
self.fProjection = UruObjectRef(self.getVersion()) #plLayerInterface
self.softvol = UruObjectRef(self.getVersion()) #plSoftVolume
self.scenenode = UruObjectRef(self.getVersion()) #Dunno
self.visregs = hsTArray([],self.getVersion()) #plVisRegion[]
def read(self,buf):
plObjInterface.read(self,buf)
self.ambient.read(buf)
self.diffuse.read(buf)
self.specular.read(buf)
self.LightToLocal.read(buf)
self.LocalToLight.read(buf)
self.LightToWorld.read(buf)
self.WorldToLight.read(buf)
self.fProjection.read(buf)
self.softvol.read(buf)
self.scenenode.read(buf)
self.visregs.read(buf)
def write(self,buf):
plObjInterface.write(self,buf)
self.ambient.write(buf)
self.diffuse.write(buf)
self.specular.write(buf)
self.LightToLocal.write(buf)
self.LocalToLight.write(buf)
self.LightToWorld.write(buf)
self.WorldToLight.write(buf)
self.fProjection.write(buf)
self.softvol.write(buf)
self.scenenode.write(buf)
self.visregs.write(buf)
def changePageRaw(self,sid,did,stype,dtype):
plObjInterface.changePageRaw(self,sid,did,stype,dtype)
self.softvol.changePageRaw(sid,did,stype,dtype)
self.layerint.changePageRaw(sid,did,stype,dtype)
self.scenenode.changePageRaw(sid,did,stype,dtype)
self.visregs.changePageRaw(sid,did,stype,dtype)
def _Import(scnobj,prp,obj):
# Lights
for li in scnobj.data1.vector:
if li.Key.object_type in [0x55,0x56,0x57]:
light=prp.findref(li)
light.data.import_obj(obj)
break
# Shadows
for sh in scnobj.data1.vector:
if sh.Key.object_type in [0xD5,0xD6]:
shadow=prp.findref(sh)
shadow.data.import_obj(obj)
Import = staticmethod(_Import)
def _Export(page,obj,scnobj,name,SceneNodeRef,softVolumeParser):
# --- Determine Lamp type and Shadow Type ---
shadow = None
if obj.data.type==Blender.Lamp.Types["Spot"]:
# plSpotLightInfo
lamp=plSpotLightInfo.FindCreate(page,name)
if obj.data.mode & Blender.Lamp.Modes["RayShadow"]:
# plPointShadowMaster
shadow = plPointShadowMaster.FindCreate(page,name)
elif obj.data.type==Blender.Lamp.Types["Lamp"]:
# plOmniLightInfo
lamp=plOmniLightInfo.FindCreate(page,name)
if obj.data.mode & Blender.Lamp.Modes["RayShadow"]:
# plPointShadowMaster
shadow = plPointShadowMaster.FindCreate(page,name)
elif obj.data.type==Blender.Lamp.Types["Area"]:
# plLimitedDirLightInfo
lamp=plLimitedDirLightInfo.FindCreate(page,name)
if obj.data.mode & Blender.Lamp.Modes["RayShadow"]:
# plDirectionalShadowMaster
shadow = plDirectShadowMaster.FindCreate(page,name)
else:
# plDirectionalLightInfo
lamp=plDirectionalLightInfo.FindCreate(page,name)
if obj.data.mode & Blender.Lamp.Modes["RayShadow"]:
# plDirectionalShadowMaster
shadow = plDirectShadowMaster.FindCreate(page,name)
# --- Check if Lamp has a projection layer --- (HACK WARNING)
lampscript = AlcScript.objects.Find(obj.getName())
layername = FindInDict(lampscript,"lamp.layer",None)
if(layername != None):
print " Attatching layer: " + layername
refparser = ScriptRefParser(page, name, 0x0006, [0x0006, 0x0043,])
layer = refparser.MixedRef_FindCreate(layername)
lamp.data.fProjection = layer.data.getRef()
# set the projection flags depending on the lamp type
if obj.data.type==Blender.Lamp.Types["Spot"]:
layer.data.fState.fMiscFlags |= hsGMatState.hsGMatMiscFlags["kMiscPerspProjection"]
elif obj.data.type==Blender.Lamp.Types["Area"]:
layer.data.fState.fMiscFlags |= hsGMatState.hsGMatMiscFlags["kMiscOrthoProjection"]
# now we set the uvw transform on the layer
texMatrix = getMatrix(obj)
texMatrix.transpose()
layer.data.fTransform.set(texMatrix)
# --- Prepare and Export lamp object ---
lamp.data.parentref=scnobj.data.getRef()
lamp.data.scenenode=SceneNodeRef
lamp.data.softVolumeParser = softVolumeParser
lamp.data.export_object(obj)
scnobj.data.data1.append(lamp.data.getRef())
# --- Prepare and Export Shadow object ---
if shadow != None:
shadow.data.parentref=scnobj.data.getRef()
shadow.data.export_obj(obj)
scnobj.data.data1.append(shadow.data.getRef())
Export = staticmethod(_Export)
def export_object(self,obj):
lamp=obj.data
objscript = AlcScript.objects.Find(obj.getName())
print " [Light Base]\n";
#set lighting flags
try:
p=obj.getProperty("flags")
name=str(p.getData())
while len(name)<8:
name = "0" + name
b=binascii.unhexlify(str(name))
l,=struct.unpack(">I",b)
except (AttributeError, RuntimeError):
l=0
self.BitFlags.append(l)
# Determine negative lighting....
if lamp.mode & (Lamp.Modes["Negative"]):
print " >>>Negative light<<<"
R = 0.0 - lamp.R
G = 0.0 - lamp.G
B = 0.0 - lamp.B
else:
R = lamp.R
G = lamp.G
B = lamp.B
# Plasma has the same Lights as DirectX:
#
energy = lamp.energy * 2
# Diffuse:
if lamp.mode & (Lamp.Modes["NoDiffuse"]):
print " Diffuse Lighting Disabled";
self.diffuse=RGBA(0.0,0.0,0.0,1.0,type=1)
else:
print " Diffuse Lighting Enabled";
self.diffuse=RGBA(R*energy,G*energy,B*energy,1.0,type=1)
# Specular
if lamp.mode & (Lamp.Modes["NoSpecular"]):
print " Specular Lighting Disabled";
self.specular=RGBA(0.0,0.0,0.0,1.0,type=1)
else:
print " Specular Lighting Enabled";
self.specular=RGBA(R*energy,G*energy,B*energy,1.0,type=1)
# Ambient:
# Light not directly emitted by the light source, but present because of it.
# If one wants to use a lamp as ambient, disable both diffuse and specular colors
# Else, it's just set to 0,0,0 aka not used.
if lamp.mode & (Lamp.Modes["NoSpecular"] | Lamp.Modes["NoDiffuse"]):
print " Lamp is set as ambient light"
self.ambient = RGBA(R * energy, G * energy, B * energy,1.0,type=1)
else:
self.ambient = RGBA(0.0, 0.0, 0.0, 0.0, type=1)
# Now Calculate the matrix:
m=getMatrix(obj)
m.transpose()
# Note:
# In Blender, the Light cannot be moved in local space,
# so Light To Local is not needed, and can remain a unity matrix.
#
#
# self.LightToLocal.set(m)
# self.LocalToLight.set(m)
self.LightToWorld.set(m)
m.invert()
self.WorldToLight.set(m)
#Set some shadow flags
if lamp.mode & (Lamp.Modes["RayShadow"]):
if prp_Config.ver2==11:
#Added because UU crashes on kLPCastShadows. Shadow is cast anyway because of kSelfShadow.
#So do we need this flag at all?
print " >>> !kLPCastShadows <<< UU compatible"
self.BitFlags[plLightInfo.Props["kLPCastShadows"]] = 0
else:
print " >>> kLPCastShadows <<<"
self.BitFlags[plLightInfo.Props["kLPCastShadows"]] = 1
else:
print " >>> !kLPCastShadows <<<"
self.BitFlags[plLightInfo.Props["kLPCastShadows"]] = 0
if lamp.mode & (Lamp.Modes["OnlyShadow"]):
print " >>> kLPShadowOnly <<<"
self.BitFlags[plLightInfo.Props["kLPShadowOnly"]] = 1
else:
print " >>> !kLPShadowOnly <<<"
self.BitFlags[plLightInfo.Props["kLPShadowOnly"]] = 0
# Set the soft volume
propString = FindInDict(objscript,"lamp.softvolume")
propString = getTextPropertyOrDefault(obj,"softvolume",propString)
if (propString != None):
if(self.softVolumeParser != None and self.softVolumeParser.isStringProperty(propString)):
self.softvol = self.softVolumeParser.parseProperty(propString,str(self.Key.name))
else:
refparser = ScriptRefParser(self.getRoot(),str(self.Key.name),"softvolume")
volume = refparser.MixedRef_FindCreate(propString)
self.softvol = volume.data.getRef()
propString = FindInDict(objscript,"lamp.visregions", [])
if type(propString) == list:
for reg in propString:
if (reg != None):
if(self.softVolumeParser != None and self.softVolumeParser.isStringProperty(str(reg))):
volume = self.softVolumeParser.parseProperty(str(reg),str(self.Key.name))
else:
refparser = ScriptRefParser(self.getRoot(),str(self.Key.name),"softvolume")
volume = refparser.MixedRef_FindCreateRef(reg)
vr = self.getRoot().find(0x0116, volume.Key.name, 1)
vr.data.scenenode = self.scenenode
vr.data.BitFlags.clear()
vr.data.BitFlags.SetBit(plVisRegion.VecFlags["kReplaceNormal"])
vr.data.fRegion = volume
self.visregs.append(vr.data.getRef())
flags = FindInDict(objscript,"lamp.flags",None)
if type(flags) == list:
self.BitFlags = hsBitVector() # reset
for flag in flags:
if flag.lower() in plLightInfo.scriptProps:
print " set flag: " + flag.lower()
idx = plLightInfo.scriptProps[flag.lower()]
self.BitFlags.SetBit(idx)
