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 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 _CreateRenderTargets(self):
if not self.prepared:
return
SceneRenderJobSpace._CreateRenderTargets(self)
vp = self.GetViewport()
self.rtWidth = vp.width
self.rtHeight = vp.height
if self.customBackBuffer is None:
self.offscreenRenderTarget = trinity.Tr2RenderTarget(vp.width, vp.height, 1, self.bbFormat)
self.finalTexture = self.offscreenRenderTarget
else:
self.finalTexture = trinity.Tr2RenderTarget(vp.width, vp.height, 1, self.customBackBuffer.format)
if self.customDepthStencil is None:
self.offscreenDepthStencil = trinity.Tr2DepthStencil(vp.width, vp.height, trinity.DEPTH_STENCIL_FORMAT.AUTO)
self.finalTexture.name = 'finalTexture'
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 csaaScreenshot(useNVidiaAA, width, height, scene):
try:
csaaFmt = trinity.TRIMULTISAMPLE_8_SAMPLES if useNVidiaAA else trinity.TRIMULTISAMPLE_NONE
csaaQty = 2 if useNVidiaAA else 0
buffer = trinity.Tr2RenderTarget(width, height, 1,
trinity.PIXEL_FORMAT.B8G8R8X8_UNORM,
csaaFmt, csaaQty)
depth = trinity.Tr2DepthStencil(width, height,
trinity.DEPTH_STENCIL_FORMAT.D24S8,
csaaFmt, csaaQty)
job = trinity.CreateRenderJob('CSAA screenshot')
job.SetRenderTarget(buffer)
job.SetDepthStencil(depth)
vp = trinity.TriViewport()
vp.x = 0
vp.y = 0
vp.width = width
vp.height = height
job.SetViewport(vp)
job.Clear((0, 0, 0, 0), 1.0)
job.RenderScene(scene)
trinity.SetPerspectiveProjection(trinity.GetFieldOfView(),
trinity.GetFrontClip(),
trinity.GetBackClip(), 1.0)
job.ScheduleOnce()
return (job, buffer)
except Exception:
return None
def csaaScreenshot(useNVidiaAA, width, height, scene):
"""
Create a renderjob that will render the scene into a buffer using CSAA, if available.
Returns ( job, buffer ) (which can be None if you ask for CSAA and it doesn't work).
Use Tr2HostBitmap(buffer).Save or whatever to get to the data, after doing WaitForFinish if needed
"""
try:
csaaFmt = trinity.TRIMULTISAMPLE_8_SAMPLES if useNVidiaAA else trinity.TRIMULTISAMPLE_NONE
csaaQty = 2 if useNVidiaAA else 0
buffer = trinity.Tr2RenderTarget(width, height, 1,
trinity.PIXEL_FORMAT.B8G8R8X8_UNORM,
csaaFmt, csaaQty)
depth = trinity.Tr2DepthStencil(width, height,
trinity.DEPTH_STENCIL_FORMAT.D24S8,
csaaFmt, csaaQty)
job = trinity.CreateRenderJob('CSAA screenshot')
job.SetRenderTarget(buffer)
job.SetDepthStencil(depth)
vp = trinity.TriViewport()
vp.x = 0
vp.y = 0
vp.width = width
vp.height = height
job.SetViewport(vp)
job.Clear((0, 0, 0, 0), 1.0)
job.RenderScene(scene)
trinity.SetPerspectiveProjection(trinity.GetFieldOfView(),
trinity.GetFrontClip(),
trinity.GetBackClip(), 1.0)
job.ScheduleOnce()
return (job, buffer)
except Exception:
return None
def TakeSnapShot_Render(self, scene, size, view, projection, transparentBackground = False, bgColor = None):
self.LogInfo('TakeSnapShot_Render')
if transparentBackground:
bbFormat = trinity.PIXEL_FORMAT.B8G8R8A8_UNORM
clearColor = bgColor or (0.0, 0.0, 0.0, 0.0)
else:
bbFormat = trinity.PIXEL_FORMAT.B8G8R8X8_UNORM
clearColor = bgColor or (0.0, 0.0, 0.0, 1.0)
dsFormat = trinity.DEPTH_STENCIL_FORMAT.AUTO
renderTarget = trinity.Tr2RenderTarget(size, size, 1, bbFormat)
depthStencil = trinity.Tr2DepthStencil(size, size, dsFormat)
self.LogInfo('TakeSnapShot_Render_After_Resource_Creation')
renderJob = trinity.CreateRenderJob('TakeSnapShot')
renderJob.PushRenderTarget(renderTarget)
renderJob.SetProjection(projection)
renderJob.SetView(view)
renderJob.PushDepthStencil(depthStencil)
renderJob.Clear(clearColor, 1.0)
renderJob.Update(scene)
renderJob.RenderScene(scene)
renderJob.PopDepthStencil()
renderJob.PopRenderTarget()
trinity.WaitForResourceLoads()
renderJob.ScheduleOnce()
renderJob.WaitForFinish()
hostCopy = trinity.Tr2HostBitmap(renderTarget)
hostCopy.name = 'TakeSnapeShot_Render'
return hostCopy
def SaveScreenShot(self, outputPath, rgb=False):
if rgb:
clearColors = (('R', (1.0, 0.0, 0.0, 0.0)),
('G', (0.0, 1.0, 0.0, 0.0)), ('B', (0.0, 0.0, 1.0,
0.0)))
else:
clearColors = ((None, None), )
print 'SaveScreenShot', outputPath
for channel, color in clearColors:
if color:
self.renderJob.SetClearColor(color)
blue.synchro.Yield()
backBuffer = trinity.device.GetRenderContext(
).GetDefaultBackBuffer()
if not backBuffer.isReadable:
tempRT = trinity.Tr2RenderTarget(backBuffer.width,
backBuffer.height, 1,
backBuffer.format)
backBuffer.Resolve(tempRT)
bmp = trinity.Tr2HostBitmap(tempRT)
else:
bmp = trinity.Tr2HostBitmap(backBuffer)
if bmp.format == trinity.PIXEL_FORMAT.B8G8R8A8_UNORM:
bmp.ChangeFormat(trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
if rgb:
bmp.Save(outputPath[:-4] + '_' + channel + outputPath[-4:])
else:
bmp.Save(outputPath)
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 GetRenderTarget(self, renderTargetFormat, width, height, locked=False):
i = 0
hashKey = self.__Hash(renderTargetFormat, width, height, i)
while self.lockedTargets.get(hashKey):
i += 1
hashKey = self.__Hash(renderTargetFormat, width, height, i)
rt = self.targets.get(hashKey)
if rt and locked:
self.lockedTargets[hashKey] = rt
reapTasklet = None
while not rt:
try:
rt = trinity.Tr2RenderTarget(width, height, 1,
renderTargetFormat)
self.targets[hashKey] = rt
if locked:
self.lockedTargets[hashKey] = rt
reapTasklet = uthread.new(
self.Reaper_t,
hashKey).context = 'RenderTargetMananger::Reaper'
except (trinity.E_OUTOFMEMORY, trinity.D3DERR_OUTOFVIDEOMEMORY):
raise
except trinity.DeviceLostError:
rt = None
blue.synchro.SleepWallclock(100)
sleepCycles = self.targetsSleepCycles.get(hashKey, 0)
self.targetsSleepCycles[hashKey] = sleepCycles + 1
if reapTasklet:
uthread.schedule(reapTasklet)
return rt
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 UpdateValue(self, parameters):
if 'copyFrom' in self._data:
copyFrom = parameters[self._data['copyFrom']].GetValue()
if copyFrom:
if 'width' in self._data:
if isinstance(self._data['width'], float):
width = int(self._data['width'] * copyFrom.width)
else:
width = self._data['width']
else:
width = copyFrom.width
if 'height' in self._data:
if isinstance(self._data['height'], float):
height = int(self._data['height'] * copyFrom.height)
else:
height = self._data['height']
else:
height = copyFrom.height
self.rt = trinity.Tr2RenderTarget()
self.rt.CreateEx(
width, height, self._data.get('mipCount',
copyFrom.mipCount),
self._data.get('format', copyFrom.format),
self._data.get('multiSampleType',
copyFrom.multiSampleType),
self._data.get('multiSampleQuality',
copyFrom.multiSampleQuality),
trinity.EX_FLAG.BIND_UNORDERED_ACCESS if self._data.get(
'uav', False) else 0)
self.rt.name = self.name
else:
self.rt = None
else:
self.rt = trinity.Tr2RenderTarget()
self.rt.CreateEx(
self._data['width'], self._data['height'],
self._data.get('mipCount', 1), self._data['format'],
self._data.get('multiSampleType', 1),
self._data.get('multiSampleQuality', 1),
trinity.EX_FLAG.BIND_UNORDERED_ACCESS if self._data.get(
'uav', False) else 0)
self.rt.name = self.name
self.texture.SetFromRenderTarget(self.rt)
self._UpdateBindings()
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 CreateUIDesktopRendertarget(self, component):
if component.renderTarget is not None:
rt = trinity.Tr2RenderTarget(component.width, component.height,
0 if component.autoMipMap else 1,
component.format)
component.renderTarget.SetFromRenderTarget(rt)
if hasattr(component.renderTarget, 'name'):
component.renderTarget.name = component.uiDesktopName
if component.uiDesktop is not None:
component.uiDesktop.SetRenderTarget(rt)
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 CreateRenderTarget(self):
textureQuality = gfxsettings.Get(gfxsettings.GFX_TEXTURE_QUALITY)
size = PLANET_TEXTURE_SIZE >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
if not rt.isValid:
if size < 2:
return
size = size / 2
rt = None
return (rt, size)
def CreateRenderTarget(self):
textureQuality = gfxsettings.Get(gfxsettings.GFX_TEXTURE_QUALITY)
self.maxSizeLimit = size = self.maxSize >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, self.format)
if not rt.isValid:
if size < 2:
return
self.maxSizeLimit = size = size / 2
rt = None
return rt
def SaveScreenShot(self, path):
backBuffer = trinity.renderContext.GetDefaultBackBuffer()
tileWidth = backBuffer.width
tileHeight = backBuffer.height
if not backBuffer.isReadable:
tempRT = trinity.Tr2RenderTarget(backBuffer.width,
backBuffer.height, 1,
backBuffer.format)
backBuffer.Resolve(tempRT)
trinity.Tr2HostBitmap(tempRT).Save(path)
else:
trinity.Tr2HostBitmap(backBuffer).Save(path)
print 'SaveScreenShot', path
def CreateRenderTarget(self):
deviceSvc = sm.GetService('device')
textureQuality = settings.public.device.Get(
'textureQuality', deviceSvc.GetDefaultTextureQuality())
self.maxSizeLimit = size = self.maxSize >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, self.format)
if not rt.isValid:
if size < 2:
return
self.maxSizeLimit = size = size / 2
rt = None
return rt
def CreateRenderTarget(self):
textureQuality = gfxsettings.Get(gfxsettings.GFX_TEXTURE_QUALITY)
self.maxSizeLimit = size = PLANET_TEXTURE_SIZE >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, self.format)
if not rt.isValid:
if size < 2:
return
self.maxSizeLimit = size = size / 2
rt = None
self.LogInfo('CreateRenderTarget textureQuality', textureQuality,
'size', size, 'maxSizeLimit', self.maxSizeLimit)
return rt
def CreateRenderTarget(self):
deviceSvc = sm.GetService('device')
textureQuality = settings.public.device.Get(
'textureQuality', deviceSvc.GetDefaultTextureQuality())
self.maxSizeLimit = size = PLANET_TEXTURE_SIZE >> textureQuality
rt = None
while rt is None or not rt.isValid:
rt = trinity.Tr2RenderTarget(2 * size, size, 0, self.format)
if not rt.isValid:
if size < 2:
return
self.maxSizeLimit = size = size / 2
rt = None
self.LogInfo('CreateRenderTarget textureQuality', textureQuality,
'size', size, 'maxSizeLimit', self.maxSizeLimit)
return rt
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 GetPortraitTexture(self, portraitID):
size = 512
sceneManager = sm.GetService('sceneManager')
scene = sceneManager.GetActiveScene()
backdropPath = self.backdropPath
if backdropPath:
backdropScene = trinity.Tr2Sprite2dScene()
backdropScene.displayWidth = size
backdropScene.displayHeight = size
sprite = trinity.Tr2Sprite2d()
sprite.texturePrimary = trinity.Tr2Sprite2dTexture()
sprite.texturePrimary.resPath = backdropPath
sprite.displayWidth = size
sprite.displayHeight = size
backdropScene.children.append(sprite)
target = trinity.Tr2RenderTarget(size, size, 1,
trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
depth = trinity.Tr2DepthStencil(size, size,
trinity.DEPTH_STENCIL_FORMAT.AUTO)
renderJob = trinity.CreateRenderJob('TakeSnapShot')
renderJob.PushRenderTarget(target)
renderJob.PushDepthStencil(depth)
projection = trinity.TriProjection()
projection.PerspectiveFov(self.camera.fieldOfView, 1, 0.1, 5.0)
view = self.camera.viewMatrix
renderJob.Clear((0.0, 0.0, 0.0, 1.0), 1.0)
renderJob.SetProjection(projection)
renderJob.SetView(view)
if backdropPath:
renderJob.Update(backdropScene)
renderJob.RenderScene(backdropScene)
renderJob.RenderScene(scene)
trinity.WaitForResourceLoads()
renderJob.PopDepthStencil()
renderJob.PopRenderTarget()
renderJob.ScheduleOnce()
renderJob.WaitForFinish()
filename = self.GetPortraitSnapshotPath(portraitID)
trinity.Tr2HostBitmap(target).Save(filename)
path = 'cache:/Pictures/Portraits/PortraitSnapshot_%s_%s.jpg' % (
portraitID, session.userid)
blue.motherLode.Delete(path)
tex = blue.resMan.GetResource(path, 'atlas')
return tex
def GetScenePicture(self, res=128, blur=0):
scene = sm.GetService('sceneManager').GetRegisteredScene(
None, defaultOnActiveScene=True)
camera = sm.GetService('sceneManager').GetActiveCamera()
depthTexture = scene.depthTexture
scene.depthTexture = None
renderTarget = trinity.Tr2RenderTarget(
res, res, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
depthStencil = trinity.Tr2DepthStencil(
res, res, trinity.DEPTH_STENCIL_FORMAT.AUTO)
view = trinity.TriView()
view.transform = camera.viewMatrix.transform
projection = camera.projectionMatrix
renderJob = trinity.CreateRenderJob('StaticScene')
renderJob.PushRenderTarget(renderTarget)
renderJob.PushDepthStencil(depthStencil)
renderJob.SetProjection(projection)
renderJob.SetView(view)
renderJob.Clear((0.0, 0.0, 0.0, 0.0), 1.0)
renderJob.RenderScene(scene)
renderJob.PopDepthStencil()
renderJob.PopRenderTarget()
renderJob.ScheduleOnce()
renderJob.WaitForFinish()
scene.depthTexture = depthTexture
hostCopy = trinity.Tr2HostBitmap(renderTarget)
hostCopy.name = 'hostCopy'
if blur:
gaussBlur = trinity.TriConvolutionMatrix5(2.0, 3.0, 5.0, 3.0, 2.0,
3.0, 4.0, 8.0, 5.0, 3.0,
5.0, 7.0, 13.0, 7.0, 5.0,
3.0, 4.0, 8.0, 5.0, 3.0,
2.0, 3.0, 5.0, 3.0, 2.0)
blurCopy = trinity.Tr2HostBitmap(
res, res, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
blurCopy.name = 'blurCopy'
blurCopy.ApplyConvFilter(hostCopy, gaussBlur, 0)
hostCopy = blurCopy
pic = uiprimitives.Sprite(align=uiconst.TOALL)
pic.texture.atlasTexture = uicore.uilib.CreateTexture(res, res)
pic.texture.atlasTexture.CopyFromHostBitmap(hostCopy)
return pic
def PrintScreen(self, *args):
year, month, weekday, day, hour, minute, second, msec = blue.os.GetTimeParts(
blue.os.GetWallclockTime())
date = '%d.%.2d.%.2d.%.2d.%.2d.%.2d' % (year, month, day, hour, minute,
second)
ext = 'png'
path = '%s/%s/capture/Screenshots/%s.%s' % (
blue.sysinfo.GetUserDocumentsDirectory(), boot.appname, date, ext)
rt = trinity.device.GetRenderContext().GetDefaultBackBuffer()
if not rt.isReadable:
readable = trinity.Tr2RenderTarget(rt.width, rt.height, 1,
rt.format)
rt.Resolve(readable)
bmp = trinity.Tr2HostBitmap(readable)
else:
bmp = trinity.Tr2HostBitmap(rt)
if bmp.format == trinity.PIXEL_FORMAT.B8G8R8A8_UNORM:
bmp.ChangeFormat(trinity.PIXEL_FORMAT.B8G8R8X8_UNORM)
bmp.Save(path)
return True
def _CreateRenderTargetAL(width, height, mipLevels, format):
rt = trinity.Tr2RenderTarget()
rt.Create(width, height, mipLevels, format)
return rt
def _CreateRenderTargetMsaaAL(width, height, format, msaaType,
msaaQuality):
rt = trinity.Tr2RenderTarget()
rt.CreateMsaa(width, height, format, msaaType, msaaQuality)
return rt
def CreateSsaoRenderJob(options, width, height, outputRT):
randomTexture = CreateRandomTexture(options)
if not randomTexture.isGood:
return
linearizeDepth = CreateMaterial('linearizeDepth')
shaderSSAO = CreateMaterial('normalFree useNormals')
linearizeDepthAndPackAODepth = CreateMaterial('linearizeDepthAndPack')
blurX = CreateMaterial('blurX')
if not options.disableBlending:
blurY = CreateMaterial('blurY blend')
else:
blurY = CreateMaterial('blurY')
SetMaterialConstants(options, width, height, linearizeDepth,
linearizeDepthAndPackAODepth, blurX, blurY,
shaderSSAO, randomTexture)
curHistoryAOZRT = trinity.Tr2RenderTarget(
width, height, 1, trinity.PIXEL_FORMAT.R16G16_FLOAT)
fullResAOZRT = trinity.Tr2RenderTarget(width, height, 1,
trinity.PIXEL_FORMAT.R16G16_FLOAT)
if options.resolutionMode == SSAO_HALF_RES_AO:
linDepthRT = trinity.Tr2RenderTarget(width / 2, height / 2, 1,
trinity.PIXEL_FORMAT.R32_FLOAT)
halfResAORT = trinity.Tr2RenderTarget(width / 2, height / 2, 1,
trinity.PIXEL_FORMAT.R8_UNORM)
outputAOZ = halfResAORT
else:
linDepthRT = trinity.Tr2RenderTarget(width, height, 1,
trinity.PIXEL_FORMAT.R32_FLOAT)
outputAOZ = curHistoryAOZRT
AddMaterialParam(shaderSSAO, 'DepthMap', linDepthRT)
AddMaterialParam(shaderSSAO, 'RandomMap', randomTexture)
if options.resolutionMode == SSAO_HALF_RES_AO:
AddMaterialParam(linearizeDepthAndPackAODepth, 'SSAOMap', halfResAORT)
AddMaterialParam(blurX, 'SSAOMap', curHistoryAOZRT)
AddMaterialParam(blurY, 'SSAOMap', fullResAOZRT)
linearizeDepth.BindLowLevelShader([])
shaderSSAO.BindLowLevelShader([])
linearizeDepthAndPackAODepth.BindLowLevelShader([])
blurX.BindLowLevelShader([])
blurY.BindLowLevelShader([])
rj = trinity.TriRenderJob()
AddStep(rj, 'SAVE_DS', trinity.TriStepPushDepthStencil(None))
AddStep(rj, 'SAVE_RT', trinity.TriStepPushRenderTarget())
cb = GetSSAOCallbackStep(options, width, height, shaderSSAO,
linearizeDepth, linearizeDepthAndPackAODepth)
AddStep(rj, 'UPDATE_CONSTANTS', trinity.TriStepPythonCB(cb))
AddStep(rj, 'SET_FULLSCREEN_STATES',
trinity.TriStepSetStdRndStates(trinity.RM_FULLSCREEN))
AddStep(rj, 'SET_LINEAR_DEPTH_RT',
trinity.TriStepSetRenderTarget(linDepthRT))
AddStep(rj, 'LINEARIZE_DEPTH',
trinity.TriStepRenderFullScreenShader(linearizeDepth))
AddStep(rj, 'SET_AO_RT', trinity.TriStepSetRenderTarget(outputAOZ))
AddStep(rj, 'RENDER_AO', trinity.TriStepRenderFullScreenShader(shaderSSAO))
if options.resolutionMode == SSAO_HALF_RES_AO:
AddStep(rj, 'SET_TEMP_AO_RT',
trinity.TriStepSetRenderTarget(curHistoryAOZRT))
AddStep(
rj, 'PACK_DEPTH_AND_AO',
trinity.TriStepRenderFullScreenShader(
linearizeDepthAndPackAODepth))
AddStep(rj, 'SET_FULL_AO_RT', trinity.TriStepSetRenderTarget(fullResAOZRT))
AddStep(rj, 'BLUR_X', trinity.TriStepRenderFullScreenShader(blurX))
if outputRT is None:
AddStep(rj, 'RESTORE_RT', trinity.TriStepPopRenderTarget())
else:
AddStep(rj, 'SET_OUTPUT_RT', trinity.TriStepSetRenderTarget(outputRT))
AddStep(rj, 'BLUR_Y', trinity.TriStepRenderFullScreenShader(blurY))
if outputRT:
AddStep(rj, 'RESTORE_RT', trinity.TriStepPopRenderTarget())
AddStep(rj, 'RESTORE_DS', trinity.TriStepPopDepthStencil())
return rj
def TakeScreenshot(filename, tilesAcross, saverClass=HostBitmapSaver):
successful = False
errorHint = ''
performanceOverlayRJ = 0
camera = TrinityPanelWrapper.GetCamera()
dev = trinity.device
fov = camera.fieldOfView
aspect = camera.aspectRatio
zNear = camera.frontClip
zFar = camera.backClip
height = 2.0 * zNear * math.tan(fov / 2.0)
width = height * aspect
disabledJobsStates = {}
sceneRenderJobs = []
for rj in trinity.renderJobs.recurring:
legalRenderJob = False
if issubclass(rj, trinity.sceneRenderJobBase.SceneRenderJobBase):
sceneRenderJobs.append(rj)
else:
disabledJobsStates[rj] = rj.enabled
rj.enabled = False
BackupAllProjectionsAndViewports(sceneRenderJobs)
flarePreviousState = FreezeInteriorFlares()
try:
if filename == None or filename == '':
raise ValueError('No filename given')
if not tilesAcross or tilesAcross == 0:
raise ValueError('tilesAcross must be greater than 0')
tilesAcross = int(tilesAcross)
heightSlice = height / tilesAcross
widthSlice = width / tilesAcross
backBuffer = TrinityPanelWrapper.GetBackBuffer()
tileWidth = backBuffer.width
tileHeight = backBuffer.height
twd4 = math.floor(tileWidth / 4)
thd4 = math.floor(tileHeight / 4)
diffW = tileWidth - twd4 * 4
diffH = tileHeight - thd4 * 4
if not backBuffer.isReadable:
tempRT = trinity.Tr2RenderTarget(tileWidth, tileHeight, 1,
backBuffer.format, 1, 0)
screenShot = saverClass(filename, tileWidth * tilesAcross,
tileHeight * tilesAcross, backBuffer.format)
info = wx.BusyInfo('Hold on, generating snazzy snapshot ...')
tileOffset = trinity.TriPoint()
halfAcross = tilesAcross / 2.0
for y in range(tilesAcross - 1, -1, -1):
top = (halfAcross - y) * heightSlice
bottom = top - heightSlice
tileOffset.y = y * tileHeight
screenShot.StartBatch(tileHeight)
for x in range(tilesAcross):
left = (x - halfAcross) * widthSlice
right = left + widthSlice
tileOffset.x = x * tileWidth
for x_off in [(-widthSlice / 4, -twd4, 0),
(widthSlice / 4, twd4, diffW)]:
for y_off in [(heightSlice / 4, -thd4, 0),
(-heightSlice / 4, thd4, diffH)]:
newProj = trinity.TriProjection()
newProj.PerspectiveOffCenter(left + x_off[0],
right + x_off[0],
bottom + y_off[0],
top + y_off[0], zNear,
zFar)
newViewport = trinity.TriViewport()
newViewport.x = 0
newViewport.y = 0
newViewport.width = tileWidth
newViewport.height = tileHeight
newViewport.minZ = 0.0
newViewport.maxZ = 1.0
OverrideAllProjectionsAndViewports(
sceneRenderJobs, newProj, newViewport)
OverrideInteriorFlareViewports(
flarePreviousState, int(x_off[1] + tileOffset.x),
int(y_off[1] + tileOffset.y),
tileWidth * tilesAcross, tileHeight * tilesAcross)
dev.Render()
dev.Render()
offset = trinity.TriPoint(int(x_off[1] + tileOffset.x),
int(y_off[1] + tileOffset.y))
rect = trinity.TriRect(int(twd4), int(thd4),
int(3 * twd4 + x_off[2]),
int(3 * thd4 + y_off[2]))
if not backBuffer.isReadable:
backBuffer.Resolve(tempRT)
screenShot.CopyFromRenderTargetRegion(
tempRT, rect.left, rect.top, rect.right,
rect.bottom, offset.x, offset.y)
else:
screenShot.CopyFromRenderTargetRegion(
backBuffer, rect.left, rect.top, rect.right,
rect.bottom, offset.x, offset.y)
RestoreAllProjectionsAndViewports()
screenShot.EndBatch()
screenShot.EndSaving()
del info
successful = True
except Exception as e:
import traceback
traceback.print_exc()
errorHint = 'An exception occurred: ' + e.message
RestoreInteriorFlares(flarePreviousState)
for rj, state in disabledJobsStates.iteritems():
rj.enabled = state
return (successful, errorHint)
