def RenderLightmap(self): rj = self.CreateRJ(self.lightmap, 'Lightmap rendering', depthClear=None, setDepthStencil=False, clearColor=(0, 0, 0, 0)) self.lightmapRenderJob = rj self.AddCallback(SkinLightmapRenderer.OnBeforeUnwrap, 'onBeforeUnwrap') doHighZOptimization = False if not doHighZOptimization: rj.PushDepthStencil(None).name = 'Depthbuffer = None' rj.RenderScene(SkinLightmapRenderer.Scene()).name = 'Unwrap light pass' self.AddCallback(SkinLightmapRenderer.OnAfterUnwrap, 'onAfterUnwrap') rj.SetRenderTarget(self.scatteredLightmap.wrappedRenderTarget).name = 'Set Scattermap RT' self.AddCallback(SkinLightmapRenderer.OnBeforeBlur, 'onBeforeBlur') rj.SetStdRndStates(trinity.RM_FULLSCREEN) rj.RenderEffect(self.lightmapScatterEffect).name = 'Light blur pass' if self.useExpandOpaque: rj.SetRenderTarget(self.lightmap.wrappedRenderTarget).name = 'Set Lightmap RT for expand' self.AddCallback(SkinLightmapRenderer.OnBeforeExpand, 'onBeforeExpand') rj.RenderEffect(self.lightmapExpandEffect).name = 'Expand lightmap' self.AddCallback(SkinLightmapRenderer.OnAfterExpand, 'onAfterExpand') rj.PopRenderTarget().name = 'PopRT - main scene rendering' if not doHighZOptimization: rj.PopDepthStencil() if SkinLightmapRenderer.renderJob is not None and SkinLightmapRenderer.renderJob.object is not None: step = trinity.TriStepRunJob() step.job = rj SkinLightmapRenderer.renderJob.object.steps.append(step) else: jobs = trinity.renderJobs.recurring for job in jobs: if 'paperdoll' in job.name.lower(): step = trinity.TriStepRunJob(rj) step.name = rj.name job.steps.insert(len(job.steps) - 1, step) break else: rj.ScheduleRecurring()
def _CreateBackgroundStep(self, scene = None): if scene is None: scene = self.GetScene() job = trinity.CreateRenderJob() job.steps.append(trinity.TriStepRenderPass(scene, trinity.TRIPASS_BACKGROUND_RENDER)) job.steps.append(trinity.TriStepRunJob(self.backgroundDistortionJob)) self.AddStep('RENDER_BACKGROUND', trinity.TriStepRunJob(job))
def _DoFormatConversionStep(self, hdrTexture, msaaTexture = None): job = trinity.CreateRenderJob() job.name = 'DoFormatConversion' if msaaTexture is not None: if hdrTexture is not None: job.steps.append(trinity.TriStepResolve(hdrTexture, msaaTexture)) else: job.steps.append(trinity.TriStepResolve(self.GetBackBufferRenderTarget(), msaaTexture)) return trinity.TriStepRunJob(job) job.steps.append(trinity.TriStepSetStdRndStates(trinity.RM_FULLSCREEN)) job.steps.append(trinity.TriStepRenderTexture(hdrTexture)) return trinity.TriStepRunJob(job)
def RenderLightmap(self): """ Create all renderjobs needed to do the whole thing: 1. Render the scene using a light unwrap shader, saving out diffuse shading only 2. Dipole blur this map 3. Render the scene again with regular shading, except that all diffuse lighting comes from the output of step 2. This is actually part of the main rendering, we just need to make sure we exit with a decent setup (effect in place, step 2 RT attached) """ rj = self.CreateRJ(self.lightmap, 'Lightmap rendering', depthClear=None, setDepthStencil=False, clearColor=(0, 0, 0, 0)) self.lightmapRenderJob = rj self.AddCallback(SkinLightmapRenderer.OnBeforeUnwrap, 'onBeforeUnwrap') doHighZOptimization = False if not doHighZOptimization: rj.PushDepthStencil(None).name = 'Depthbuffer = None' rj.RenderScene(SkinLightmapRenderer.Scene()).name = 'Unwrap light pass' self.AddCallback(SkinLightmapRenderer.OnAfterUnwrap, 'onAfterUnwrap') rj.SetRenderTarget(self.scatteredLightmap.wrappedRenderTarget ).name = 'Set Scattermap RT' self.AddCallback(SkinLightmapRenderer.OnBeforeBlur, 'onBeforeBlur') rj.SetStdRndStates(trinity.RM_FULLSCREEN) rj.RenderEffect(self.lightmapScatterEffect).name = 'Light blur pass' if self.useExpandOpaque: rj.SetRenderTarget(self.lightmap.wrappedRenderTarget ).name = 'Set Lightmap RT for expand' self.AddCallback(SkinLightmapRenderer.OnBeforeExpand, 'onBeforeExpand') rj.RenderEffect(self.lightmapExpandEffect).name = 'Expand lightmap' self.AddCallback(SkinLightmapRenderer.OnAfterExpand, 'onAfterExpand') rj.PopRenderTarget().name = 'PopRT - main scene rendering' if not doHighZOptimization: rj.PopDepthStencil() if SkinLightmapRenderer.renderJob is not None and SkinLightmapRenderer.renderJob.object is not None: step = trinity.TriStepRunJob() step.job = rj SkinLightmapRenderer.renderJob.object.steps.append(step) else: jobs = trinity.renderJobs.recurring for job in jobs: if 'paperdoll' in job.name.lower(): step = trinity.TriStepRunJob(rj) step.name = rj.name job.steps.insert(len(job.steps) - 1, step) break else: rj.ScheduleRecurring()
def _SetupRenderJob(self): self.renderJob = trinity.CreateRenderJob() self.renderJob.name = 'UI' self.PrepareBlurredBackBuffer() 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' self.desktopRenderJob = trinity.CreateRenderJob() self.desktopRenderJob.name = 'Desktop' self.renderJob.steps.append( trinity.TriStepRunJob(self.desktopRenderJob)) isFpsEnabled = trinity.IsFpsEnabled() if isFpsEnabled: trinity.SetFpsEnabled(False) self.renderJob.ScheduleRecurring() if isFpsEnabled: trinity.SetFpsEnabled(True)
def CreateSculptingStep(renderJob, append=True): ghostStep = trinity.TriStepRunJob() ghostStep.name = 'Sculpting overlay' if append: renderJob.steps.append(ghostStep) AvatarGhost.renderStepSlot = blue.BluePythonWeakRef(ghostStep) return ghostStep
def SetRenderTargets(self, customBackBuffer, customDepthStencil, depthTexture, blitTexture, distortionTexture): self.RemoveStep('SET_DEPTH') if self.GetSwapChain() is not None: self.AddStep('SET_SWAPCHAIN_RT', trinity.TriStepSetRenderTarget(self.GetSwapChain().backBuffer)) self.AddStep('SET_SWAPCHAIN_DEPTH', trinity.TriStepSetDepthStencil(self.GetSwapChain().depthStencilBuffer)) else: self.RemoveStep('SET_SWAPCHAIN_RT') self.RemoveStep('SET_SWAPCHAIN_DEPTH') activePostProcessing = self.usePostProcessing and self.postProcessingJob.liveCount > 0 if customBackBuffer is not None: self.AddStep('SET_CUSTOM_RT', trinity.TriStepPushRenderTarget(customBackBuffer)) self.AddStep('SET_FINAL_RT', trinity.TriStepPopRenderTarget()) if self.msaaEnabled and not activePostProcessing: if self.hdrEnabled: self.AddStep('FINAL_BLIT', self._DoFormatConversionStep(blitTexture, customBackBuffer)) else: self.AddStep('FINAL_BLIT', trinity.TriStepResolve(self.GetBackBufferRenderTarget(), customBackBuffer)) elif self.hdrEnabled and not activePostProcessing and not self.msaaEnabled: self.AddStep('FINAL_BLIT', self._DoFormatConversionStep(customBackBuffer)) else: self.RemoveStep('FINAL_BLIT') if self.fxaaEnabled: self.AddStep('SET_VAR_GATHER', trinity.TriStepSetVariableStore('GatherMap', customBackBuffer)) self.RemoveStep('FINAL_BLIT') else: self.RemoveStep('SET_VAR_GATHER') else: self.RemoveStep('SET_CUSTOM_RT') self.RemoveStep('FINAL_BLIT') self.RemoveStep('SET_FINAL_RT') self.RemoveStep('SET_VAR_GATHER') if customDepthStencil is not None: self.AddStep('SET_DEPTH', trinity.TriStepPushDepthStencil(customDepthStencil)) self.AddStep('RESTORE_DEPTH', trinity.TriStepPopDepthStencil()) else: self.RemoveStep('RESTORE_DEPTH') if self.depthTexture is not None: if not self.doDepthPass: self.AddStep('SET_DEPTH', trinity.TriStepPushDepthStencil(depthTexture)) self.AddStep('RESTORE_DEPTH', trinity.TriStepPopDepthStencil()) self._SetDepthMap() self.AddStep('SET_VAR_DEPTH', trinity.TriStepSetVariableStore('DepthMap', depthTexture)) else: if not self.msaaEnabled: self.RemoveStep('SET_DEPTH') self.RemoveStep('RESTORE_DEPTH') self.RemoveStep('SET_VAR_DEPTH') self._RefreshPostProcessingJob(self.postProcessingJob, self.usePostProcessing and self.prepared) self._RefreshPostProcessingJob(self.distortionJob, self.distortionEffectsEnabled and self.prepared) self._RefreshPostProcessingJob(self.backgroundDistortionJob, self.distortionEffectsEnabled and self.prepared) if distortionTexture is not None: self.AddStep('DO_DISTORTIONS', trinity.TriStepRunJob(self.distortionJob)) distortionTriTextureRes = trinity.TriTextureRes() distortionTriTextureRes.SetFromRenderTarget(distortionTexture) self.distortionJob.SetPostProcessVariable('Distortion', 'TexDistortion', distortionTriTextureRes) self.backgroundDistortionJob.SetPostProcessVariable('Distortion', 'TexDistortion', distortionTriTextureRes) else: self.RemoveStep('DO_DISTORTIONS') self._CreateDepthPass()
def CreateScatterStep(renderJob, scene, append = True): step = trinity.TriStepRunJob() step.name = 'Subsurface scattering' step.job = trinity.CreateRenderJob('Render scattering') if append: renderJob.steps.append(step) SkinLightmapRenderer.renderJob = blue.BluePythonWeakRef(step.job) SkinLightmapRenderer.scene = blue.BluePythonWeakRef(scene) return step
def CreateShadowStep(renderJob, append = True): shadowStep = trinity.TriStepRunJob() shadowStep.name = 'Spotlight shadows' shadowStep.job = trinity.CreateRenderJob('Render shadowmaps') if append: renderJob.steps.append(shadowStep) SkinSpotLightShadows.renderJob = blue.BluePythonWeakRef(shadowStep.job) if SkinSpotLightShadows.instance is not None: SkinSpotLightShadows.instance.RefreshLights() return shadowStep
def _DoPostProcess(self, pp, source): job = trinity.TriRenderJob() job.name = 'Run Post Process ' + str(pp.name) self._AppendStep( 'Set var BlitOriginal', trinity.TriStepSetVariableStore('BlitOriginal', self.resolveTarget), job) self._AppendStep( 'Set var BlitCurrent', trinity.TriStepSetVariableStore('BlitCurrent', self.resolveTarget), job) pp.AddSteps(job) self._AppendStep(job.name, trinity.TriStepRunJob(job))
def _CreateDepthPass(self): rj = trinity.TriRenderJob() if self.enabled and self.doDepthPass and self.depthTexture is not None: rj.steps.append(trinity.TriStepPushViewport()) rj.steps.append(trinity.TriStepPushRenderTarget(self._GetRTForDepthPass())) rj.steps.append(trinity.TriStepPushDepthStencil(self.depthTexture)) rj.steps.append(trinity.TriStepPopViewport()) rj.steps.append(trinity.TriStepPushViewport()) rj.steps.append(trinity.TriStepRenderPass(self.GetScene(), trinity.TRIPASS_DEPTH_PASS)) rj.steps.append(trinity.TriStepPopDepthStencil()) rj.steps.append(trinity.TriStepPopRenderTarget()) rj.steps.append(trinity.TriStepPopViewport()) self.AddStep('RENDER_DEPTH_PASS', trinity.TriStepRunJob(rj))
def CreatePrefixSumJob(inputUav, outputUav, debugging=False, allowRecursion=True, folder='prefixsum'): NUM_ELEM = inputUav.numElements if NUM_ELEM & 3: return None NUM_THREAD_PER_BLOCK = 256 NUM_BLOCKS_PHASE1 = max(1, ((NUM_ELEM + 3) / 4 + NUM_THREAD_PER_BLOCK - 1) / NUM_THREAD_PER_BLOCK) fxPath = 'res:/graphics/effect/compute/' + folder + '/' phase1fx = trinity.Tr2Effect() phase1fx.effectFilePath = fxPath + 'phase1.fx' recurse = allowRecursion and NUM_BLOCKS_PHASE1 >= 1024 and NUM_BLOCKS_PHASE1 % 4 == 0 if not recurse: phase2fx = trinity.Tr2Effect() phase2fx.effectFilePath = fxPath + 'phase2.fx' phase3fx = trinity.Tr2Effect() phase3fx.effectFilePath = fxPath + 'phase3.fx' blue.resMan.Wait() if debugging: phase1fx.effectResource.Reload() if not recurse: phase2fx.effectResource.Reload() phase3fx.effectResource.Reload() blockOffsets = trinity.Tr2UavBuffer(NUM_BLOCKS_PHASE1, trinity.PIXEL_FORMAT.R32_UINT) blockOffsets.name = 'blockOffsets' phase1 = trinity.TriStepRunComputeShader(phase1fx, NUM_BLOCKS_PHASE1, 1) if recurse: summedBlockOffsets = trinity.Tr2UavBuffer( NUM_BLOCKS_PHASE1, trinity.PIXEL_FORMAT.R32_UINT) phase2 = CreatePrefixSumJob(blockOffsets, summedBlockOffsets, debugging) phase2 = trinity.TriStepRunJob(phase2) else: phase2 = trinity.TriStepRunComputeShader(phase2fx, 1, 1) phase3 = trinity.TriStepRunComputeShader(phase3fx, NUM_BLOCKS_PHASE1, 1) if debugging: phase1.logDispatchTime = True if not recurse: phase2.logDispatchTime = True phase3.logDispatchTime = True phase1.name = 'phase1' phase2.name = 'phase2' phase3.name = 'phase3' input4 = trinity.Tr2UavBuffer() input4.CreateAlias(inputUav, trinity.PIXEL_FORMAT.R32G32B32A32_UINT) input4.name = 'input4' rj = trinity.CreateRenderJob('PrefixSum') phase1.SetSrvBuffer(0, input4) phase1.SetUavBuffer(1, blockOffsets) phase1.autoClearUav = False phase1.autoResetUav = True if not recurse: phase2.SetUavBuffer(1, blockOffsets) phase2.autoClearUav = False phase2.autoResetUav = True phase3.SetSrvBuffer(0, input4) phase3.SetUavBuffer(1, blockOffsets if not recurse else summedBlockOffsets) phase3.SetUavBuffer(2, outputUav) phase3.autoClearUav = False phase3.autoResetUav = True rj.steps.append(phase1) rj.steps.append(phase2) rj.steps.append(phase3) return rj
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 SetCameraUpdate(self, job): self.AddStep('UPDATE_CAMERA', trinity.TriStepRunJob(job))
def EnablePostProcessing(self, enabled): if enabled: self.AddStep('RJ_POSTPROCESSING', trinity.TriStepRunJob(self.postProcessingJob)) else: self.RemoveStep('RJ_POSTPROCESSING')