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 RunSimulation(self):
trinity.settings.SetValue('frustumCullingDisabled', 1)
trinity.settings.SetValue('eveSpaceSceneVisibilityThreshold', 0)
trinity.settings.SetValue('eveSpaceSceneLowDetailThreshold', 0)
trinity.settings.SetValue('eveSpaceSceneMediumDetailThreshold', 0)
ut.StartTasklet(self._PumpBlue)
import sceneutils
scene = sceneutils.GetOrCreateScene()
scene.objects.append(self.redNodeMutated)
self._UpdateBoundingBox(True)
rj = trinity.CreateRenderJob('CallbackJob')
projection = trinity.TriProjection()
projection.PerspectiveFov(1, 1, 1, 10000000)
rj.steps.append(trinity.TriStepSetProjection(projection))
view = trinity.TriView()
view.SetLookAtPosition((50000, 0, 0), (0, 0, 0), (0, 1, 0))
rj.steps.append(trinity.TriStepSetView(view))
rj.steps.append(trinity.TriStepUpdate(scene))
rj.steps.append(trinity.TriStepRenderScene(scene))
rj.steps.append(trinity.TriStepPythonCB(self.AccumulateBounds))
rj.ScheduleRecurring()
for i in range(self._passes):
self.activeIndex[0] = i
for cs in self.curveSets:
cs.Play()
for sys in self.systems:
sys.ClearParticles()
self.started[0] = True
ut.SleepSim(self._time)
rj.UnscheduleRecurring()
self._pumpBlue = False
def __init__(self):
sm.RegisterNotify(self)
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.rotateTarget = None
self._rotateOffset = (0.0, 0.0)
self.rotateUpdateThread = None
self.fovTarget = None
self.fovUpdateThread = None
self._fovOffset = 0.0
self._eyeOffset = None
self._atOffset = None
self._eyeAndAtOffset = None
self._atTransitOffset = None
self._eyeTransitOffset = None
self._effectOffset = None
self.centerOffset = None
self.isActive = False
self._transitDoneTime = None
self.viewMatrix = trinity.TriView()
self.projectionMatrix = trinity.TriProjection()
def PickObject(self, x, y):
if self.sceneManager.GetActiveScene() != self.renderScene:
return
rescale = 1.0 / 10000.0
projection = trinity.TriProjection()
projection.PerspectiveFov(trinity.GetFieldOfView(),
trinity.GetAspectRatio(),
trinity.GetFrontClip(),
trinity.GetBackClip())
view = trinity.TriView()
view.transform = trinity.GetViewTransform()
scaling, rotation, translation = geo2.MatrixDecompose(
self.transform.worldTransform)
pZ = geo2.Vec3Transform((0, 0, 1), self.transform.worldTransform)
surfaceNormal = geo2.Subtract(pZ, translation)
cameraZ = geo2.Vector(view.transform[0][2], view.transform[1][2],
view.transform[2][2])
if geo2.Vec3Dot(surfaceNormal, cameraZ) < 0:
return
self.renderObject.translation = geo2.Vec3Scale(translation, rescale)
self.renderObject.rotation = rotation
self.renderObject.scaling = geo2.Vec3Scale(scaling, rescale)
scaling, rotation, translation = geo2.MatrixDecompose(view.transform)
translation = geo2.Vec3Scale(translation, rescale)
view.transform = geo2.MatrixTransformation(None, None, scaling, None,
rotation, translation)
return self.renderObject.PickObject(x, y, projection, view,
trinity.device.viewport)
def GetViewAndProjectionUsingBoundingSphere(self, 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 self._SphericalFit(boundingSphereRadius, fov)
projection = trinity.TriProjection()
projection.PerspectiveFov(fov, 1.0, 1.0, GETPHOTO_BACKCLIP)
view = trinity.TriView()
view.SetLookAtPosition(*self._GetViewMatrixFromAngle(cameraAngle, boundingSphereCenter, dist))
return (view, projection)
def _GetViewAndProjectionUsingProjectedBoundingBox(
calculateProjectedBoundingBox,
scene=None,
boundingSphereRadius=None,
boundingSphereCenter=None,
boundingBoxMin=None,
boundingBoxMax=None,
cameraAngle=None):
"""
Fits an object in frame with view and projection matrices. We first do a rough fit
using either the bounding sphere or bounding box. We then "zoom in" to the point where
the projected bounding box fills 90% of the image.
"""
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 __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 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 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 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 _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 __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 _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 FollowCamera(self, target, aimTarget=None):
viewStep, proj = self.GetViewAndProjection()
if viewStep:
viewStep.view = trinity.TriView()
camera = sm.GetService('sceneManager').GetRegisteredCamera(
None, defaultOnActiveCamera=True)
globalSceneScale = 1.0
ballpark = sm.GetService('michelle').GetBallpark()
ball = ballpark.GetBall(eve.session.shipid)
self.resetCamera = False
while not self.resetCamera and target:
time = blue.os.GetSimTime()
rot = target.rotationCurve
if True:
rotation = rot.GetQuaternionAt(time)
translation = target.translationCurve.GetVectorAt(time)
if ball:
targetPos = ball.model.worldPosition
targetVector = (targetPos[0] - translation.x,
targetPos[0] - translation.x,
targetPos[0] - translation.x)
targetVector = geo2.Vec3Normalize(targetVector)
dist = 100.0
elevation = 0.0
translation.x = translation.x - targetVector[0] * dist
translation.y = translation.y - targetVector[
1] * dist + elevation
translation.z = translation.z - targetVector[2] * dist
lookat = geo2.MatrixLookAtRH(
(translation.x, translation.y, translation.z),
targetPos, (0.0, 1.0, 0.0))
trans = geo2.MatrixTranslation(
translation.x * globalSceneScale,
translation.y * globalSceneScale,
translation.z * globalSceneScale)
rot = geo2.MatrixRotationQuaternion(
(rotation.x, rotation.y, rotation.z, rotation.w))
if viewStep and viewStep.view:
viewStep.view.transform = lookat
blue.synchro.Yield()
if viewStep:
viewStep.view = None
proj.projection = camera.projectionMatrix
self.resetCamera = False
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 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 _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 _UpdateCameraAnimation(self,
alignToParent=False,
alignTargets=None,
loop=False,
clipName=None,
parent=None):
def FindParametersInPostFx():
blurScaleH = None
blurScaleV = None
blurFade = None
exposure = None
rj = self.GetRenderJob()
if rj:
for step in rj.steps:
if step.name == 'RJ_POSTPROCESSING':
if step.job:
for jobStep in step.job.steps:
if jobStep.name == 'PostProcess Blur':
for fx in jobStep.PostProcess.stages:
for param in fx.parameters:
if param.name == 'ScalingFactor':
if fx.name == 'Gaussian Horizontal Blur':
blurScaleH = param
if fx.name == 'Gaussianl Vertical Blur':
blurScaleV = param
if fx.name == '4x Up Filter and Add':
blurFade = param
if jobStep.name == 'PostProcess Exposure':
for fx in jobStep.PostProcess.stages:
for param in fx.parameters:
if param.name == 'ScalingFactor':
if fx.name == '4x Up Filter and Add':
exposure = param
return (blurScaleH, blurScaleV, blurFade, exposure)
transformTrack = None
shakeSequencer = None
duration = 0.0
curveSetName = 'AnimatedCamera'
scene = sm.GetService('sceneManager').GetRegisteredScene('default')
viewStep, proj = self.GetViewAndProjection()
camera = viewStep.camera
for cset in scene.curveSets:
if cset.name == curveSetName:
transformTrack = cset.curves[0]
if len(cset.curves) > 1:
shakeSequencer = cset.curves[1]
duration = transformTrack.duration - 1 / 10.0
oldFov = camera.fieldOfView
ppJob.AddPostProcess('Blur', 'res:/fisfx/postprocess/blur.red')
ppJob.AddPostProcess('Exposure', 'res:/fisfx/postprocess/exposure.red')
blurScaleH, blurScaleV, blurFade, exposure = FindParametersInPostFx()
ballpark = sm.GetService('michelle').GetBallpark()
ball = ballpark.GetBall(session.shipid)
if parent:
ball = parent.translationCurve
if alignTargets:
ball = alignTargets[0]
if viewStep:
viewStep.view = trinity.TriView()
startTime = blue.os.GetSimTime()
if loop:
endTime = startTime + 36000000000L
else:
endTime = startTime + duration * 10000000
time = startTime
globalSceneScale = 4.0 / 30.0 * ball.model.boundingSphereRadius
lastWorldPos = None
lastWorldRot = None
while time < endTime and not self.resetCamera and not self.interrupt:
time = blue.os.GetSimTime()
weight1 = 0.0
weight2 = 0.0
if self.vectorTracks:
currentTime = trinity.device.animationTime
for cvt in self.vectorTracks:
if cvt == 'targetWeight1' or cvt == 'targetWeight2':
vecTrack = self.vectorTracks[cvt]
if cvt == 'targetWeight1':
weight1 = vecTrack.value
else:
weight2 = vecTrack.value
if viewStep:
trans = geo2.MatrixTranslation(
transformTrack.translation[0] * globalSceneScale,
transformTrack.translation[1] * globalSceneScale,
transformTrack.translation[2] * globalSceneScale)
rot = geo2.MatrixRotationQuaternion(transformTrack.rotation)
comp = geo2.MatrixMultiply(rot, trans)
if alignToParent:
if not ball.model and lastWorldPos:
translation = lastWorldPos
rotation = lastWorldRot
else:
rotation = ball.GetQuaternionAt(time)
translation = ball.model.worldPosition
lastWorldPos = translation
lastWorldRot = rotation
transOffset = geo2.MatrixTranslation(
translation[0], translation[1], translation[2])
rotOffset = geo2.MatrixRotationQuaternion(
(rotation.x, rotation.y, rotation.z, rotation.w))
comp = geo2.MatrixMultiply(comp, rotOffset)
comp = geo2.MatrixMultiply(comp, transOffset)
if alignTargets:
t1 = alignTargets[0].model.worldPosition
t2 = alignTargets[1].model.worldPosition
if True:
sphereOffset = alignTargets[
1].model.boundingSphereCenter
qr = alignTargets[
1].model.rotationCurve.GetQuaternionAt(time)
quatRotation = (qr.x, qr.y, qr.z, qr.w)
correctedOffset = geo2.QuaternionTransformVector(
quatRotation, sphereOffset)
t2 = geo2.Vec3Add(t2, correctedOffset)
rot = geo2.MatrixLookAtRH(t2, t1, (0.0, 1.0, 0.0))
rot = geo2.MatrixInverse(rot)
rot = (rot[0], rot[1], rot[2], (t1[0], t1[1], t1[2], 1.0))
comp = geo2.MatrixMultiply(comp, rot)
if weight1 > 0.0001:
shake = shakeSequencer.value
pos = (comp[3][0], comp[3][1], comp[3][2])
targetPos = (t2[0] + shake.x, t2[1] + shake.y,
t2[2] + shake.z)
lookat = geo2.MatrixLookAtRH(pos, targetPos,
(0.0, 1.0, 0.0))
lookat = geo2.MatrixInverse(lookat)
qlookat = geo2.QuaternionRotationMatrix(lookat)
qorig = geo2.QuaternionRotationMatrix(comp)
qresult = geo2.Lerp(qorig, qlookat, weight1)
mresult = geo2.MatrixRotationQuaternion(qresult)
comp = (mresult[0], mresult[1], mresult[2], comp[3])
if viewStep.view:
viewStep.view.transform = geo2.MatrixInverse(comp)
if self.vectorTracks:
currentTime = trinity.device.animationTime
for cvt in self.vectorTracks:
if cvt == 'fov':
vecTrack = self.vectorTracks['fov']
fovValue = vecTrack.value
camera.fieldOfView = fovValue
proj.projection.PerspectiveFov(
fovValue, trinity.device.width /
float(trinity.device.height), camera.frontClip,
camera.backClip)
if cvt == 'blur':
vecTrack = self.vectorTracks['blur']
blurValue = vecTrack.value
if blurScaleH and blurScaleV and blurFade:
blurScaleH.value = blurValue
blurScaleV.value = blurValue
if blurValue > 0.01:
blurFade.value = 1.0
else:
blurFade.value = 0.0
if cvt == 'exposure':
vecTrack = self.vectorTracks['exposure']
exposureValue = vecTrack.value
if exposure:
exposure.value = exposureValue
if 'fov' not in self.vectorTracks:
camera.fieldOfView = oldFov
proj.projection.PerspectiveFov(
oldFov,
trinity.device.width / float(trinity.device.height),
camera.frontClip, camera.backClip)
blue.synchro.Yield()
if exposure and blurFade:
exposure.value = 0.0
blurFade.value = 0.0
if viewStep:
viewStep.view = None
camera.fieldOfView = oldFov
if not self.interrupt:
if not camera.fieldOfView == 1.0:
self.LogWarn('Warning: Camera fov not 1, correcting...')
camera.fieldOfView = 1.0
proj.projection = camera.projectionMatrix
self.playingClip = False
if self.continuousType and not self.interrupt and not self.resetCamera:
self.interrupt = False
self.UpdateContinuous()
self.resetCamera = False
self.interrupt = False
if clipName:
self.LogInfo('Camera clip done:', clipName)
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, 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 __init__(self, *args, **kwds):
self.viewport = None
self.viewMatrix = trinity.TriView()
self.projectionMatrix = trinity.TriProjection()
self.enabled = True
uthread.new(self.UpdateTick)
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()
