def SetupIncarnaBackground(self, scene, sceneTranslation, sceneRotation):
if scene is not None:
self.incarnaRenderJob.SetBackgroundScene(scene)
self.backgroundView = trinity.TriView()
self.backgroundProjection = trinity.TriProjection()
backGroundCameraUpdateFunction = self.incarnaRenderJob.GetBackgroundCameraUpdateFunction(
self.backgroundView, self.backgroundProjection, 10.0, 40000.0,
sceneTranslation, sceneRotation)
self.incarnaRenderJob.SetBackgroundCameraViewAndProjection(
self.backgroundView, self.backgroundProjection,
backGroundCameraUpdateFunction)
def __init__(self, fov, front, back, asp):
self.minZoomDistance = 0.05
self.maxZoomDistance = 100000.0
self.parentPos = (0.0, 0.0, 0.0)
self.localViewMatrix = geo2.MatrixIdentity()
self.view = trinity.TriView()
self.view.transform = geo2.MatrixIdentity()
self.projection = trinity.TriProjection()
self.SetPerspective(fov, front, back, asp)
self.SetPosition((0.0, 50.0, -100.0))
self.Focus((0.0, 0.0, 0.0))
def Run(self, *etc):
service.Service.Run(self, *etc)
self.trinityViewMatrix = trinity.TriView()
self.trinityProjectionMatrix = trinity.TriProjection()
self.cameraStartupInfo = None
self.audioListener = None
self.enabled = False
self.transition = False
defaultCamera = cameras.PolarCamera()
defaultCamera.SetTrinityMatrixObjects(self.trinityViewMatrix, self.trinityProjectionMatrix)
self.sharedCameras = {'Basic Camera': defaultCamera}
self.cameraStack = [defaultCamera]
def PickPrimitiveScene(self, x, y):
camera = sm.GetService('sceneManager').GetActiveCamera()
view = trinity.TriView()
view.transform = camera.viewMatrix.transform
proj = trinity.TriProjection()
p = camera.projectionMatrix.transform
proj.CustomProjection(p)
res = self.primitiveScene.PickObject(x, y, proj, view, trinity.device.viewport)
if res and res.name in self.PickableAxis():
return res.name
else:
return None
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 _GetViewAndProjectionUsingProjectedBoundingBox(
calculateProjectedBoundingBox,
scene=None,
boundingSphereRadius=None,
boundingSphereCenter=None,
boundingBoxMin=None,
boundingBoxMax=None,
cameraAngle=None):
cameraAngle = cameraAngle or GETPHOTO_ANGLE
if boundingSphereRadius:
radius = boundingSphereRadius
center = boundingSphereCenter if boundingSphereCenter else (0.0, 0.0,
0.0)
else:
center = geo2.Vec3Add(boundingBoxMin, boundingBoxMax)
center = geo2.Vec3Scale(center, 0.5)
radius = geo2.Vec3Length(
geo2.Vec3Subtract(boundingBoxMax, boundingBoxMin))
dist = _SphericalFit(radius)
viewEyeAtUp = _GetViewMatrixFromAngle(cameraAngle, center, dist)
projTransform = geo2.MatrixPerspectiveFovRH(*GETPHOTO_PROJECTION)
viewTransform = geo2.MatrixLookAtRH(*viewEyeAtUp)
combinedTransform = viewTransform
combinedTransform = geo2.MatrixMultiply(combinedTransform, projTransform)
safeMin, safeMax = calculateProjectedBoundingBox(combinedTransform)
deltaX = safeMax[0] - safeMin[0]
deltaY = safeMax[1] - safeMin[1]
scalingFactor = 0.9 * (2.0 / max(deltaX, deltaY))
try:
if scene.backgroundEffect is not None:
params = scene.backgroundEffect.Find(['trinity.Tr2FloatParameter'])
for param in params:
if param.name == 'ProjectionScaling':
param.value = scalingFactor
except AttributeError:
pass
offsetX = -1 * scalingFactor * (safeMin[0] + safeMax[0]) / 2.0
offsetY = -1 * scalingFactor * (safeMin[1] + safeMax[1]) / 2.0
scale = 1.0 / tan(GETPHOTO_FOV / 2.0) * scalingFactor
zn = 1.0
zf = dist + radius * 2
t = zn * (1 - offsetY) / scale
b = -t * (1 + offsetY) / (1 - offsetY)
r = zn * (1 - offsetX) / scale
l = -r * (1 + offsetX) / (1 - offsetX)
projection = trinity.TriProjection()
projection.PerspectiveOffCenter(l, r, b, t, zn, zf)
view = trinity.TriView()
view.SetLookAtPosition(*viewEyeAtUp)
return (view, projection)
def EnableStereo(self, enable):
if enable == self.stereoEnabled:
return True
if enable:
def leftCallback():
return self._StereoUpdateViewProjection(trinity.STEREO_EYE_LEFT)
def rightCallback():
return self._StereoUpdateViewProjection(trinity.STEREO_EYE_RIGHT)
leftUpdate = self.AddStep('UPDATE_STEREO', trinity.TriStepPythonCB())
if leftUpdate is None:
return False
leftUpdate.SetCallback(leftCallback)
self.originalProjection = self.projection
self.stereoProjection = trinity.TriProjection()
self.SetCameraProjection(self.stereoProjection)
rightUpdate = trinity.TriStepPythonCB()
rightUpdate.name = 'UPDATE_STEREO_RIGHT'
rightUpdate.SetCallback(rightCallback)
self.steps.append(rightUpdate)
index = -1
try:
index = self.steps.index(self.GetStep('UPDATE_STEREO'))
except:
pass
if index >= 0:
count = len(self.steps)
for i in range(index + 1, count - 1):
step = self.steps[i]
self.steps.append(step)
self.stereoEnabled = True
else:
index = -1
for i, step in enumerate(self.steps):
if step.name == 'UPDATE_STEREO_RIGHT':
index = i
break
if index >= 0:
while len(self.steps) > index:
self.steps.removeAt(index)
self.stereoEnabled = False
self.RemoveStep('UPDATE_STEREO')
self.SetCameraProjection(self.originalProjection.object)
return True
def __init__(self):
service.Service.__init__(self)
self.selection = []
self.selectionObjs = []
self.ignoreAxis = None
self.lookatID = None
self.ed = None
view = trinity.TriView()
view.SetLookAtPosition((0, 2, -2), (0, 3, 0), (0, 1, 0))
projection = trinity.TriProjection()
projection.PerspectiveFov(1, trinity.device.viewport.GetAspectRatio(),
1, 3000)
self.clientToolsScene = None
self.clientToolsScene = scene = self.GetClientToolsScene()
self.cursors = {
'Translation':
dungeonEditorTools.TranslationTool(view, projection, scene),
'Rotation':
dungeonEditorTools.RotationTool(view, projection, scene),
'Scaling':
dungeonEditorTools.ScalingTool(view, projection, scene)
}
self.currentCursor = None
self.isActive = False
self.isMoving = False
self.isSaving = False
self.isUnlocking = False
self.dungeonOrigin = None
self.playerLocation = None
self.fakeBallTransforms = {}
self.backupTranslations = {}
self.backupRotations = {}
self.unsavedChanges = {}
self.unsavedTime = {}
self.lockedObjects = {}
self.lockedTime = {}
self.lastChangeTimestamp = None
self.lastUpdateRecievedTimestamp = None
self.selectionCenter = (0.0, 0.0, 0.0)
self.groupRotation = geo2.Vector(0, 0, 0, 1)
self.addSelectedTaskletCount = 0
self.currentHardGroup = None
self.hardGroupRotations = {}
self.rotatedSelectionGroups = {}
self.editDungeonID = None
self.editRoomID = None
self.editRoomPos = None
self.groupsWithNoModel = [
const.groupCosmicAnomaly, const.groupCosmicSignature
]
def GetViewAndProjectionUsingBoundingSphere(boundingSphereRadius,
boundingSphereCenter=None,
cameraAngle=None,
distanceOverride=None,
fov=GETPHOTO_FOV):
cameraAngle = cameraAngle or GETPHOTO_ANGLE
boundingSphereCenter = boundingSphereCenter or (0.0, 0.0, 0.0)
dist = distanceOverride if distanceOverride else _SphericalFit(
boundingSphereRadius, fov)
projection = trinity.TriProjection()
projection.PerspectiveFov(fov, 1.0, 1.0, GETPHOTO_BACKCLIP)
view = trinity.TriView()
view.SetLookAtPosition(
*_GetViewMatrixFromAngle(cameraAngle, boundingSphereCenter, dist))
return (view, projection)
def _GetViewAndProjectionUsingProjectedBoundingBox(self, CalculateProjectedBoundingBox, scene = None, boundingSphereRadius = None, boundingSphereCenter = None, boundingBoxMin = None, boundingBoxMax = None, cameraAngle = None):
self.LogInfo('TakeSnapShotUsingBoundingBox')
cameraAngle = cameraAngle or GETPHOTO_ANGLE
if boundingSphereRadius:
radius = boundingSphereRadius
center = boundingSphereCenter if boundingSphereCenter else (0.0, 0.0, 0.0)
elif boundingBoxMin and boundingBoxMax:
boundingBoxMin = geo2.Vector(boundingBoxMin.x, boundingBoxMin.y, boundingBoxMin.z)
boundingBoxMax = geo2.Vector(boundingBoxMax.x, boundingBoxMax.y, boundingBoxMax.z)
center = (boundingBoxMin + boundingBoxMax) / 2.0
radius = geo2.Vec3Length(boundingBoxMax - boundingBoxMin)
else:
raise RuntimeError('Can not do a rough fit without either a bounding sphere or bounding box.')
dist = self._SphericalFit(radius)
viewEyeAtUp = self._GetViewMatrixFromAngle(cameraAngle, center, dist)
projTransform = geo2.MatrixPerspectiveFovRH(*GETPHOTO_PROJECTION)
viewTransform = geo2.MatrixLookAtRH(*viewEyeAtUp)
combinedTransform = viewTransform
combinedTransform = geo2.MatrixMultiply(combinedTransform, projTransform)
safeMin, safeMax = CalculateProjectedBoundingBox(combinedTransform)
deltaX = safeMax[0] - safeMin[0]
deltaY = safeMax[1] - safeMin[1]
scalingFactor = 0.9 * (2.0 / max(deltaX, deltaY))
try:
if scene.backgroundEffect is not None:
params = scene.backgroundEffect.Find(['trinity.TriFloatParameter', 'trinity.Tr2FloatParameter'])
for param in params:
if param.name == 'ProjectionScaling':
param.value = scalingFactor
except AttributeError:
pass
offsetX = -1 * scalingFactor * (safeMin[0] + safeMax[0]) / 2.0
offsetY = -1 * scalingFactor * (safeMin[1] + safeMax[1]) / 2.0
scale = 1.0 / tan(GETPHOTO_FOV / 2.0) * scalingFactor
zn = 1.0
zf = dist + radius * 2
t = zn * (1 - offsetY) / scale
b = -t * (1 + offsetY) / (1 - offsetY)
r = zn * (1 - offsetX) / scale
l = -r * (1 + offsetX) / (1 - offsetX)
projection = trinity.TriProjection()
projection.PerspectiveOffCenter(l, r, b, t, zn, zf)
view = trinity.TriView()
view.SetLookAtPosition(*viewEyeAtUp)
return (view, projection)
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 __init__(self):
self.direction = (math.pi / 4.0, math.pi / 4.0, math.pi / 4.0)
self.cameraPosition = (0, 0, 0)
self.viewMatrix = trinity.TriView()
self.baseViewMatrix = trinity.TriView()
self.projectionMatrix = trinity.TriProjection()
self.fieldOfView = 1.0
self.frontClip = 0.1
self.backClip = 1000.0
self.yaw, self.pitch = self.GetYawPitch()
self.mouseLeftButtonDown = False
self.mouseRightButtonDown = False
self.desiredDeltaX = 0
self.desiredDeltaY = 0
self.controlEnabled = True
self.cameraBehaviors = []
self.lastUpdateTime = blue.os.GetWallclockTime()
self.audio2Listener = None
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 __init__(self):
sm.RegisterNotify(self)
self._animationCurves = {}
self._fov = self.default_fov
self._nearClip = self.default_nearClip
self._farClip = self.default_farClip
self._eyePosition = self.default_eyePosition
self._atPosition = self.default_atPosition
self._upDirection = self.default_upDirection
self.panTarget = None
self.panUpdateThread = None
self.zoomTarget = None
self.zoomUpdateThread = None
self.orbitTarget = None
self.orbitUpdateThread = None
self.eventListeners = defaultdict(list)
self.viewMatrix = trinity.TriView()
self.projectionMatrix = trinity.TriProjection()
self.Update()
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 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 ApplyAttributes(self, attributes):
uicls.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.scene = trinity.EveSpaceScene()
self.scene.renderGPUParticles = False
self.transform = trinity.EveRootTransform()
self.scene.objects.append(self.transform)
self.PrepareCamera()
self.DisplayScene()
self.CreateBracketCurveSet()
self.UpdateViewPort()
def RenderStaticEnvironment(self):
alphaFill = trinity.Tr2Effect()
alphaFill.effectFilePath = 'res:/Graphics/Effect/Utility/Compositing/AlphaFill.fx'
trinity.WaitForResourceLoads()
if self.staticEnvResource is None:
self.staticEnvResource = StaticEnvironmentResource(self)
dev = trinity.device
self.hangarScene.display = True
self.hangarScene.update = True
depthTexture = self.hangarScene.depthTexture
distortionTexture = self.hangarScene.distortionTexture
self.hangarScene.depthTexture = None
self.hangarScene.distortionTexture = None
clientWidth = trinity.device.width
clientHeight = trinity.device.height
renderTarget = trinity.Tr2RenderTarget(
clientWidth, clientHeight, 1, trinity.PIXEL_FORMAT.B8G8R8A8_UNORM)
depthStencil = trinity.Tr2DepthStencil(
clientWidth, clientHeight, trinity.DEPTH_STENCIL_FORMAT.AUTO)
self.SetupCamera()
camera = self.sceneManager.GetRegisteredCamera(self.name)
camera.idleMove = False
updateJob = trinity.CreateRenderJob('UpdateScene')
updateJob.SetView(None)
updateJob.Update(self.hangarScene)
while updateJob.status != trinity.RJ_DONE:
updateJob.ScheduleOnce()
updateJob.WaitForFinish()
view = trinity.TriView()
view.SetLookAtPosition(camera.pos, camera.intr, (0.0, 1.0, 0.0))
projection = trinity.TriProjection()
fov = camera.fieldOfView
aspectRatio = float(clientWidth) / clientHeight
projection.PerspectiveFov(fov, aspectRatio, 1.0, 350000.0)
renderJob = trinity.CreateRenderJob('StaticScene')
renderJob.PushRenderTarget(renderTarget)
renderJob.SetProjection(projection)
renderJob.SetView(view)
renderJob.PushDepthStencil(depthStencil)
renderJob.Clear((0.0, 0.0, 0.0, 0.0), 1.0)
renderJob.RenderScene(self.hangarScene)
renderJob.SetStdRndStates(trinity.RM_FULLSCREEN)
renderJob.RenderEffect(alphaFill)
renderJob.PopDepthStencil()
renderJob.PopRenderTarget()
while renderJob.status != trinity.RJ_DONE:
renderJob.ScheduleOnce()
renderJob.WaitForFinish()
self.hangarScene.display = False
self.hangarScene.update = False
try:
rgbSource = trinity.Tr2HostBitmap(renderTarget)
except Exception:
log.LogException()
sys.exc_clear()
return
self.RemoveFullScreenSprite()
self.sprite = uicls.Sprite(parent=uicore.uilib.desktop,
width=uicore.uilib.desktop.width,
height=uicore.uilib.desktop.height,
left=0,
top=0)
self.sprite.name = 'fullScreenSprite'
self.sprite.texture.atlasTexture = uicore.uilib.CreateTexture(
rgbSource.width, rgbSource.height)
self.sprite.texture.atlasTexture.CopyFromHostBitmap(rgbSource)
self.hangarScene.display = False
self.hangarScene.update = False
self.hangarScene.depthTexture = depthTexture
self.hangarScene.distortionTexture = distortionTexture
def __init__(self, *args, **kwds):
self.viewport = None
self.viewMatrix = trinity.TriView()
self.projectionMatrix = trinity.TriProjection()
self.enabled = True
uthread.new(self.UpdateTick)
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
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 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()
