def __init__(self):
self.isEnabled = False
self.renderJobContainer = None
self.renderJob = None
self.graphGroups = {}
self.graphs = {}
self.bounds = (0, 0, 400, 400)
renderer = trinity.TriStepRenderLineGraph()
renderer.name = 'time'
renderer.legendScale = 1000.0
renderer.maxLegend = 300.0
grp = {}
grp['viewport'] = trinity.TriViewport()
grp['renderer'] = renderer
grp['graphs'] = []
self.graphGroups['time'] = grp
renderer = trinity.TriStepRenderLineGraph()
renderer.name = 'counterLow'
grp = {}
grp['viewport'] = trinity.TriViewport()
grp['renderer'] = renderer
grp['graphs'] = []
self.graphGroups['counterLow'] = grp
renderer = trinity.TriStepRenderLineGraph()
renderer.name = 'counterHigh'
grp = {}
grp['viewport'] = trinity.TriViewport()
grp['renderer'] = renderer
grp['graphs'] = []
self.graphGroups['counterHigh'] = grp
renderer = trinity.TriStepRenderLineGraph()
renderer.name = 'memory'
renderer.legendScale = 1e-06
grp = {}
grp['viewport'] = trinity.TriViewport()
grp['renderer'] = renderer
grp['graphs'] = []
self.graphGroups['memory'] = grp
self.AdjustViewports(self.bounds)
self.colors = {
'counterHigh': [],
'counterLow': [],
'time': [],
'memory': []
}
availColors = [(0.8, 0.8, 0.8, 1.0), (0.4, 0.8, 0.8, 1.0),
(0.8, 0.4, 0.8, 1.0), (0.4, 0.4, 0.8, 1.0),
(0.8, 0.8, 0.4, 1.0), (0.4, 0.8, 0.4, 1.0),
(0.8, 0.4, 0.4, 1.0), (0.8, 0.0, 0.0, 1.0),
(0.0, 0.8, 0.8, 1.0), (0.8, 0.8, 0.0, 1.0)]
for each in availColors:
self.colors['counterHigh'].append(each)
self.colors['counterLow'].append(each)
self.colors['time'].append(each)
self.colors['memory'].append(each)
def ApplyAttributes(self, attributes):
Base.ApplyAttributes(self, attributes)
self.viewport = trinity.TriViewport()
self.viewport.x = 0
self.viewport.y = 0
self.viewport.width = 1
self.viewport.height = 1
self.viewport.minZ = 0.0
self.viewport.maxZ = 1.0
self.projection = trinity.TriProjection()
self.frontClip = 1.0
self.backClip = 350000.0
self.fieldOfView = 1.0
self.minPitch = -3.0
self.maxPitch = 3.4
self.minZoom = 0.0
self.maxZoom = 1.0
self._zoom = 0.5
self.scene = trinity.EveSpaceScene()
self.transform = trinity.EveRootTransform()
self.scene.objects.append(self.transform)
self.PrepareCamera()
self.DisplayScene()
self.CreateBracketCurveSet()
self.UpdateViewPort()
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 SetViewport(self, rj, width, height):
vp = trinity.TriViewport()
vp.x = 0
vp.y = 0
vp.width = width
vp.height = height
rj.SetViewport(vp)
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 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 __init__(self, paparazziMode=False):
if not paparazziMode:
sm.RegisterNotify(self)
if len(trinity.textureAtlasMan.atlases) == 0:
trinity.textureAtlasMan.AddAtlas(
trinity.PIXEL_FORMAT.B8G8R8A8_UNORM, 2048, 2048)
self.textureAtlas = trinity.textureAtlasMan.atlases[0]
self.textureAtlas.optimizeOnRemoval = False
self.renderObjectToPyObjectDict = weakref.WeakValueDictionary()
self.x = -1
self.y = -1
self.z = 0
self.dx = 0
self.dy = 0
self.dz = 0
self._mouseOver = None
self._auxMouseOverRO = None
self._capturingMouseItem = None
self._clickItem = None
self._mouseTargetObject = None
self.exclusiveMouseFocusActive = False
self.appfocusitem = None
self.selectedCursorType = uiconst.UICURSOR_DEFAULT
self.centerMouse = False
self.ignoreDeadChar = None
self._lastEventTime = None
self._globalClickCounter = 0
self._globalKeyDownCounter = 0
self._clickTime = None
self._clickCount = 0
self._clickTimer = None
self._clickPosition = None
self.rootObjects = []
self.rootObjectsByName = {}
self._triuiRegs = {}
self._triuiRegsByMsgID = {}
self._mouseButtonStates = {}
self._mouseDownPosition = {}
self._appfocusitem = None
self._modkeysOff = tuple([0 for x in uiconst.MODKEYS])
self._expandMenu = None
self._keyDownAcceleratorThread = None
self.blurredBackBufferRenderJob = None
self.blurredBackBufferAtlas = None
self.desktopBlurredBg = None
self._pickProjection = trinity.TriProjection()
self._pickView = trinity.TriView()
self._pickViewport = trinity.TriViewport()
self.cursorCache = {}
self.alignIslands = []
uicore.uilib = self
trinity.fontMan.loadFlag = 32
if not paparazziMode:
self._SetupRenderJob()
self.desktop = self.CreateRootObject('Desktop', isFullscreen=True)
uthread.new(self.EnableEventHandling)
from eve.client.script.ui.tooltips.tooltipHandler import TooltipHandler
self.tooltipHandler = TooltipHandler()
trinity.device.RegisterResource(self)
self._hoverThread = None
def CreateRJ(self,
target,
name,
depthClear=0.0,
setDepthStencil=True,
clearColor=(0.125, 0.125, 0.125, 1.0),
isRT=False):
"""
Helper method to create a renderjob that has a target and viewport matching the target argument.
"""
rj = trinity.CreateRenderJob(name)
rj.PushRenderTarget(target.wrappedRenderTarget).name = name
if setDepthStencil:
rj.PushDepthStencil(self.depth)
rj.Clear(clearColor, depthClear)
rj.SetStdRndStates(trinity.RM_FULLSCREEN)
vp = trinity.TriViewport()
vp.x = 0
vp.y = 0
if False:
rdesc = target.GetDesc()
vp.width = rdesc['Width']
vp.height = rdesc['Height']
else:
vp.width = target.width
vp.height = target.height
rj.SetViewport(vp)
return rj
def OverrideInteriorFlareViewports(flarePreviousState, x, y, width, height):
viewport = trinity.TriViewport()
viewport.x = int(x)
viewport.y = int(y)
viewport.width = int(width)
viewport.height = int(height)
for flare in flarePreviousState:
flare.OverrideViewport(viewport)
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 _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 _ManualInit(self, name):
self.stencilBlitEffect = None
self.stencilPath = ''
self.SetupStencilBlitEffect()
self.isOffscreen = False
self.doFinalBlit = True
self.offscreenRenderTarget = None
self.offscreenDepthStencil = None
self.finalTexture = None
self.rtWidth = 0
self.rtHeight = 0
self.blitViewport = trinity.TriViewport()
SceneRenderJobSpace._ManualInit(self, name)
def Update(self, *args):
if getattr(self, 'updatingFromRoot', False):
return
vp = trinity.TriViewport()
vp.width = trinity.device.width
vp.height = trinity.device.height
self.scaledViewportStep.viewport = vp
self.UpdateMouseOver()
for root in self.rootObjects:
root.UpdateAlignment()
for island in self.alignIslands:
island.UpdateAlignmentAsRoot()
self.alignIslands = []
def CompositeTexture(self, effect, subrect = None):
if self.renderTarget:
vp = trinity.TriViewport()
if subrect:
vp.x = subrect[0]
vp.y = subrect[1]
vp.width = subrect[2] - subrect[0]
vp.height = subrect[3] - subrect[1]
else:
vp.x = 0
vp.y = 0
vp.width = self.renderTarget.width
vp.height = self.renderTarget.height
self.renderJob.SetViewport(vp)
self.renderJob.RenderEffect(effect)
def ApplyAttributes(self, attributes):
Base.ApplyAttributes(self, attributes)
self.viewport = trinity.TriViewport()
self.linegraph = trinity.Tr2LineGraph()
self.linegraphSize = 0
self.linegraph.name = 'FPS'
self.linegraph.color = (0.9, 0.9, 0.9, 1)
blue.statistics.SetAccumulator(self.linegraph.name, self.linegraph)
self.renderJob = trinity.CreateRenderJob('Graphs')
self.renderObject.renderJob = self.renderJob
self.renderJob.PythonCB(self.AdjustViewport)
self.renderJob.SetViewport(self.viewport)
self.renderJob.SetStdRndStates(trinity.RM_SPRITE2D)
self.renderer = self.renderJob.RenderLineGraph()
self.renderer.showLegend = False
self.renderer.lineGraphs.append(self.linegraph)
def ApplyAttributes(self, attributes):
self.viewport = trinity.TriViewport()
self.viewport.x = 0
self.viewport.y = 0
self.viewport.width = 1
self.viewport.height = 1
self.viewport.minZ = 0.0
self.viewport.maxZ = 1.0
self.projection = trinity.TriProjection()
self.renderJob = None
self.frontClip = 1.0
self.backClip = 350000.0
self.fieldOfView = 1.0
self.minPitch = -1.4
self.maxPitch = 1.4
self.offscreen = False
uicls.Base.ApplyAttributes(self, attributes)
def Update(self, *args):
if getattr(self, 'updatingFromRoot', False):
return
vp = trinity.TriViewport()
vp.width = trinity.device.width
vp.height = trinity.device.height
self.scaledViewportStep.viewport = vp
self.cursorPos = trinity.GetCursorPos()
self.UpdateMouseOver()
if self.tooltipHandler:
self.tooltipHandler.RefreshTooltip()
for root in self.rootObjects:
root.UpdateAlignmentAsRoot('uilib.Update')
for island in self.alignIslands:
if not island.destroyed:
island.UpdateAlignmentAsRoot('uilib.Update Islands')
self.alignIslands = []
def _Bake(self, targetTex, transform):
self.SetShaderValue(self.__avatar, 'TattooVSUVTransform', transform)
size = (targetTex.width, targetTex.height)
renderTarget = targetTex.wrappedRenderTarget
sourceVP = trinity.TriViewport()
sourceVP.width = size[0]
sourceVP.height = size[1]
rj = trinity.CreateRenderJob('Baking out source decal texture')
rj.PushRenderTarget(renderTarget)
rj.SetProjection(trinity.TriProjection())
rj.SetView(trinity.TriView())
rj.SetViewport(sourceVP)
rj.PushDepthStencil(None)
rj.Clear((0.0, 0.0, 0.0, 0.0))
rj.SetStdRndStates(trinity.RM_FULLSCREEN)
rj.Update(self.bakeScene)
rj.RenderScene(self.bakeScene)
rj.PopRenderTarget()
rj.PopDepthStencil()
rj.ScheduleChained()
rj.WaitForFinish()
def SetRenderTargets(self, *args):
SceneRenderJobSpace.SetRenderTargets(self, *args)
self.RemoveStep('PUSH_RENDER_TARGET')
self.RemoveStep('PUSH_DEPTH_STENCIL')
self.RemoveStep('POP_RENDER_TARGET')
self.RemoveStep('POP_DEPTH_STENCIL')
self.RemoveStep('SET_BLIT_VIEWPORT')
self.RemoveStep('COPY_TO_BLIT_TEXTURE')
self.RemoveStep('FINAL_BLIT_EMBEDDED')
self.RemoveStep('PUSH_BLIT_DEPTH')
self.RemoveStep('POP_BLIT_DEPTH')
viewport = self.GetViewport()
if viewport is not None:
vpStep = self.GetStep('SET_VIEWPORT')
if vpStep is not None:
vpOrigin = trinity.TriViewport(0, 0, viewport.width, viewport.height)
vpStep.viewport = vpOrigin
if self.offscreenDepthStencil:
self.AddStep('PUSH_DEPTH_STENCIL', trinity.TriStepPushDepthStencil(self.offscreenDepthStencil))
self.AddStep('POP_DEPTH_STENCIL', trinity.TriStepPopDepthStencil())
if self.offscreenRenderTarget:
self.AddStep('PUSH_RENDER_TARGET', trinity.TriStepPushRenderTarget(self.offscreenRenderTarget))
self.AddStep('POP_RENDER_TARGET', trinity.TriStepPopRenderTarget())
self.AddStep('PUSH_BLIT_DEPTH', trinity.TriStepPushDepthStencil(None))
self.RemoveStep('FINAL_BLIT')
if self.customBackBuffer is not None and self.finalTexture is not None:
step = trinity.TriStepResolve(self.finalTexture, self.customBackBuffer)
step.name = 'Resolve: finalTexture <== customBackBuffer'
self.AddStep('COPY_TO_BLIT_TEXTURE', step)
if self.doFinalBlit:
self.AddStep('SET_BLIT_VIEWPORT', trinity.TriStepSetViewport(viewport))
if self.finalTexture:
if self.stencilPath is None or self.stencilPath == '':
self.AddStep('FINAL_BLIT_EMBEDDED', trinity.TriStepRenderTexture(self.finalTexture))
else:
stencilTriTextureRes = trinity.TriTextureRes()
stencilTriTextureRes.SetFromRenderTarget(self.finalTexture)
self.blitMapParameter.SetResource(stencilTriTextureRes)
self.AddStep('FINAL_BLIT_EMBEDDED', trinity.TriStepRenderEffect(self.stencilBlitEffect))
self.AddStep('POP_BLIT_DEPTH', trinity.TriStepPopDepthStencil())
def ApplyAttributes(self, attributes):
self.viewport = trinity.TriViewport()
self.viewport.x = 0
self.viewport.y = 0
self.viewport.width = 1
self.viewport.height = 1
self.viewport.minZ = 0.0
self.viewport.maxZ = 1.0
self.projection = trinity.TriProjection()
self.renderJob = None
self.frontClip = 1.0
self.backClip = 350000.0
self.fov = 1.0
self.minPitch = -1.4
self.maxPitch = 1.4
self.scene = None
self.offscreen = False
self.PrepareCamera()
self._reloadLock = locks.Lock()
Base.ApplyAttributes(self, attributes)
self.minZoom = attributes.Get('minZoom', self.default_minZoom)
self.maxZoom = attributes.Get('maxZoom', self.default_maxZoom)
def __init__(self, *args, **kwargs):
self.viewport = trinity.TriViewport()
Base.__init__(self, *args, **kwargs)
self.isReady = True
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)
def CreateRenderJob(size,
view,
projection,
bgColor=None,
transparent=False,
postProcessingQuality=2,
antiAliasingQuality=3):
"""
Creates a Jessica render job and adds functionality for 2D sprite background and overlays.
"""
def _GetRenderStepPosition(renderJob, name):
for i, each in enumerate(renderJob.steps):
if each.name == name:
return i
return i
if transparent:
clearColor = bgColor or (0.0, 0.0, 0.0, 0.0)
format = trinity.PIXEL_FORMAT.B8G8R8A8_UNORM
else:
clearColor = bgColor or (0.0, 0.0, 0.0, 1.0)
format = trinity.PIXEL_FORMAT.B8G8R8X8_UNORM
rt = trinity.Tr2RenderTarget(size, size, 1, format)
rt.name = 'MyRT'
ds = trinity.Tr2DepthStencil()
ds.Create(size, size, trinity.DEPTH_STENCIL_FORMAT.D24S8, 0, 0)
ds.name = 'MyDS'
vp = trinity.TriViewport()
vp.width = size
vp.height = size
renderJob = CreateJessicaSpaceRenderJob()
renderJob.updateJob = None
renderJob.CreateBasicRenderSteps()
renderJob.OverrideSettings('hdrEnabled', True)
settings = renderJob.GetSettings()
settings['postProcessingQuality'] = postProcessingQuality
settings['aaQuality'] = antiAliasingQuality
renderJob.SetSettings(settings)
renderJob.SetClearColor(clearColor)
renderJob.OverrideSettings('bbFormat', format)
renderJob.SetActiveCamera(view=view, projection=projection)
renderJob.SetViewport(vp)
renderJob.OverrideBuffers(rt, ds)
renderJob.Enable(False)
bgStep = trinity.TriStepRenderScene()
bgStep.name = 'BACKGROUND_SPRITE'
bgSprite1 = CreateSprite(1.0, size)
bgSprite2 = CreateSprite(1.0, size)
bgSpriteScene = trinity.Tr2Sprite2dScene()
bgSpriteScene.children.append(bgSprite1)
bgSpriteScene.children.append(bgSprite2)
bgStep.scene = bgSpriteScene
pos = _GetRenderStepPosition(renderJob, 'CLEAR')
renderJob.steps.insert(pos + 1, bgStep)
setattr(renderJob, 'iconTexture', bgSprite1.texturePrimary)
setattr(renderJob, 'backgroundTexture', bgSprite2.texturePrimary)
oStep = trinity.TriStepRenderScene()
oStep.name = 'OVERLAY_SPRITES'
oSprite1 = CreateSprite(1.0, size)
oSprite1.blendMode = 2
oSprite2 = CreateSprite(16.0 / size, size)
oSpriteScene = trinity.Tr2Sprite2dScene()
oSpriteScene.children.append(oSprite1)
oSpriteScene.children.append(oSprite2)
oStep.scene = oSpriteScene
pos2 = _GetRenderStepPosition(renderJob, 'END_RENDERING')
renderJob.steps.insert(pos2 + 1, oStep)
setattr(renderJob, 'overlayTexture', oSprite1.texturePrimary)
setattr(renderJob, 'techTexture', oSprite2.texturePrimary)
setattr(renderJob, 'renderTarget', rt)
return renderJob
def CreateRenderJobsForLight(self, light):
"""
Create a renderjob to render out the shadow map for this light, and blur
it for VSM; optionally also show it on the screen for debugging.
"""
self.lights.append(light)
if not SkinSpotLightShadows.REUSE_ENGINE_MAPS:
light.shadowCasterTypes = 0
else:
light.shadowResolution = 1024
ignoreLight = False
if self.lightFilter is not None and light.name not in self.lightFilter:
ignoreLight = True
elif len(self.lights) > SkinSpotLightShadows.MAX_LIGHTS or light.coneAlphaOuter > 89:
ignoreLight = True
if ignoreLight:
light.importanceScale = 0
light.importanceBias = -9999
light.shadowCasterTypes = 0
return
light.importanceScale = 0
light.importanceBias = -len(self.lights)
if SkinSpotLightShadows.REUSE_ENGINE_MAPS:
self.RTs[light] = light.GetShadowTextureRes()
rj = trinity.CreateRenderJob('render shadowmap ' + str(light))
self.jobs[light] = [rj]
cb = trinity.TriStepPythonCB()
cb.name = 'UpdateViewProjForLight'
cb.SetCallback(lambda : self.UpdateViewProjForLight(None, None, light, None))
rj.steps.append(cb)
rj.ScheduleRecurring()
return
rj = trinity.CreateRenderJob('render shadowmap ' + str(light))
renderTarget = None
while self.width > 8:
renderTarget = trinity.Tr2RenderTarget(self.width, self.height, 1, self.format)
if renderTarget is None or not renderTarget.isValid:
renderTarget = None
self.width /= 2
self.height /= 2
pdCf.Yield()
else:
break
self.RTs[light] = renderTarget
depthStencil = None
while self.width > 8:
depthStencil = trinity.Tr2DepthStencil(self.width, self.height, trinity.DEPTH_STENCIL_FORMAT.D24S8)
if depthStencil is None or not depthStencil.isValid:
depthStencil = None
self.width /= 2
self.height /= 2
pdCf.Yield()
else:
break
if not renderTarget or not depthStencil or not renderTarget.isValid or not depthStencil.isValid:
return
v = None
rj.PushViewport()
rj.PushRenderTarget(renderTarget)
rj.PushDepthStencil(depthStencil)
clearColor = (100.0, 1.0, 1.0, 1.0)
rj.Clear(clearColor, 1.0)
vp = trinity.TriViewport()
vp.x = 0
vp.y = 0
vp.width = self.width
vp.height = self.height
rj.PushProjection()
rj.PushViewTransform()
rj.SetViewport(vp)
cb = trinity.TriStepPythonCB()
cb.name = 'UpdateViewProjForLight'
rj.steps.append(cb)
stepProj = rj.SetProjection(trinity.TriProjection())
stepView = rj.SetView(trinity.TriView())
self.UpdateViewProjForLight(stepView, stepProj, light, v)
cb.SetCallback(lambda : self.UpdateViewProjForLight(stepView, stepProj, light, v))
def applyVisualizer(doIt):
for meshData in self.meshes.itervalues():
if doIt:
meshData.applyShadowEffect()
else:
meshData.applyOriginalEffect()
cb = trinity.TriStepPythonCB()
cb.name = 'applyVisualizer(True)'
cb.SetCallback(lambda : applyVisualizer(True))
rj.steps.append(cb)
rj.RenderScene(self.scene)
cb = trinity.TriStepPythonCB()
cb.name = 'applyVisualizer(False)'
cb.SetCallback(lambda : applyVisualizer(False))
rj.steps.append(cb)
rj.PopDepthStencil()
rj.PopRenderTarget()
rj.PopViewTransform().name = 'TriStepPopViewTransform Restoring state'
rj.PopViewport()
rj.PopProjection()
if SkinSpotLightShadows.renderJob is not None and SkinSpotLightShadows.renderJob.object is not None:
step = trinity.TriStepRunJob()
step.job = rj
SkinSpotLightShadows.renderJob.object.steps.insert(0, step)
else:
self.jobs[light] = [rj]
rj.ScheduleRecurring(insertFront=True)
if self.debugVisualize:
rj2 = trinity.CreateRenderJob('visualize shadowmap ' + str(light))
if light not in self.jobs:
self.jobs[light] = [rj2]
else:
self.jobs[light].append(rj2)
rj2.PushDepthStencil(None)
size = 200
vp2 = trinity.TriViewport()
vp2.x = 10
vp2.y = 10 + (size + 10) * (len(self.lights) - 1)
vp2.width = size
vp2.height = size
rj2.PushViewport()
rj2.PushProjection()
rj2.PushViewTransform()
rj2.SetViewport(vp2)
rj2.SetStdRndStates(trinity.RM_FULLSCREEN)
rj2.RenderTexture(renderTarget)
rj2.PopViewTransform()
rj2.PopProjection()
rj2.PopViewport()
rj2.PopDepthStencil()
rj2.ScheduleRecurring()
def GetMaskAtPixel(self, x, y):
self.zoneSize = (self.zoneMap.width, self.zoneMap.height)
self.bodyZoneSize = (self.bodyZoneMap.width, self.bodyZoneMap.height)
if self.zoneSize[0] == 0 or self.bodyZoneSize[0] == 0:
return (0,
0,
[0, 0],
0,
True)
mask = 0
dev = trinity.device
cameraProj, cameraView = self.GetProjectionAndViewMatrixFunc()
if self.pickScene:
self.pickAvatar.rotation = self.avatar.rotation
backbuffer = self.backbuffer or trinity.device.GetRenderContext().GetDefaultBackBuffer()
viewport = trinity.TriViewport(0, 0, backbuffer.width, backbuffer.height)
pick = None
if hasattr(self.pickScene, 'PickObject'):
pick = self.pickScene.PickPointAndObject(x, y, cameraProj, cameraView, viewport)
if not pick:
return (0,
0,
[0, 0],
0,
True)
if not hasattr(self.pickScene, 'PickObjectUV') or pick[0].__typename__ != 'Tr2IntSkinnedObject':
return (0,
pick[0],
[0, 0],
pick[1],
True)
pickedPixelUV = self.pickScene.PickObjectUV(x, y, cameraProj, cameraView, viewport)
isHead = True
self.pickedSide = 'right'
midpoint = 0.5
if pickedPixelUV[0] > 0.5:
self.pickedMesh = 'head'
pickedPixelUV = [(pickedPixelUV[0] - 0.5) * 2.0, pickedPixelUV[1] * 2.0]
if pickedPixelUV[0] < 0.0 or pickedPixelUV[0] > 1.0 or pickedPixelUV[1] < 0.0 or pickedPixelUV[1] > 1.0:
return (0,
pick[0],
pickedPixelUV,
pick[1],
isHead)
pixel = [int(pickedPixelUV[0] * self.zoneSize[0]), int(pickedPixelUV[1] * self.zoneSize[1])]
buffer = self.zoneMap.GetRawData()
color = struct.unpack_from('=BBBB', buffer[0], pixel[0] * 4 + pixel[1] * buffer[3])
mask = color[0]
else:
isHead = False
self.pickedMesh = 'body'
pickedPixelUV = [pickedPixelUV[0] * 2.0, pickedPixelUV[1]]
pixel = [int(pickedPixelUV[0] * self.bodyZoneSize[0]), int(pickedPixelUV[1] * self.bodyZoneSize[1])]
buffer = self.bodyZoneMap.GetRawData()
color = struct.unpack_from('=BBBB', buffer[0], pixel[0] * 4 + pixel[1] * buffer[3])
mask = color[0]
zone = self.ConvertMaskToZone(mask)
if zone in (0, 2, 5) or zone == 1 and pickedPixelUV[0] < 0.37:
midpoint = 0.2
if pickedPixelUV[0] > midpoint:
self.pickedSide = 'left'
return (mask,
pick[0],
pickedPixelUV,
pick[1],
isHead)
def __init__(self, paparazziMode=False):
if len(trinity.textureAtlasMan.atlases) == 0:
trinity.textureAtlasMan.AddAtlas(
trinity.PIXEL_FORMAT.B8G8R8A8_UNORM, 2048, 2048)
self.textureAtlas = trinity.textureAtlasMan.atlases[0]
self.textureAtlas.optimizeOnRemoval = False
self.renderObjectToPyObjectDict = weakref.WeakValueDictionary()
self.x = -1
self.y = -1
self.z = 0
self.dx = 0
self.dy = 0
self.dz = 0
self._mouseOver = None
self._auxMouseOverRO = None
self._capturingMouseItem = None
self._clickItem = None
self.exclusiveMouseFocusActive = False
self.appfocusitem = None
self.selectedCursorType = uiconst.UICURSOR_DEFAULT
self.centerMouse = False
self.ignoreDeadChar = None
self._lastEventTime = None
self._globalClickCounter = 0
self._globalKeyDownCounter = 0
self._clickTime = None
self._clickCount = 0
self._clickTimer = None
self._clickPosition = None
self.rootObjects = []
self.rootObjectsByName = {}
self._triuiRegs = {}
self._triuiRegsByMsgID = {}
self._mouseButtonStates = {}
self._mouseDownPosition = {}
self._appfocusitem = None
self._modkeysOff = tuple([0 for x in uiconst.MODKEYS])
self._expandMenu = None
self._keyDownAcceleratorThread = None
self._pickProjection = trinity.TriProjection()
self._pickView = trinity.TriView()
self._pickViewport = trinity.TriViewport()
self.cursorCache = {}
self.alignIslands = []
uicore.uilib = self
trinity.fontMan.loadFlag = 32
if not paparazziMode:
self.inSceneRenderJob = trinity.CreateRenderJob()
self.inSceneRenderJob.name = 'In-scene UI'
self.inSceneRenderJob.ScheduleRecurring(insertFront=True)
self.renderJob = trinity.CreateRenderJob()
self.renderJob.name = 'UI'
self.sceneViewStep = self.renderJob.SetView()
self.scaledViewportStep = self.renderJob.SetViewport()
self.sceneProjectionStep = self.renderJob.SetProjection()
videoJobStep = self.renderJob.RunJob()
videoJobStep.name = 'Videos'
self.videoJob = trinity.CreateRenderJob()
self.videoJob.name = 'Update videos job'
videoJobStep.job = self.videoJob
self.bracketCurveSet = trinity.TriCurveSet()
self.bracketCurveSet.Play()
self.renderJob.Update(
self.bracketCurveSet).name = 'Update brackets'
self.renderJob.SetViewport()
self.renderJob.PythonCB(self.Update).name = 'Update uilib'
isFpsEnabled = trinity.IsFpsEnabled()
if isFpsEnabled:
trinity.SetFpsEnabled(False)
self.renderJob.ScheduleRecurring()
if isFpsEnabled:
trinity.SetFpsEnabled(True)
self.desktop = self.CreateRootObject('Desktop', isFullscreen=True)
uthread.new(self.EnableEventHandling)
trinity.device.RegisterResource(self)
self._hoverThread = None
