def RenderSpaceObject(outPath,
scenePath='',
objectPath='',
sofDNA=None,
size=128,
bgColor=None,
transparent=False,
backgroundPath=None,
overlayPath=None,
techPath=None,
cameraAngle=None,
freezeTime=True,
postProcessingQuality=2,
supersampleQuality=2,
modifyScene=None,
sunDirection=None,
animationStates=[]):
if freezeTime:
FreezeTime()
trinity.GetVariableStore().RegisterVariable('DepthMap',
trinity.TriTextureRes())
trinity.GetVariableStore().RegisterVariable('DepthMapMsaa',
trinity.TriTextureRes())
if scenePath:
scene = blue.resMan.LoadObject(scenePath)
else:
scene = trinity.EveSpaceScene()
model = LoadSpaceObject(objectPath, sofDNA, scene, animationStates)
view, projection = GetViewProjectionForModel(model, scene, cameraAngle)
if modifyScene:
view, projection = modifyScene(scene, view, projection)
sunDirection = sunDirection or (-view.transform[0][2],
-view.transform[1][2],
-view.transform[2][2])
SetupScene(scene,
transparentBackground=transparent,
sunDirection=sunDirection,
pbr=bool(sofDNA))
hostBitmap = RenderToSurface(scene=scene,
view=view,
projection=projection,
size=size,
bgColor=bgColor,
transparent=transparent,
backgroundPath=backgroundPath,
overlayPath=overlayPath,
techPath=techPath,
postProcessingQuality=postProcessingQuality,
supersampleQuality=supersampleQuality)
hostBitmap.Save(outPath)
def CreateTargetsOnModifier(self, modifier, asRenderTargets = False):
textureFormat = trinity.PIXEL_FORMAT.B8G8R8A8_UNORM
def validateTarget(target, width, height):
if not (target and target.isGood and target.depth > 0):
return False
if target.width != width or target.height != height:
return False
return True
if modifier.decalData.bodyEnabled:
modifier.mapD[pdDef.DOLL_PARTS.BODY] = trinity.TriTextureRes(trinity.Tr2RenderTarget(self.size[0] / 2, self.size[1], 1, textureFormat))
if modifier.decalData.headEnabled:
modifier.mapD[pdDef.DOLL_PARTS.HEAD] = trinity.TriTextureRes(trinity.Tr2RenderTarget(self.size[0] / 2, self.size[1] / 2, 1, textureFormat))
def ApplyAttributes(self, attributes):
Sprite.ApplyAttributes(self, attributes)
sm.RegisterNotify(self)
self.textureRes = trinity.TriTextureRes()
self.texture = trinity.Tr2Sprite2dTexture()
self.player = None
self.path = None
self.audioTrack = 0
self.videoLoop = False
self.emitter = None
self._updateStep = None
self._isFetchingFile = False
RO = self.GetRenderObject()
self.disableAudio = attributes.get('disableAudio',
self.default_disableAudio)
self._positionComponent = attributes.get('positionComponent', None)
self.positionComponent = None
if 'videoPath' in attributes and attributes[
'videoPath'] and attributes.get('videoAutoPlay',
self.default_videoAutoPlay):
self.SetVideoPath(
attributes['videoPath'], attributes.get('audioTrack', 0),
attributes.get('videoLoop', self.default_videoLoop))
if 'pos' in attributes:
pos = attributes.get('pos',
(self.default_left, self.default_top,
self.default_width, self.default_height))
RO.displayX, RO.displayY, RO.displayWidth, RO.displayHeight = pos
def GetResourceAndRender(self, resourceTypeID):
"""
Get the spherical harmonic from planetSvc going to server if nessesasary.
We render the SH in slices yielding in between so we won't stall the client.
We check if we are still rendering the correct resournce whenever we have yielded the thread.
"""
self.LogInfo('GetResourceAndRender resourceTypeID', resourceTypeID)
planet = sm.GetService('planetSvc').GetPlanet(self.planetID)
inRange, sh = planet.GetResourceData(resourceTypeID)
self.currSphericalHarmonic = sh
sh = builder.CopySH(sh)
builder.ScaleSH(sh, 1.0 / const.planetResourceMaxValue)
chart = self.ChartResourceLayer(sh)
buf = chart.makeChart2(chart.PNG)
if resourceTypeID != self.selectedResourceTypeID:
raise ResourceRenderAbortedError
bmp = trinity.Tr2HostBitmap(PLANET_RESOURCE_TEX_WIDTH,
PLANET_RESOURCE_TEX_HEIGHT, 1,
trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
bmp.LoadFromPngInMemory(buf)
texture = trinity.TriTextureRes()
if resourceTypeID != self.selectedResourceTypeID:
raise ResourceRenderAbortedError
texture.CreateFromHostBitmap(bmp)
if resourceTypeID != self.selectedResourceTypeID:
raise ResourceRenderAbortedError
return (inRange, texture)
def DoPreProcessEffectForPhotoSvc(self, size):
renderTarget = trinity.Tr2RenderTarget(2 * size, size, 0, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
vp = trinity.TriViewport()
vp.width = 2 * size
vp.height = size
if not self.LoadRedFiles():
return
trinity.WaitForResourceLoads()
heightMapParam1 = self.__GetBakeShaderParameter('NormalHeight1', 'trinity.TriTextureParameter')
if heightMapParam1 is not None:
heightMapParam1.resourcePath = self.heightMapResPath1
heightMapParam2 = self.__GetBakeShaderParameter('NormalHeight2', 'trinity.TriTextureParameter')
if heightMapParam2 is not None:
heightMapParam2.resourcePath = self.heightMapResPath2
renderTargetSizeParam = self.__GetBakeShaderParameter('TargetTextureHeight', 'trinity.TriTextureParameter')
if renderTargetSizeParam is not None:
renderTargetSizeParam.value = size
trinity.WaitForResourceLoads()
rj = trinity.CreateRenderJob('Height normal Compositing')
rj.PushRenderTarget(renderTarget)
rj.SetViewport(vp)
rj.PushDepthStencil(None)
rj.Clear((0.0, 0.0, 0.0, 0.0))
rj.RenderEffect(self.effectHeight)
rj.PopDepthStencil()
rj.PopRenderTarget()
rj.GenerateMipMaps(renderTarget)
rj.ScheduleOnce()
rj.WaitForFinish()
tex = trinity.TriTextureRes()
tex.CreateAndCopyFromRenderTarget(renderTarget)
heightMapParamList = self.__GetPlanetShaderParameters('HeightMap', 'trinity.TriTextureParameter')
for heightMapParam in heightMapParamList:
heightMapParam.SetResource(tex)
def PrepareBlurredBackBuffer(self):
if self.blurredBackBufferRenderJob:
renderJob = self.blurredBackBufferRenderJob
renderJob.enabled = True
for step in renderJob.steps[:]:
renderJob.steps.remove(step)
else:
renderJob = trinity.CreateRenderJob()
renderJob.name = 'Blurred Back Buffer'
renderJob.ScheduleRecurring(insertFront=True)
self.blurredBackBufferRenderJob = renderJob
if not settings.char.windows.Get('enableWindowBlur', True):
if self.blurredBackBufferRenderJob:
self.blurredBackBufferRenderJob.enabled = False
return
backbuffer = trinity.device.GetRenderContext().GetDefaultBackBuffer()
self.spaceSceneBackBufferCopy = trinity.Tr2RenderTarget()
self.spaceSceneBackBufferCopy.Create(trinity.app.width,
trinity.app.height, 1,
backbuffer.format)
self.spaceSceneBackBufferDownSizedCopy = trinity.Tr2RenderTarget()
self.spaceSceneBackBufferDownSizedCopy.name = 'spaceSceneBackBufferDownSizedCopy'
self.spaceSceneBackBufferDownSizedCopy.Create(trinity.app.width / 4,
trinity.app.height / 4,
1, backbuffer.format)
step = trinity.TriStepResolve(self.spaceSceneBackBufferCopy,
backbuffer)
step.name = 'Resolve back buffer'
renderJob.steps.append(step)
if self.desktopBlurredBg:
self.RemoveRootObject(self.desktopBlurredBg)
self.desktopBlurredBg.Close()
self.desktopBlurredBg = self.CreateRootObject(
name='desktopBlurred',
renderTarget=self.spaceSceneBackBufferCopy,
renderJob=renderJob,
isFullscreen=True)
self.desktopBlurredBg.renderObject.clearBackground = False
renderJob.PushDepthStencil().pushCurrent = False
renderJob.SetVariableStore(
'BlitCurrent',
self.spaceSceneBackBufferCopy).name = 'Set BlitCurrent variable'
value = (1.0 / trinity.app.width, 1.0 / trinity.app.height,
trinity.app.width, trinity.app.height)
renderJob.SetVariableStore('g_texelSize',
value).name = 'Set g_texelSize variable'
renderJob.PushRenderTarget(self.spaceSceneBackBufferDownSizedCopy)
renderJob.Clear((0, 0, 0, 0))
effect = trinity.Tr2Effect()
effect.effectFilePath = 'res:/Graphics/Effect/Managed/Space/PostProcess/ColorDownFilter4.fx'
renderJob.RenderEffect(effect)
renderJob.PopRenderTarget()
renderJob.PopDepthStencil()
textureRes = trinity.TriTextureRes()
textureRes.SetFromRenderTarget(self.spaceSceneBackBufferDownSizedCopy)
atlasTexture = trinity.Tr2AtlasTexture()
atlasTexture.textureRes = textureRes
self.blurredBackBufferAtlas = atlasTexture
sm.ScatterEvent('OnBlurredBufferCreated')
def CreateSceneWithUI():
del trinity.renderJobs.recurring[:]
scene2d = trinity.Tr2Sprite2dScene()
scene2d.width = 512
scene2d.height = 512
scene2d.clearBackground = True
scene2d.isFullScreen = False
tex = trinity.Tr2RenderTarget(512, 512, 1,
trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
scene, screen = CreateScene3d(trinity.TriTextureRes(tex))
scene2d.translation = screen.translation
scene2d.rotation = screen.rotation
scene2d.scaling = screen.scaling
SetupAnimation(scene2d)
rj = trinity.CreateRenderJob()
rj.name = 'Scene with UI'
rj.Update(scene).name = 'Update 3D scene'
rj.Update(scene2d).name = 'Update 2D scene'
rj.SetPushRenderTarget(tex).name = 'Set texture as render target'
rj.RenderScene(scene2d).name = 'Render 2D scene'
rj.SetPopRenderTarget().name = 'Set framebuffer as render target'
rj.RenderScene(scene).name = 'Render 3D scene'
rj.ScheduleRecurring()
picker = Scene2dPicker(scene2d)
trinity.device.tickInterval = 0
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 __init__(self, name, rt):
super(BuiltinRenderTargetParameter,
self).__init__(name, {'type': 'rendertarget'})
self.rt = rt
self.texture = trinity.TriTextureRes()
self.texture.name = self.name
self.texture.SetFromRenderTarget(self.rt)
def SetRenderTargets(self, customBackBuffer, customDepthStencil, depthTexture, blitTexture, distortionTexture):
self.RemoveStep('SET_DEPTH')
if self.GetSwapChain() is not None:
self.AddStep('SET_SWAPCHAIN_RT', trinity.TriStepSetRenderTarget(self.GetSwapChain().backBuffer))
self.AddStep('SET_SWAPCHAIN_DEPTH', trinity.TriStepSetDepthStencil(self.GetSwapChain().depthStencilBuffer))
else:
self.RemoveStep('SET_SWAPCHAIN_RT')
self.RemoveStep('SET_SWAPCHAIN_DEPTH')
activePostProcessing = self.usePostProcessing and self.postProcessingJob.liveCount > 0
if customBackBuffer is not None:
self.AddStep('SET_CUSTOM_RT', trinity.TriStepPushRenderTarget(customBackBuffer))
self.AddStep('SET_FINAL_RT', trinity.TriStepPopRenderTarget())
if self.msaaEnabled and not activePostProcessing:
if self.hdrEnabled:
self.AddStep('FINAL_BLIT', self._DoFormatConversionStep(blitTexture, customBackBuffer))
else:
self.AddStep('FINAL_BLIT', trinity.TriStepResolve(self.GetBackBufferRenderTarget(), customBackBuffer))
elif self.hdrEnabled and not activePostProcessing and not self.msaaEnabled:
self.AddStep('FINAL_BLIT', self._DoFormatConversionStep(customBackBuffer))
else:
self.RemoveStep('FINAL_BLIT')
if self.fxaaEnabled:
self.AddStep('SET_VAR_GATHER', trinity.TriStepSetVariableStore('GatherMap', customBackBuffer))
self.RemoveStep('FINAL_BLIT')
else:
self.RemoveStep('SET_VAR_GATHER')
else:
self.RemoveStep('SET_CUSTOM_RT')
self.RemoveStep('FINAL_BLIT')
self.RemoveStep('SET_FINAL_RT')
self.RemoveStep('SET_VAR_GATHER')
if customDepthStencil is not None:
self.AddStep('SET_DEPTH', trinity.TriStepPushDepthStencil(customDepthStencil))
self.AddStep('RESTORE_DEPTH', trinity.TriStepPopDepthStencil())
else:
self.RemoveStep('RESTORE_DEPTH')
if self.depthTexture is not None:
if not self.doDepthPass:
self.AddStep('SET_DEPTH', trinity.TriStepPushDepthStencil(depthTexture))
self.AddStep('RESTORE_DEPTH', trinity.TriStepPopDepthStencil())
self._SetDepthMap()
self.AddStep('SET_VAR_DEPTH', trinity.TriStepSetVariableStore('DepthMap', depthTexture))
else:
if not self.msaaEnabled:
self.RemoveStep('SET_DEPTH')
self.RemoveStep('RESTORE_DEPTH')
self.RemoveStep('SET_VAR_DEPTH')
self._RefreshPostProcessingJob(self.postProcessingJob, self.usePostProcessing and self.prepared)
self._RefreshPostProcessingJob(self.distortionJob, self.distortionEffectsEnabled and self.prepared)
self._RefreshPostProcessingJob(self.backgroundDistortionJob, self.distortionEffectsEnabled and self.prepared)
if distortionTexture is not None:
self.AddStep('DO_DISTORTIONS', trinity.TriStepRunJob(self.distortionJob))
distortionTriTextureRes = trinity.TriTextureRes()
distortionTriTextureRes.SetFromRenderTarget(distortionTexture)
self.distortionJob.SetPostProcessVariable('Distortion', 'TexDistortion', distortionTriTextureRes)
self.backgroundDistortionJob.SetPostProcessVariable('Distortion', 'TexDistortion', distortionTriTextureRes)
else:
self.RemoveStep('DO_DISTORTIONS')
self._CreateDepthPass()
def RebuildResource(self):
height = self.measurer.ascender - self.measurer.descender
width = self.measurer.cursorX
tr = trinity.TriTextureRes(width, height, 1,
trinity.PIXEL_FORMAT.B8G8R8A8_UNORM,
trinity.BUFFER_USAGE_FLAGS.CPU_WRITE)
self.measurer.DrawToTexture(tr)
self.diffuseMap.SetResource(tr)
def OnCreate(self, device):
texture = trinity.TriTextureRes(self.textureWidth, self.textureHeight,
1, trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
self.textureAwaitingSwap = texture
self.surface = texture
if self.browserSession is not None:
self.browserSession.SetBrowserSurface(self.surface,
self._OnSurfaceReady)
def SetupCqStationLogo(paramString):
"""
Resource constructor for the station name decal object.
"""
if uicore.isRunning:
return trinity.TriTextureRes()
else:
return blue.resMan.GetResource('res:/UI/Texture/Corps/1_128_1.png')
def __init__(self, name, data):
super(RenderTargetParameter, self).__init__(name, data)
if self._type != 'rendertarget':
raise RuntimeError()
self._data = data
self.rt = None
self.texture = trinity.TriTextureRes()
self.texture.name = self.name
def DoPreProcessEffect(self, size, format, renderTarget):
if renderTarget is None:
self.model.resourceActionPending = False
self.model.ready = True
return
vp = trinity.TriViewport()
vp.width = 2 * size
vp.height = size
trinity.WaitForResourceLoads()
if self.model is None:
return
if len(self.modelRes) == 0:
if not self.LoadRedFiles():
self.model.resourceActionPending = False
self.model.ready = True
return
else:
self.__ReloadLargeResources()
heightMapParam1 = self.__GetBakeShaderParameter('NormalHeight1', 'trinity.TriTextureParameter')
if heightMapParam1 is not None:
heightMapParam1.resourcePath = self.heightMapResPath1
heightMapParam2 = self.__GetBakeShaderParameter('NormalHeight2', 'trinity.TriTextureParameter')
if heightMapParam2 is not None:
heightMapParam2.resourcePath = self.heightMapResPath2
renderTargetSizeParam = self.__GetBakeShaderParameter('TargetTextureHeight', 'trinity.TriTextureParameter')
if renderTargetSizeParam is not None:
renderTargetSizeParam.value = size
trinity.WaitForResourceLoads()
if self.model is None:
return
rj = trinity.CreateRenderJob('Height normal Compositing')
rj.PushRenderTarget(renderTarget)
rj.SetViewport(vp)
rj.PushDepthStencil(None)
step = rj.Clear((0.0, 0.0, 0.0, 0.0), 1.0)
step.isDepthCleared = False
rj.RenderEffect(self.effectHeight)
rj.PopDepthStencil()
rj.PopRenderTarget()
rj.GenerateMipMaps(renderTarget)
rj.ScheduleOnce()
rj.WaitForFinish()
if self.model is None:
return
tex = trinity.TriTextureRes()
tex.CreateAndCopyFromRenderTargetWithSize(renderTarget, size * 2, size)
if heightMapParam1 is not None:
heightMapParam1.resourcePath = ''
heightMapParam1.SetResource(None)
if heightMapParam2 is not None:
heightMapParam2.resourcePath = ''
heightMapParam2.SetResource(None)
heightMapParamList = self.__GetPlanetShaderParameters('HeightMap', 'trinity.TriTextureParameter')
for heightMapParam in heightMapParamList:
heightMapParam.SetResource(tex)
self.model.ready = True
self.model.resourceActionPending = False
def _OnCreateTextures(self, player, width, height):
try:
self.textureRes = trinity.TriTextureRes(
width, height, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
player.bgra_texture = self.textureRes
self.texture.atlasTexture = trinity.Tr2AtlasTexture()
self.texture.atlasTexture.textureRes = self.textureRes
except:
logging.exception('Exception in VideoPlayer.on_create_textures')
def OnCreate(self, device):
"""
This is called by Trinity whenever we need to recreate the texture.
e.g. When the graphics device has been lost and restored.
"""
texture = trinity.TriTextureRes(self.textureWidth, self.textureHeight, 1, trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
self.textureAwaitingSwap = texture
self.surface = texture
if self.browserSession is not None:
self.browserSession.SetBrowserSurface(self.surface, self._OnSurfaceReady)
def SetupCqPIScreen(paramString):
"""
Dynamic resource constructor for Captain's Quarters planetary interaction screen in scene.
Right Screen
"""
if uicore.isRunning:
return trinity.TriTextureRes()
else:
return blue.resMan.GetResource(
'res:/Graphics/Shared_Texture/Global/Screen_Right_Fallback.dds')
def _DestroyVideo(self):
if self.positionComponent:
self.positionComponent.UnRegisterPlacementObserverWrapper(
self.positionObserver)
self.positionComponent = None
self.positionObserver = None
self.emitter = None
self.player = None
self._updateStep = None
self.textureRes = trinity.TriTextureRes()
def SetupCqAgentFinderScreen(paramString):
"""
Dynamic resource constructor for Captain's Quarters agent finder screen in scene.
Left Screen
"""
if uicore.isRunning:
return trinity.TriTextureRes()
else:
return blue.resMan.GetResource(
'res:/Graphics/Shared_Texture/Global/Screen_Left_Fallback.dds')
def CreateTargetsOnModifier(self, modifier, asRenderTargets = False):
"""
Checks for existance of valid targets on the modifier according to size and rendertarget usage.
If that check fails the method will create targets so the modifier contains valid maps for
rendering out the decal.
"""
textureFormat = trinity.PIXEL_FORMAT.B8G8R8A8_UNORM
def validateTarget(target, width, height):
if not (target and target.isGood and target.depth > 0):
return False
if target.width != width or target.height != height:
return False
return True
if modifier.decalData.bodyEnabled:
modifier.mapD[pdDef.DOLL_PARTS.BODY] = trinity.TriTextureRes(trinity.Tr2RenderTarget(self.size[0] / 2, self.size[1], 1, textureFormat))
if modifier.decalData.headEnabled:
modifier.mapD[pdDef.DOLL_PARTS.HEAD] = trinity.TriTextureRes(trinity.Tr2RenderTarget(self.size[0] / 2, self.size[1] / 2, 1, textureFormat))
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 OnCreate(self, dev):
if self.diffuseMap is None:
return
if self.diffuseMap.resource is not None and self.diffuseMap.resource.isGood:
return
height = self.measurer.ascender - self.measurer.descender
width = self.measurer.cursorX
tr = trinity.TriTextureRes(width, height, 1,
trinity.PIXEL_FORMAT.B8G8R8A8_UNORM,
trinity.BUFFER_USAGE_FLAGS.CPU_WRITE)
self.measurer.DrawToTexture(tr)
self.diffuseMap.SetResource(tr)
def ShowSH(self, sh, scaleIt=True):
if scaleIt:
builder.ScaleSH(sh, 1.0 / const.planetResourceMaxValue)
chart = self.ChartResourceLayer(sh)
buf = chart.makeChart2(chart.PNG)
bmp = trinity.Tr2HostBitmap(PLANET_RESOURCE_TEX_WIDTH,
PLANET_RESOURCE_TEX_HEIGHT, 1,
trinity.TRIFMT_X8R8G8B8)
bmp.LoadFromPngInMemory(buf)
texture = trinity.TriTextureRes()
texture.CreateFromHostBitmap(bmp)
if self.planetTransform is not None:
self.EnableResourceLayer()
self.SetResourceTexture(texture)
def createEffectParamsForLight(self, effect, index, light, shadowMapRenderTarget, debugNoFiltering):
map = pdCcf.SetOrAddMap(effect, 'spotLightMap' + str(index))
map.SetResource(trinity.TriTextureRes(shadowMapRenderTarget))
if SkinSpotLightShadows.REUSE_ENGINE_MAPS:
self.maps[light].append(map)
map = pdCcf.SetOrAddMap(effect, 'Noisemap')
map.resourcePath = 'res:/texture/global/noise.png'
viewProj = pdCcf.FindOrAddMat4(effect, 'spotLightViewProj' + str(index))
self.viewProjParams[light].append(viewProj)
lightData = pdCcf.FindOrAddVec4(effect, 'spotLightData' + str(index))
lightData.value = (1.0,
1.0 / self.shadowResolution,
float(debugNoFiltering),
0)
self.dataParams[light].append(lightData)
effect.RebuildCachedData()
def Create3DRenderTarget(self, destscene):
sprite = blue.resMan.LoadObject('res:/uicore/uiInSpace.red')
area = sprite.mesh.opaqueAreas[0]
texture = area.effect.resources[0]
destscene.objects.append(sprite)
rj = trinity.CreateRenderJob()
rj.Update(destscene)
myScene = self.GetRenderObject()
renderTarget = trinity.Tr2RenderTarget(self.width, self.height, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
rj.PushRenderTarget(renderTarget)
rj.RenderScene(myScene).name = 'Render 2D scene'
rj.PopRenderTarget()
rj.ScheduleRecurring(insertFront=True)
texture.SetResource(trinity.TriTextureRes(renderTarget))
myScene.is2dRender = True
self.sceneObject = blue.BluePythonWeakRef(sprite)
self.renderSteps[-1].enabled = False
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 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 CreateRandomTexture(options):
randomBitmap = trinity.Tr2HostBitmap(
options.randomTextureWidth, options.randomTextureWidth, 1,
trinity.PIXEL_FORMAT.R32G32B32A32_FLOAT)
data = randomBitmap.GetRawData()
values = []
dataFormat = ''
for i in range(options.randomTextureWidth * options.randomTextureWidth):
angle = 2.0 * math.pi * random.random() / options.numDirections
values.append(math.sin(angle))
values.append(math.cos(angle))
values.append(random.random())
values.append(random.random())
dataFormat += 'ffff'
struct.pack_into(dataFormat, data[0], 0, *values)
randomTexture = trinity.TriTextureRes()
randomTexture.CreateFromHostBitmap(randomBitmap)
return randomTexture
def Startup(self, *args):
self.texture = trinity.TriTextureRes(
4, 4, 1, trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
self.isTabStop = True
self.cursor = 0
self.browserSessionSurfaceManager = None
self._browserSession = None
self.surface = None
self.textureAwaitingSwap = None
self.textureWidth = 0
self.textureHeight = 0
self.renderJob = trinity.CreateRenderJob('Browser')
self.renderObject.renderJob = self.renderJob
self.renderJob.PythonCB(self.AdjustViewport)
self.renderJob.SetViewport(self.viewport)
self.renderJob.SetStdRndStates(trinity.RM_SPRITE2D)
self.renderTextureStep = self.renderJob.RenderTexture(self.texture)
trinity.device.RegisterResource(self)
self.StartBrowserView()
