def __CreateBakeEffect(self):
"""
Create and setup a planet's effect file for heightmap baking
"""
self.effectHeight = trinity.Tr2Effect()
if self.effectHeight is None:
self.LogError('Could not create effect for planet with id',
self.itemID)
return
mainMesh = self.model.highDetail.children[0].meshLod
if mainMesh is None:
mainMesh = self.model.highDetail.children[0].mesh
errorMsg = 'No LODs found on planet.\n'
modelPath = 'modelPath=' + self.modelPath + '\n'
presetPath = 'presetPath=' + self.presetPath + '\n'
shaderPreset = 'shaderPreset=' + str(
self.attributes.shaderPreset) + '\n'
self.LogError(errorMsg, modelPath, presetPath, shaderPreset)
if len(mainMesh.transparentAreas) > 0:
resPath = mainMesh.transparentAreas[0].effect.effectFilePath
elif len(mainMesh.opaqueAreas) > 0:
resPath = mainMesh.opaqueAreas[0].effect.effectFilePath
else:
self.LogError('Unexpected program flow! Loading fallback shader.')
resPath = 'res:/Graphics/Effect/Managed/Space/Planet/EarthlikePlanet.fx'
resPath = resPath.replace('.fx', 'BlitHeight.fx')
self.effectHeight.effectFilePath = resPath
if self.__GetHeightMap1() is not None and self.__GetHeightMap2(
) is not None:
param1 = trinity.TriTexture2DParameter()
param1.name = 'NormalHeight1'
self.heightMapResPath1 = util.GraphicFile(self.__GetHeightMap1())
self.effectHeight.resources.append(param1)
param2 = trinity.TriTexture2DParameter()
param2.name = 'NormalHeight2'
self.heightMapResPath2 = util.GraphicFile(self.__GetHeightMap2())
self.effectHeight.resources.append(param2)
param3 = trinity.Tr2FloatParameter()
param3.name = 'Random'
param3.value = float(self.itemID % 100)
self.effectHeight.parameters.append(param3)
param4 = trinity.Tr2FloatParameter()
param4.name = 'TargetTextureHeight'
param4.value = 2048
self.effectHeight.parameters.append(param4)
paramList = self.__GetPlanetShaderParameters(
'', 'trinity.Tr2Vector4Parameter')
for param in paramList:
self.effectHeight.parameters.append(param)
paramList = self.__GetPlanetShaderParameters(
'', 'trinity.Tr2FloatParameter')
for param in paramList:
self.effectHeight.parameters.append(param)
resList = self.__GetPlanetShaderParameters(
'', 'trinity.TriTexture2DParameter')
for res in resList:
self.effectHeight.resources.append(res)
def SetupStencilBlitEffect(self):
self.stencilBlitEffect = trinity.Tr2Effect()
self.stencilBlitEffect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/system/BlitStencil.fx'
stencilMap = trinity.TriTexture2DParameter()
stencilMap.name = 'StencilMap'
stencilMap.resourcePath = self.stencilPath
self.stencilBlitEffect.resources.append(stencilMap)
self.blitMapParameter = trinity.TriTexture2DParameter()
self.blitMapParameter.name = 'BlitSource'
self.stencilBlitEffect.resources.append(self.blitMapParameter)
def _ExpandOpaque(self, bodyPart, targetTex):
"""
Using pre-generated masks, we bleed the opaque accross the edges defined by said masks.
This reduces visible seams when the tattoos have been projected in object space so that
their pixels in UV space aren't continuous.
"""
eoMaskPath = 'res:/graphics/character/global/tattoomask/{0}_opaque_mask_{1}.dds'.format(self._gender, bodyPart)
eoMaskRes = blue.resMan.GetResource(eoMaskPath)
fx = trinity.Tr2Effect()
fx.effectFilePath = EO_SHADERRES
while eoMaskRes.isLoading or fx.effectResource.isLoading:
PD.Yield()
tex = trinity.TriTexture2DParameter()
tex.name = 'Mask'
tex.SetResource(eoMaskRes)
fx.resources.append(tex)
v = trinity.Tr2Vector2Parameter()
v.name = 'gMaskSize'
v.value = (eoMaskRes.width, eoMaskRes.height)
fx.parameters.append(v)
tex = trinity.TriTexture2DParameter()
tex.name = 'Texture'
tex.SetResource(targetTex)
fx.resources.append(tex)
v = trinity.Tr2Vector2Parameter()
v.name = 'gTextureSize'
v.value = (targetTex.width, targetTex.height)
fx.parameters.append(v)
fx.RebuildCachedData()
vp = trinity.TriViewport()
vp.width = targetTex.width
vp.height = targetTex.height
expandedRT = trinity.Tr2RenderTarget(vp.width, vp.height, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
rj = trinity.CreateRenderJob('Expanding Opaque')
rj.PushRenderTarget(expandedRT)
rj.SetProjection(trinity.TriProjection())
rj.SetView(trinity.TriView())
rj.SetViewport(vp)
rj.PushDepthStencil(None)
rj.Clear((0.0, 0.0, 0.0, 0.0))
rj.SetStdRndStates(trinity.RM_FULLSCREEN)
rj.SetRenderState(trinity.D3DRS_SEPARATEALPHABLENDENABLE, 1)
rj.SetRenderState(trinity.D3DRS_SRCBLENDALPHA, trinity.TRIBLEND_ONE)
rj.SetRenderState(trinity.D3DRS_DESTBLENDALPHA, trinity.TRIBLEND_ZERO)
rj.RenderEffect(fx)
rj.SetRenderTarget(targetTex.wrappedRenderTarget)
rj.RenderTexture(expandedRT)
rj.PopRenderTarget()
rj.PopDepthStencil()
rj.ScheduleChained()
rj.WaitForFinish()
def CreateCurvedLineSet(self, effectPath = None):
lineSet = trinity.EveCurveLineSet()
if effectPath is not None:
lineSet.lineEffect.effectFilePath = effectPath
texMap = trinity.TriTexture2DParameter()
texMap.name = 'TexMap'
texMap.resourcePath = 'res:/dx9/texture/UI/lineSolid.dds'
lineSet.lineEffect.resources.append(texMap)
overlayTexMap = trinity.TriTexture2DParameter()
overlayTexMap.name = 'OverlayTexMap'
overlayTexMap.resourcePath = 'res:/dx9/texture/UI/lineOverlay5.dds'
lineSet.lineEffect.resources.append(overlayTexMap)
return lineSet
def Create3DRender(self):
self.renderTexture = trinity.TriTexture2DParameter()
self.renderTexture.name = 'DiffuseMap'
self.renderColor = trinity.TriVector4Parameter()
self.renderColor.name = 'DiffuseColor'
self.renderColor.value = (1, 1, 1, 1)
self.renderEffect = trinity.Tr2Effect()
self.renderEffect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
self.renderEffect.resources.append(self.renderTexture)
self.renderEffect.parameters.append(self.renderColor)
self.renderArea = trinity.Tr2MeshArea()
self.renderArea.effect = self.renderEffect
self.renderMesh = trinity.Tr2Mesh()
self.renderMesh.name = 'orbitalBombardmentTarget'
self.renderMesh.geometryResPath = 'res:/Graphics/Generic/UnitPlane/UnitPlane.gr2'
self.renderMesh.transparentAreas.append(self.renderArea)
self.transform = trinity.EveRootTransform()
self.transform.mesh = self.renderMesh
self.renderScene.objects.append(self.transform)
self.renderJob = trinity.CreateRenderJob()
self.renderJob.Update(self.renderScene)
self.renderObject = self.GetRenderObject()
self.renderObject.is2dPick = False
self.renderTarget = trinity.Tr2RenderTarget(
self.width, self.height, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
self.renderJob.PushRenderTarget(self.renderTarget)
self.renderJob.RenderScene(self.renderObject)
self.renderJob.PopRenderTarget()
self.renderJob.ScheduleRecurring(insertFront=True)
self.renderTexture.SetResource(trinity.TriTextureRes(
self.renderTarget))
self.renderSteps[-1].enabled = False
return self.transform
def PrepareAreasForConstruction(self, areas, alphaParams, prefix):
sovShaders = False
slimItem = self.typeData.get('slimItem')
if slimItem is not None:
groupID = slimItem.groupID
if groupID in [const.groupSovereigntyDisruptionStructures, const.groupInfrastructureHub]:
sovShaders = True
for each in areas:
if 'alpha_' not in each.effect.effectFilePath and 'v3.fx' not in each.effect.effectFilePath.lower():
effectFilePathInsertPos = each.effect.effectFilePath.rfind('/')
if effectFilePathInsertPos != -1:
filePath = each.effect.effectFilePath
if prefix + each.effect.name not in self.savedShaders:
self.savedShaders[prefix + str(id(each))] = filePath
if sovShaders:
skp = filePath[effectFilePathInsertPos + 1:].lower().find('skinned_')
if skp >= 0:
each.effect.effectFilePath = filePath[:effectFilePathInsertPos + 1] + 'alpha_' + filePath[effectFilePathInsertPos + 9:]
else:
each.effect.effectFilePath = filePath[:effectFilePathInsertPos + 1] + 'alpha_' + filePath[effectFilePathInsertPos + 1:]
else:
each.effect.effectFilePath = filePath[:effectFilePathInsertPos + 1] + 'alpha_' + filePath[effectFilePathInsertPos + 1:]
alphaParam = self.FindOrMakeAlphathreshold(each.effect, 1.0, 0.0, 0.0, 0.0)
alphaParams.append(alphaParam)
each.effect.parameters.fremove(alphaParam)
each.effect.parameters.append(alphaParam)
alphaMap = trinity.TriTexture2DParameter()
alphaMap.name = 'AlphaThresholdMap'
alphaMap.resourcePath = CONSTRUCTION_MATERIAL
each.effect.resources.append(alphaMap)
each.effect.RebuildCachedData()
def AddTex2D(self, effect, name, resourcePath = None):
param = trinity.TriTexture2DParameter()
param.name = name
if resourcePath is not None:
param.resourcePath = resourcePath
effect.resources.append(param)
return param
def SetStencilMap(self, path='res:/UI/Texture/circleStencil.dds'):
if hasattr(self.renderJob, 'SetStencil'):
self.renderJob.SetStencil(path)
stencilMap = trinity.TriTexture2DParameter()
stencilMap.name = 'StencilMap'
stencilMap.resourcePath = path
self.scene.backgroundEffect.resources.append(stencilMap)
self.scene.backgroundEffect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/NebulaWithStencil.fx'
def makeBitmapStep(filePath, scaleToFit = True, color = (1.0, 1.0, 1.0, 1.0), targetSize = None):
"""
Helper function to create a renderstep that shows a bitmap without stretching, by scaling it or adding black.
http://carbon/wiki/Core_Graphics_Snippets
"""
tex = trinity.TriTexture2DParameter()
tex.name = 'Texture'
tex.resourcePath = filePath
if targetSize is None:
bb = trinity.device.GetRenderContext().GetDefaultBackBuffer()
targetSize = (bb.width, bb.height)
fx = trinity.Tr2Effect()
fx.effectFilePath = 'res:/Graphics/Effect/Managed/Space/System/ColoredBlit.fx'
fx.resources.append(tex)
while tex.resource.isLoading:
blue.synchro.Yield()
sw = float(tex.resource.width)
sh = float(tex.resource.height)
tw = float(targetSize[0])
th = float(targetSize[1])
v = trinity.Tr2Vector4Parameter()
v.name = 'Color'
v.value = color
fx.parameters.append(v)
v = trinity.Tr2Vector4Parameter()
v.name = 'SourceUVs'
fx.parameters.append(v)
sourceAspect = sw / sh
targetAspect = tw / th
if scaleToFit:
if targetAspect > sourceAspect:
span = targetAspect / sourceAspect
v.value = (0.5 - 0.5 * span,
0.0,
0.5 + 0.5 * span,
1.0)
else:
span = sourceAspect / targetAspect
v.value = (0,
0.5 - 0.5 * span,
1.0,
0.5 + 0.5 * span)
elif targetAspect > sourceAspect:
d = 1.0 - sw * th / (sh * tw)
d *= 0.5
v.value = (0.0,
d,
1.0,
1.0 - d)
else:
d = 1.0 - tw * sh / (th * sw)
d *= 0.5
v.value = (d,
0.0,
1.0 - d,
1.0)
return trinity.TriStepRenderEffect(fx)
def DuplicateResource(targetEffect, sourceEffect, name):
"""
Make sure a resource called name exists on targetEffect, pointing back to sourceEffect
"""
p = trinity.TriTexture2DParameter()
p.name = name
p.SetResource(
SkinLightmapRenderer.FindResource(sourceEffect, name).resource)
targetEffect.resources.append(p)
def CopyResource(res):
if res is None:
return
newRes = trinity.TriTexture2DParameter()
newRes.name = res.name
newRes.resourcePath = res.resourcePath
if res.resourcePath == '' and res.resource is not None:
newRes.SetResource(res.resource)
return newRes
def ConstructDebugLineset(self):
""" Construct a lineset in the active scene for debugging purposes """
if hasattr(self, 'debugLineSet'):
scene = sm.GetService('sceneManager').GetActiveScene()
if self.debugLineSet in scene.objects:
return
self.debugLineSet = trinity.EveCurveLineSet()
self.debugLineSet.scaling = (1.0, 1.0, 1.0)
tex2D1 = trinity.TriTexture2DParameter()
tex2D1.name = 'TexMap'
tex2D1.resourcePath = 'res:/texture/global/lineSolid.dds'
self.debugLineSet.lineEffect.resources.append(tex2D1)
tex2D2 = trinity.TriTexture2DParameter()
tex2D2.name = 'OverlayTexMap'
tex2D2.resourcePath = 'res:/UI/Texture/Planet/link.dds'
self.debugLineSet.lineEffect.resources.append(tex2D2)
scene = sm.GetService('sceneManager').GetActiveScene()
scene.objects.append(self.debugLineSet)
return self.debugLineSet
def AddTex2D(self, effect, name, resourcePath=None):
"""
Helper to save typing when attaching texture maps to an effect.
"""
param = trinity.TriTexture2DParameter()
param.name = name
if resourcePath is not None:
param.resourcePath = resourcePath
effect.resources.append(param)
return param
def CreateLineset(self):
"""
Creates a lineset.
"""
lineSet = trinity.EveCurveLineSet()
lineSet.scaling = (1.0, 1.0, 1.0)
tex2D1 = trinity.TriTexture2DParameter()
tex2D1.name = 'TexMap'
tex2D1.resourcePath = 'res:/dx9/texture/UI/lineSolid.dds'
lineSet.lineEffect.resources.append(tex2D1)
return lineSet
def CreateOrbits(self, child_parent, objectTransforms):
lineSet = trinity.EveCurveLineSet()
lineSet.name = 'OrbitLines'
lineSet.depthOffset = 10000000.0
self.systemMapTransform.children.append(lineSet)
tex2D = trinity.TriTexture2DParameter()
tex2D.name = 'TexMap'
tex2D.resourcePath = 'res:/UI/Texture/classes/MapView/lineSegment.dds'
lineSet.lineEffect.resources.append(tex2D)
overlayTex2D = trinity.TriTexture2DParameter()
overlayTex2D.name = 'OverlayTexMap'
overlayTex2D.resourcePath = 'res:/UI/Texture/classes/MapView/lineSegment.dds'
lineSet.lineEffect.resources.append(overlayTex2D)
for childID, parentID in child_parent:
if childID in objectTransforms and parentID in objectTransforms:
self.CreateOrbitCircle(objectTransforms[childID],
objectTransforms[parentID], lineSet)
if lineSet:
lineSet.SubmitChanges()
def AddMaterialParam(material, name, value):
if type(value) == trinity.TriTextureRes:
param = trinity.TriTexture2DParameter()
param.name = name
param.SetResource(value)
elif type(value) == trinity.Tr2RenderTarget:
param = trinity.TriTexture2DParameter()
param.name = name
t = trinity.TriTextureRes(value)
param.SetResource(t)
elif type(value) == trinity.Tr2DepthStencil:
param = trinity.TriTexture2DParameter()
param.name = name
t = trinity.TriTextureRes(value)
param.SetResource(t)
else:
param = trinity.Tr2Vector4Parameter()
param.name = name
param.value = value
material.parameters[name] = param
def CreateLineSet(self,
lsName,
transform,
animationTexture=None,
scale=1.0):
ls = trinity.EveCurveLineSet()
ls.scaling = (scale, scale, scale)
tex2D_1 = trinity.TriTexture2DParameter()
tex2D_1.name = 'TexMap'
tex2D_1.resourcePath = 'res:/texture/global/lineSolid.dds'
ls.lineEffect.resources.append(tex2D_1)
if animationTexture:
tex2D_2 = trinity.TriTexture2DParameter()
tex2D_2.name = 'OverlayTexMap'
tex2D_2.resourcePath = animationTexture
ls.lineEffect.resources.append(tex2D_2)
self.lineSets[lsName] = ls
transform.children.append(ls)
self.transformsByLineSets[ls] = transform
return ls
def CreateResource(self,
effect,
paramName,
resPath,
cutoutName=None,
paramType=None,
mapType=''):
"""
Creates a resource using blue resource manager.
"""
if paramType is None:
paramType = trinity.TriTexture2DParameter()
paramRes = None
error = False
skipLoad = False
atlasUVs = None
if not resPath:
error = True
elif type(resPath) in types.StringTypes:
if type(resPath) == types.UnicodeType:
resPath = str(resPath)
if self.atlasData:
paramRes, atlasUVs = self.atlasData.GetTexture(resPath)
if not paramRes:
if self.targetWidth > 0 and self.resData:
resDataEntry = self.resData.GetEntryByFullResPath(resPath)
if resDataEntry:
resPath = resDataEntry.GetMapResolutonMatch(
resPath, self.targetWidth)
paramRes = rm.GetResource(resPath)
skipLoad = not paramRes.isLoading
elif type(resPath) == trinity.TriTextureRes:
paramRes = resPath
skipLoad = True
elif hasattr(resPath, 'resource'):
paramRes = resPath.resource
else:
error = True
if error or paramRes is None:
raise Exception('Invalid resource passed to texture compositor!')
sys.exc_clear()
param = paramType
param.name = paramName
param.SetResource(paramRes)
item = (paramRes, effect, cutoutName, mapType, atlasUVs)
if cutoutName:
self.texturesWithCutouts.append(item)
if not skipLoad:
self.texturesByResourceID[id(paramRes)] = item
if paramRes not in self.resourcesToLoad:
self.resourcesToLoad.append(paramRes)
return param
def SetOrAddMap(effect, mapName, mapPath=None):
for res in effect.resources:
if res.name == mapName:
if mapPath:
res.resourcePath = mapPath
return res
map = trinity.TriTexture2DParameter()
map.name = mapName
if mapPath:
map.resourcePath = mapPath
effect.resources.append(map)
return map
def CopyResources(sourceEffect, targetMaterial, resourceNames):
if hasattr(sourceEffect, 'resources'):
for res in sourceEffect.resources:
if res.name not in resourceNames or type(res) != trinity.TriTexture2DParameter:
continue
newParameter = trinity.TriTexture2DParameter()
newParameter.name = res.name
newParameter.resourcePath = res.resourcePath
if res.resourcePath == '' and res.resource is not None:
newParameter.SetResource(res.resource)
if type(targetMaterial) == trinity.Tr2Effect:
targetMaterial.resources.append(newParameter)
else:
targetMaterial.parameters[res.name] = newParameter
def createMeshAreaParams(self, meshArea, isDecal, isCloth = False, isTranslucent = False):
"""
Create the effect needed to draw mesh into the shadow map during the depth pass.
The effect will use a skinned or non-skinned shader, based on not-cloth or cloth.
For opaque vs. decals, only one shader is needed -- a spotlight.x parameter controls
if the diffuse alpha should be used or not to do alphatesting.
"""
shadowEffect = trinity.Tr2Effect()
shadowEffect.effectFilePath = SPOTLIGHT_SHADOW_EFFECT if not isCloth else SPOTLIGHT_SHADOW_EFFECT_CLOTH
v = trinity.Tr2Vector4Parameter()
v.name = 'spotlight'
v.value = (float(isDecal),
1.0 / self.shadowResolution,
float(isTranslucent),
1)
shadowEffect.parameters.append(v)
effect = None
if hasattr(meshArea, 'effect') and meshArea.effect:
effect = meshArea.effect
elif hasattr(meshArea, 'effectReversed') and meshArea.effectReversed:
effect = meshArea.effectReversed
if type(effect) is not trinity.Tr2Effect:
return
if effect and isDecal:
for p in effect.parameters:
if p.name == 'TransformUV0':
v = trinity.Tr2Vector4Parameter()
v.name = p.name
v.value = p.value
shadowEffect.parameters.append(v)
elif p.name == 'CutMaskInfluence':
v = trinity.Tr2FloatParameter()
v.name = p.name
v.value = p.value
shadowEffect.parameters.append(v)
for r in effect.resources:
if r.name == 'DiffuseMap' or r.name == 'CutMaskMap':
t = trinity.TriTexture2DParameter()
t.name = r.name
t.SetResource(r.resource)
shadowEffect.resources.append(t)
shadowEffect.RebuildCachedData()
if effect:
pdCcf.AddWeakBlue(self, 'meshAreaShadowEffect', meshArea, shadowEffect)
pdCcf.AddWeakBlue(self, 'meshAreaOriginalEffect', meshArea, meshArea.effect)
def BindInteriorShader(self, effect, wrinkleFx, doll, suffix):
"""
Look at the LOD, and attach the hero/skin/linear shaders that the asset may not have been exported with.
wrinkleFx - contains all the effects that are part of the head.
suffix - which permutation of the shaders are we interested in (dxt5 and such)
"""
path = effect.effectFilePath.lower()
if pdDef.DOLL_PARTS.HAIR not in path:
if doll.currentLOD >= 0:
if 'skinnedavatarbrdf' not in path:
effect.effectFilePath = '{0}{1}'.format(
pdDef.INTERIOR_AVATAR_EFFECT_FILE_PATH[:-3], suffix)
for r in effect.resources:
if r.name == 'FresnelLookupMap':
break
else:
res = trinity.TriTexture2DParameter()
res.name = 'FresnelLookupMap'
res.resourcePath = pdDef.FRESNEL_LOOKUP_MAP
effect.resources.append(res)
elif doll.currentLOD == pdDef.LOD_A:
pass
elif doll.currentLOD in [pdDef.LOD_SKIN]:
pdPor.PortraitTools.BindSkinShader(
effect,
wrinkleFx,
scattering=False,
buildDataManager=doll.buildDataManager,
gender=doll.gender,
use_png=pdDef.USE_PNG,
fxSuffix=suffix)
pdPor.PortraitTools.BindLinearAvatarBRDF(effect, suffix)
elif doll.currentLOD == pdDef.LOD_SCATTER_SKIN:
pdPor.PortraitTools.BindSkinShader(
effect,
wrinkleFx,
scattering=True,
buildDataManager=doll.buildDataManager,
gender=doll.gender,
use_png=pdDef.USE_PNG,
fxSuffix=suffix)
pdPor.PortraitTools.BindLinearAvatarBRDF(effect, suffix)
elif doll.currentLOD <= 0:
pdPor.PortraitTools.BindHeroHairShader(effect, suffix)
def createMeshAreaParams(self,
meshArea,
isDecal,
isCloth=False,
isTranslucent=False):
shadowEffect = trinity.Tr2Effect()
shadowEffect.effectFilePath = SPOTLIGHT_SHADOW_EFFECT if not isCloth else SPOTLIGHT_SHADOW_EFFECT_CLOTH
v = trinity.Tr2Vector4Parameter()
v.name = 'spotlight'
v.value = (float(isDecal), 1.0 / self.shadowResolution,
float(isTranslucent), 1)
shadowEffect.parameters.append(v)
effect = None
if hasattr(meshArea, 'effect') and meshArea.effect:
effect = meshArea.effect
elif hasattr(meshArea,
'effectReversed') and meshArea.effectReversed:
effect = meshArea.effectReversed
if type(effect) is not trinity.Tr2Effect:
return
if effect and isDecal:
for p in effect.parameters:
if p.name == 'TransformUV0':
v = trinity.Tr2Vector4Parameter()
v.name = p.name
v.value = p.value
shadowEffect.parameters.append(v)
elif p.name == 'CutMaskInfluence':
v = trinity.Tr2FloatParameter()
v.name = p.name
v.value = p.value
shadowEffect.parameters.append(v)
for r in effect.resources:
if r.name == 'DiffuseMap' or r.name == 'CutMaskMap':
t = trinity.TriTexture2DParameter()
t.name = r.name
t.SetResource(r.resource)
shadowEffect.resources.append(t)
shadowEffect.RebuildCachedData()
if effect:
PD.AddWeakBlue(self, 'meshAreaShadowEffect', meshArea,
shadowEffect)
PD.AddWeakBlue(self, 'meshAreaOriginalEffect', meshArea,
meshArea.effect)
def Initialize(self, size, speed, amplitude, tiling, texturePath):
"""
Initializes the output texture, render job, builds render steps.
Returns the output texture.
"""
def TextureDestroyed():
"""
Closure for weakref callback. Destroys the
render job.
"""
self.Destroy()
texture = trinity.Tr2RenderTarget(size, size, 1,
trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
self.name = 'Caustics'
self.size = size
self.texture = blue.BluePythonWeakRef(texture)
self.texture.callback = TextureDestroyed
self.steps.append(trinity.TriStepPushRenderTarget(texture))
self.steps.append(trinity.TriStepClear((0, 0, 0, 0)))
self.steps.append(trinity.TriStepSetStdRndStates(
trinity.RM_FULLSCREEN))
material = trinity.Tr2ShaderMaterial()
material.highLevelShaderName = 'Caustics'
param = trinity.TriTexture2DParameter()
param.name = 'Texture'
param.resourcePath = texturePath
material.parameters['Texture'] = param
param = trinity.Tr2FloatParameter()
param.name = 'Speed'
param.value = speed
material.parameters['Speed'] = param
param = trinity.Tr2FloatParameter()
param.name = 'Amplitude'
param.value = amplitude
material.parameters['Amplitude'] = param
param = trinity.Tr2FloatParameter()
param.name = 'Tiling'
param.value = tiling
material.parameters['Tiling'] = param
material.BindLowLevelShader([])
self.steps.append(trinity.TriStepRenderFullScreenShader(material))
self.steps.append(trinity.TriStepPopRenderTarget())
trinity.renderJobs.recurring.append(self)
return trinity.TriTextureRes(texture)
def SetOrAddMap(effect, mapName, mapPath=None):
"""
Simple helper to set the path of a resource, or add it with that path if it doesn't exist yet.
In other words make sure a given texture always exists on some mesh, and points at mapPath if that
isn't None. Returns the found or newly created texture map.
"""
for res in effect.resources:
if res.name == mapName:
if mapPath:
res.resourcePath = mapPath
return res
map = trinity.TriTexture2DParameter()
map.name = mapName
if mapPath:
map.resourcePath = mapPath
effect.resources.append(map)
return map
def TransferArrayToTexture(cut, mat1, mat2, spec):
pixels = []
def GetFromArray(array, index, component=0, default=0):
if array is None or not hasattr(
array,
'value') or index >= len(array.value):
return default
v = array.value[index]
if type(v) == trinity.TriVector4:
return v.data[component]
return v
OPT_CUTOUT = 8
OPT_DOUBLE_MATERIAL = 16
for x in xrange(32):
infoList = collapsedMeshes.get(mesh, [])
infoTuple = infoList[x] if x < len(infoList) else (
0, 0, 0, 0)
permute = infoTuple[3]
table = paperDollPrePassFixup.MATERIAL_ID_TRANSPARENT_HACK_EXACT if infoTuple[
1] == 2 else paperDollPrePassFixup.MATERIAL_ID_EXACT
r = int(0.5 + 100 * GetFromArray(cut, x))
if permute & OPT_CUTOUT:
r += 128
g = int(GetFromArray(mat1, x))
if permute & OPT_DOUBLE_MATERIAL:
b = int(GetFromArray(mat2, x))
else:
b = g
a = int(0.5 +
50 * GetFromArray(spec, x, component=2))
pixels.append(
(x, 0, (a << 24) + (r << 16) + (g << 8) + b))
hb = trinity.Tr2HostBitmap(
32, 1, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
hb.SetPixels(0, pixels, 0)
lookup = trinity.TriTextureRes()
lookup.CreateFromHostBitmap(hb)
texParam = trinity.TriTexture2DParameter()
texParam.name = 'CollapsedMeshArrayLookup'
texParam.SetResource(lookup)
return texParam
def CopyResources(sourceEffect, targetMaterial, resourceNames):
"""
Make a single pass through all resources in the effect, and if a resource's name is found in
the set resourceNames, copy the resource into the material.
"""
if hasattr(sourceEffect, 'resources'):
for res in sourceEffect.resources:
if res.name not in resourceNames or type(
res) != trinity.TriTexture2DParameter:
continue
newParameter = trinity.TriTexture2DParameter()
newParameter.name = res.name
newParameter.resourcePath = res.resourcePath
if res.resourcePath == '' and res.resource is not None:
newParameter.SetResource(res.resource)
if type(targetMaterial) == trinity.Tr2Effect:
targetMaterial.resources.append(newParameter)
else:
targetMaterial.parameters[res.name] = newParameter
def BindInteriorShader(self, effect, wrinkleFx, doll, suffix):
path = effect.effectFilePath.lower()
if PD.DOLL_PARTS.HAIR not in path:
if doll.currentLOD >= 0:
if 'skinnedavatarbrdf' not in path:
effect.effectFilePath = '{0}{1}'.format(
PD.INTERIOR_AVATAR_EFFECT_FILE_PATH[:-3], suffix)
for r in effect.resources:
if r.name == 'FresnelLookupMap':
break
else:
res = trinity.TriTexture2DParameter()
res.name = 'FresnelLookupMap'
res.resourcePath = PD.FRESNEL_LOOKUP_MAP
effect.resources.append(res)
elif doll.currentLOD == PD.LOD_A:
pass
elif doll.currentLOD in [PD.LOD_SKIN, PD.LOD_RAYTRACE]:
PD.PortraitTools.BindSkinShader(
effect,
wrinkleFx,
scattering=False,
buildDataManager=doll.buildDataManager,
gender=doll.gender,
use_png=PD.USE_PNG,
fxSuffix=suffix)
PD.PortraitTools.BindLinearAvatarBRDF(effect, suffix)
elif doll.currentLOD == PD.LOD_SCATTER_SKIN:
PD.PortraitTools.BindSkinShader(
effect,
wrinkleFx,
scattering=True,
buildDataManager=doll.buildDataManager,
gender=doll.gender,
use_png=PD.USE_PNG,
fxSuffix=suffix)
PD.PortraitTools.BindLinearAvatarBRDF(effect, suffix)
elif doll.currentLOD <= 0:
PD.PortraitTools.BindHeroHairShader(effect, suffix)
def __init__(self, text, parent, size=72, shadow=0, hspace=8):
self.transform = trinity.EveTransform()
self.transform.mesh = trinity.Tr2Mesh()
self.transform.mesh.geometryResPath = 'res:/Model/Global/zsprite.gr2'
self.transform.modifier = 1
self.measurer = trinity.Tr2FontMeasurer()
self.measurer.limit = 0
fontFamily = uicore.font.GetFontFamilyBasedOnClientLanguageID()[
fontConst.STYLE_DEFAULT]
self.measurer.font = fontFamily[2]
self.measurer.fontSize = size
self.measurer.letterSpace = hspace
self.measurer.AddText(text.upper())
height = self.measurer.ascender - self.measurer.descender
width = self.measurer.cursorX
self.measurer.CommitText(0, self.measurer.ascender)
self.transform.scaling = (width, height, 0)
area = trinity.Tr2MeshArea()
self.transform.mesh.transparentAreas.append(area)
area.effect = self.effect = trinity.Tr2Effect()
sampler = list(self.effect.samplerOverrides.GetDefaultValue())
sampler[0] = 'DiffuseMapSampler'
sampler[1] = trinity.TRITADDRESS_CLAMP
sampler[2] = trinity.TRITADDRESS_CLAMP
self.effect.samplerOverrides.append(tuple(sampler))
self.effect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/SpecialFX/TextureColor.fx'
diffuseColor = trinity.Tr2Vector4Parameter()
diffuseColor.name = 'DiffuseColor'
self.effect.parameters.append(diffuseColor)
self.diffuseColor = diffuseColor
self.diffuseMap = trinity.TriTexture2DParameter()
self.diffuseMap.name = 'DiffuseMap'
self.effect.resources.append(self.diffuseMap)
parent.children.append(self.transform)
trinity.device.RegisterResource(self)
self.OnCreate(trinity.device)
def LoadOrbitalObjects(self, scene):
orbitalObjects = sm.GetService('planetInfo').GetOrbitalsForPlanet(
self.planetID, const.groupPlanetaryCustomsOffices)
groupClasses = spaceObject.GetGroupDict()
categoryClasses = spaceObject.GetCategoryDict()
park = sm.GetService('michelle').GetBallpark()
addedObjects = []
for orbitalObjectID in orbitalObjects:
ball = park.GetBall(orbitalObjectID)
invItem = park.GetInvItem(orbitalObjectID)
fileName = None
if cfg.invtypes.Get(invItem.typeID).graphicID is not None:
if type(cfg.invtypes.Get(invItem.typeID).graphicID) != type(0):
raise RuntimeError('NeedGraphicIDNotMoniker',
invItem.itemID)
if cfg.invtypes.Get(invItem.typeID).Graphic():
fileName = cfg.invtypes.Get(invItem.typeID).GraphicFile()
if not (fileName.lower().endswith('.red')
or fileName.lower().endswith('.blue')):
filename_and_turret_type = string.split(fileName, ' ')
fileName = filename_and_turret_type[0]
if fileName is None:
self.LogError(
'Error: Object type %s has invalid graphicFile, using graphicID: %s'
% (invItem.typeID, cfg.invtypes.Get(
invItem.typeID).graphicID))
continue
tryFileName = fileName.replace(':/Model', ':/dx9/Model').replace(
'.blue', '.red')
tryFileName = tryFileName.replace('.red', '_UI.red')
model = None
if tryFileName is not None:
try:
model = blue.resMan.LoadObject(tryFileName)
except:
model = None
sys.exc_clear()
if model is None:
self.LogError('Was looking for:', tryFileName,
'but it does not exist!')
if model is None:
try:
model = blue.resMan.LoadObject(fileName)
except:
model = None
sys.exc_clear()
if not model:
log.LogError(
'Could not load model for orbital object. FileName:',
fileName, ' id:', invItem.itemID, ' typeID:',
getattr(invItem, 'typeID', '?unknown?'))
if invItem is not None and hasattr(invItem, 'typeID'):
log.LogError('Type is:',
cfg.invtypes.Get(invItem.typeID).typeName)
continue
model.name = '%s' % invItem.itemID
model.display = 0
model.scaling = (0.002, 0.002, 0.002)
addedObjects.append(model)
orbitRoot = trinity.EveTransform()
orbitRoot.children.append(model)
inclinationRoot = trinity.EveTransform()
inclinationRoot.children.append(orbitRoot)
orbitalInclination = orbitalObjectID / math.pi % (
math.pi / 4.0) - math.pi / 8.0
if orbitalInclination <= 0.0:
orbitalInclination -= math.pi / 8.0
else:
orbitalInclination += math.pi / 8.0
inclinationRoot.rotation = geo2.QuaternionRotationSetYawPitchRoll(
0.0, orbitalInclination, 0.0)
rotationCurveSet = trinity.TriCurveSet()
rotationCurveSet.playOnLoad = False
rotationCurveSet.Stop()
rotationCurveSet.scaledTime = 0.0
rotationCurveSet.scale = 0.25
orbitRoot.curveSets.append(rotationCurveSet)
ypr = trinity.TriYPRSequencer()
ypr.YawCurve = trinity.TriScalarCurve()
ypr.YawCurve.extrapolation = trinity.TRIEXT_CYCLE
ypr.YawCurve.AddKey(0.0, 0.0, 0.0, 0.0, trinity.TRIINT_LINEAR)
ypr.YawCurve.AddKey(200.0, 360.0, 0.0, 0.0, trinity.TRIINT_LINEAR)
ypr.YawCurve.Sort()
rotationCurveSet.curves.append(ypr)
binding = trinity.TriValueBinding()
binding.sourceObject = ypr
binding.sourceAttribute = 'value'
binding.destinationObject = orbitRoot
binding.destinationAttribute = 'rotation'
rotationCurveSet.bindings.append(binding)
rotationCurveSet.Play()
model.translation = (0.0, 0.0, 1500.0)
model.rotation = geo2.QuaternionRotationSetYawPitchRoll(
math.pi, 0.0, 0.0)
scene.objects.append(inclinationRoot)
ls = trinity.EveCurveLineSet()
ls.scaling = (1.0, 1.0, 1.0)
tex2D1 = trinity.TriTexture2DParameter()
tex2D1.name = 'TexMap'
tex2D1.resourcePath = 'res:/UI/Texture/Planet/link.dds'
ls.lineEffect.resources.append(tex2D1)
tex2D2 = trinity.TriTexture2DParameter()
tex2D2.name = 'OverlayTexMap'
tex2D2.resourcePath = 'res:/UI/Texture/Planet/link.dds'
ls.lineEffect.resources.append(tex2D2)
lineColor = (1.0, 1.0, 1.0, 0.05)
p1 = planet.SurfacePoint(0.0, 0.0, -1500.0, 1000.0)
p2 = planet.SurfacePoint(5.0, 0.0, 1498.0, 1000.0)
l1 = ls.AddSpheredLineCrt(p1.GetAsXYZTuple(), lineColor,
p2.GetAsXYZTuple(), lineColor,
(0.0, 0.0, 0.0), 3.0)
p1 = planet.SurfacePoint(0.0, 0.0, -1500.0, 1000.0)
p2 = planet.SurfacePoint(-5.0, 0.0, 1498.0, 1000.0)
l2 = ls.AddSpheredLineCrt(p1.GetAsXYZTuple(), lineColor,
p2.GetAsXYZTuple(), lineColor,
(0.0, 0.0, 0.0), 3.0)
animationColor = (0.3, 0.3, 0.3, 0.5)
ls.ChangeLineAnimation(l1, animationColor, 0.25, 1.0)
ls.ChangeLineAnimation(l2, animationColor, -0.25, 1.0)
ls.ChangeLineSegmentation(l1, 100)
ls.ChangeLineSegmentation(l2, 100)
ls.SubmitChanges()
orbitRoot.children.append(ls)
trinity.WaitForResourceLoads()
for model in addedObjects:
model.display = 1
