def on_stage_setup(self):
if not NATIVE_CXX_LOADED:
self.debug("Setting max splits to 1 since python is used")
self._pipeline.plugin_mgr.settings["pssm"]["split_count"].set_value(1)
self.update_enabled = True
self.pta_sun_vector = PTAVecBase3f.empty_array(1)
self.last_cache_reset = 0
self.shadow_stage = self.create_stage(PSSMShadowStage)
self.pssm_stage = self.create_stage(PSSMStage)
self.shadow_stage.num_splits = self.get_setting("split_count")
self.shadow_stage.split_resolution = self.get_setting("resolution")
self.scene_stage = self.create_stage(PSSMSceneShadowStage)
self.scene_stage.resolution = self.get_setting("scene_shadow_resolution")
# Enable distant shadow map if specified
if self.get_setting("use_distant_shadows"):
self.dist_shadow_stage = self.create_stage(PSSMDistShadowStage)
self.dist_shadow_stage.resolution = self.get_setting("dist_shadow_resolution")
self.dist_shadow_stage.clip_size = self.get_setting("dist_shadow_clipsize")
self.pssm_stage.required_pipes.append("PSSMDistSunShadowMap")
self.pssm_stage.required_inputs.append("PSSMDistSunShadowMapMVP")
def on_stage_setup(self):
if not NATIVE_CXX_LOADED:
self.debug("Setting max splits to 1 since python is used")
self._pipeline.plugin_mgr.settings["pssm"][
"split_count"].set_value(1)
self.update_enabled = True
self.pta_sun_vector = PTAVecBase3f.empty_array(1)
self.last_cache_reset = 0
self.shadow_stage = self.create_stage(PSSMShadowStage)
self.pssm_stage = self.create_stage(PSSMStage)
self.shadow_stage.num_splits = self.get_setting("split_count")
self.shadow_stage.split_resolution = self.get_setting("resolution")
self.scene_shadow_stage = self.create_stage(PSSMSceneShadowStage)
self.scene_shadow_stage.resolution = self.get_setting(
"scene_shadow_resolution")
self.scene_shadow_stage.sun_distance = self.get_setting(
"scene_shadow_sundist")
# Enable distant shadow map if specified
if self.get_setting("use_distant_shadows"):
self.dist_shadow_stage = self.create_stage(PSSMDistShadowStage)
self.dist_shadow_stage.resolution = self.get_setting(
"dist_shadow_resolution")
self.dist_shadow_stage.clip_size = self.get_setting(
"dist_shadow_clipsize")
self.dist_shadow_stage.sun_distance = self.get_setting(
"dist_shadow_sundist")
self.pssm_stage.required_pipes.append("PSSMDistSunShadowMap")
self.pssm_stage.required_inputs.append("PSSMDistSunShadowMapMVP")
def _createInputHandles(self):
""" Defines various inputs to be used in the shader passes. Most inputs
use pta-arrays, so updating them is faster than using setShaderInput all the
time. """
self.cameraPosition = PTAVecBase3f.emptyArray(1)
self.currentViewMat = PTALMatrix4f.emptyArray(1)
self.currentProjMatInv = PTALMatrix4f.emptyArray(1)
self.lastMVP = PTALMatrix4f.emptyArray(1)
self.currentMVP = PTALMatrix4f.emptyArray(1)
self.frameIndex = PTAInt.emptyArray(1)
self.frameDelta = PTAFloat.emptyArray(1)
self.renderPassManager.registerStaticVariable("lastMVP", self.lastMVP)
self.renderPassManager.registerStaticVariable("currentMVP", self.currentMVP)
self.renderPassManager.registerStaticVariable("frameIndex", self.frameIndex)
self.renderPassManager.registerStaticVariable("cameraPosition", self.cameraPosition)
self.renderPassManager.registerStaticVariable("mainCam", self.showbase.cam)
self.renderPassManager.registerStaticVariable("mainRender", self.showbase.render)
self.renderPassManager.registerStaticVariable("frameDelta", self.frameDelta)
self.renderPassManager.registerStaticVariable("currentViewMat", self.currentViewMat)
self.renderPassManager.registerStaticVariable("currentProjMatInv", self.currentProjMatInv)
self.renderPassManager.registerStaticVariable("zeroVec2", Vec2(0))
self.renderPassManager.registerStaticVariable("zeroVec3", Vec3(0))
self.renderPassManager.registerStaticVariable("zeroVec4", Vec4(0))
self.transformMat = TransformState.makeMat(Mat4.convertMat(CSYupRight, CSZupRight))
def setup_stages(self):
self._update_enabled = True
self._pta_sun_vector = PTAVecBase3f.empty_array(1)
self._last_cache_reset = 0
self._shadow_stage = self.create_stage(PSSMShadowStage)
self._pssm_stage = self.create_stage(PSSMStage)
self._shadow_stage.set_num_splits(self.get_setting("split_count"))
self._shadow_stage.set_split_resolution(self.get_setting("resolution"))
def create(self):
""" Creates this pipeline """
self.debug("Setting up render pipeline")
if self.settings is None:
self.error("You have to call loadSettings first!")
return
self.debug("Analyzing system ..")
SystemAnalyzer.analyze()
self.debug("Checking required Panda3D version ..")
SystemAnalyzer.checkPandaVersionOutOfDate(01, 12, 2014)
# Mount everything first
self.mountManager.mount()
# Store globals, as cython can't handle them
self.debug("Setting up globals")
Globals.load(self.showbase)
Globals.font = loader.loadFont("Data/Font/SourceSansPro-Semibold.otf")
Globals.font.setPixelsPerUnit(25)
# Setting up shader loading
BetterShader._DumpShaders = self.settings.dumpGeneratedShaders
# We use PTA's for shader inputs, because that's faster than
# using setShaderInput
self.temporalProjXOffs = PTAInt.emptyArray(1)
self.cameraPosition = PTAVecBase3f.emptyArray(1)
self.motionBlurFactor = PTAFloat.emptyArray(1)
self.lastMVP = PTALMatrix4f.emptyArray(1)
self.currentMVP = PTALMatrix4f.emptyArray(1)
self.currentShiftIndex = PTAInt.emptyArray(1)
# Initialize variables
self.camera = self.showbase.cam
self.size = self._getSize()
self.cullBounds = None
# For the temporal reprojection it is important that the window width
# is a multiple of 2
if self.settings.enableTemporalReprojection and self.size.x % 2 == 1:
self.error(
"The window has to have a width which is a multiple of 2 "
"(Current: ", self.showbase.win.getXSize(), ")")
self.error(
"I'll correct that for you, but next time pass the correct "
"window size!")
wp = WindowProperties()
wp.setSize(self.showbase.win.getXSize() + 1,
self.showbase.win.getYSize())
self.showbase.win.requestProperties(wp)
self.showbase.graphicsEngine.openWindows()
# Get new size
self.size = self._getSize()
# Debug variables to disable specific features
self.haveLightingPass = True
# haveCombiner can only be true when haveLightingPass is enabled
self.haveCombiner = True
self.haveMRT = True
# Not as good as I want it, so disabled. I'll work on it.
self.blurEnabled = False
self.debug("Window size is", self.size.x, "x", self.size.y)
self.showbase.camLens.setNearFar(0.1, 50000)
self.showbase.camLens.setFov(90)
self.showbase.win.setClearColor(Vec4(1.0, 0.0, 1.0, 1.0))
# Create GI handler
if self.settings.enableGlobalIllumination:
self._setupGlobalIllumination()
# Create occlusion handler
self._setupOcclusion()
if self.settings.displayOnscreenDebugger:
self.guiManager = PipelineGuiManager(self)
self.guiManager.setup()
# Generate auto-configuration for shaders
self._generateShaderConfiguration()
# Create light manager, which handles lighting + shadows
if self.haveLightingPass:
self.lightManager = LightManager(self)
self.patchSize = LVecBase2i(self.settings.computePatchSizeX,
self.settings.computePatchSizeY)
# Create separate scene graphs. The deferred graph is render
self.forwardScene = NodePath("Forward-Rendering")
self.transparencyScene = NodePath("Transparency-Rendering")
self.transparencyScene.setBin("transparent", 30)
# We need no transparency (we store other information in the alpha
# channel)
self.showbase.render.setAttrib(
TransparencyAttrib.make(TransparencyAttrib.MNone), 100)
# Now create deferred render buffers
self._makeDeferredTargets()
# Create the target which constructs the view-space normals and
# position from world-space position
if self.occlusion.requiresViewSpacePosNrm():
self._createNormalPrecomputeBuffer()
if self.settings.enableGlobalIllumination:
self._creatGIPrecomputeBuffer()
# Setup the buffers for lighting
self._createLightingPipeline()
# Setup combiner for temporal reprojetion
if self.haveCombiner and self.settings.enableTemporalReprojection:
self._createCombiner()
if self.occlusion.requiresBlurring():
self._createOcclusionBlurBuffer()
self._setupAntialiasing()
if self.blurEnabled:
self._createDofStorage()
self._createBlurBuffer()
# Not sure why it has to be 0.25. But that leads to the best result
aspect = float(self.size.y) / self.size.x
self.onePixelShift = Vec2(0.125 / self.size.x, 0.125 / self.size.y /
aspect) * self.settings.jitterAmount
# Annoying that Vec2 has no multliply-operator for non-floats
multiplyVec2 = lambda a, b: Vec2(a.x * b.x, a.y * b.y)
if self.antialias.requiresJittering():
self.pixelShifts = [
multiplyVec2(self.onePixelShift, Vec2(-0.25, 0.25)),
multiplyVec2(self.onePixelShift, Vec2(0.25, -0.25))
]
else:
self.pixelShifts = [Vec2(0), Vec2(0)]
self.currentPixelShift = PTAVecBase2f.emptyArray(1)
self.lastPixelShift = PTAVecBase2f.emptyArray(1)
self._setupFinalPass()
self._setShaderInputs()
# Give the gui a hint when the pipeline is done loading
if self.settings.displayOnscreenDebugger:
self.guiManager.onPipelineLoaded()
# add update task
self._attachUpdateTask()
def create(self):
""" Creates this pipeline """
self.debug("Setting up render pipeline")
if self.settings is None:
self.error("You have to call loadSettings first!")
return
# Mount everything first
self.mountManager.mount()
# Store globals, as cython can't handle them
self.debug("Setting up globals")
Globals.load(self.showbase)
# Setting up shader loading
BetterShader._DumpShaders = self.settings.dumpGeneratedShaders
# We use PTA's for shader inputs, because that's faster than
# using setShaderInput
self.temporalProjXOffs = PTAInt.emptyArray(1)
self.cameraPosition = PTAVecBase3f.emptyArray(1)
self.motionBlurFactor = PTAFloat.emptyArray(1)
self.lastMVP = PTALMatrix4f.emptyArray(1)
self.currentMVP = PTALMatrix4f.emptyArray(1)
# Create onscreen gui
# For the temporal reprojection it is important that the window width
# is a multiple of 2
if self.showbase.win.getXSize() % 2 == 1:
self.error(
"The window has to have a width which is a multiple of 2 "
"(Current: ", self.showbase.win.getXSize(), ")")
self.error(
"I'll correct that for you, but next time pass the correct "
"window size!")
wp = WindowProperties()
wp.setSize(
self.showbase.win.getXSize() + 1, self.showbase.win.getYSize())
self.showbase.win.requestProperties(wp)
self.showbase.graphicsEngine.openWindows()
self.camera = self.showbase.cam
self.size = self._getSize()
self.cullBounds = None
# Debug variables to disable specific features
self.haveLightingPass = True
# haveCombiner can only be true when haveLightingPass is enabled
self.haveCombiner = True
self.haveMRT = True
# Not as good as I want it, so disabled. I'll work on it.
self.blurEnabled = False
self.debug("Window size is", self.size.x, "x", self.size.y)
self.showbase.camLens.setNearFar(0.1, 50000)
self.showbase.camLens.setFov(90)
self.showbase.win.setClearColor(Vec4(1.0,0.0,1.0,1.0))
# Create occlusion handler
self._setupOcclusion()
if self.settings.displayOnscreenDebugger:
self.guiManager = PipelineGuiManager(self)
self.guiManager.setup()
# Generate auto-configuration for shaders
self._generateShaderConfiguration()
# Create light manager, which handles lighting + shadows
if self.haveLightingPass:
self.lightManager = LightManager(self)
self.patchSize = LVecBase2i(
self.settings.computePatchSizeX,
self.settings.computePatchSizeY)
# Create separate scene graphs. The deferred graph is render
self.forwardScene = NodePath("Forward-Rendering")
self.transparencyScene = NodePath("Transparency-Rendering")
# We need no transparency (we store other information in the alpha
# channel)
self.showbase.render.setAttrib(
TransparencyAttrib.make(TransparencyAttrib.MNone), 100)
# Now create deferred render buffers
self._makeDeferredTargets()
# Create the target which constructs the view-space normals and
# position from world-space position
if self.occlusion.requiresViewSpacePosNrm():
self._createNormalPrecomputeBuffer()
# Setup the buffers for lighting
self._createLightingPipeline()
# Setup combiner for temporal reprojetion
if self.haveCombiner:
self._createCombiner()
if self.occlusion.requiresBlurring():
self._createOcclusionBlurBuffer()
self._setupAntialiasing()
if self.blurEnabled:
self._createDofStorage()
self._createBlurBuffer()
self._setupFinalPass()
self._setShaderInputs()
# add update task
self._attachUpdateTask()
def create(self):
""" Creates this pipeline """
self.debug("Setting up render pipeline")
if self.settings is None:
self.error("You have to call loadSettings first!")
return
self.debug("Analyzing system ..")
SystemAnalyzer.analyze()
self.debug("Checking required Panda3D version ..")
SystemAnalyzer.checkPandaVersionOutOfDate(7,8,2014)
# Mount everything first
self.mountManager.mount()
# Store globals, as cython can't handle them
self.debug("Setting up globals")
Globals.load(self.showbase)
Globals.font = loader.loadFont("Data/Font/SourceSansPro-Semibold.otf")
Globals.font.setPixelsPerUnit(25)
# Setting up shader loading
BetterShader._DumpShaders = self.settings.dumpGeneratedShaders
# We use PTA's for shader inputs, because that's faster than
# using setShaderInput
self.temporalProjXOffs = PTAInt.emptyArray(1)
self.cameraPosition = PTAVecBase3f.emptyArray(1)
self.motionBlurFactor = PTAFloat.emptyArray(1)
self.lastMVP = PTALMatrix4f.emptyArray(1)
self.currentMVP = PTALMatrix4f.emptyArray(1)
self.currentShiftIndex = PTAInt.emptyArray(1)
# Initialize variables
self.camera = self.showbase.cam
self.size = self._getSize()
self.cullBounds = None
# For the temporal reprojection it is important that the window width
# is a multiple of 2
if self.settings.enableTemporalReprojection and self.size.x % 2 == 1:
self.error(
"The window has to have a width which is a multiple of 2 "
"(Current: ", self.showbase.win.getXSize(), ")")
self.error(
"I'll correct that for you, but next time pass the correct "
"window size!")
wp = WindowProperties()
wp.setSize(
self.showbase.win.getXSize() + 1, self.showbase.win.getYSize())
self.showbase.win.requestProperties(wp)
self.showbase.graphicsEngine.openWindows()
# Get new size
self.size = self._getSize()
# Debug variables to disable specific features
self.haveLightingPass = True
# haveCombiner can only be true when haveLightingPass is enabled
self.haveCombiner = True
self.haveMRT = True
# Not as good as I want it, so disabled. I'll work on it.
self.blurEnabled = False
self.debug("Window size is", self.size.x, "x", self.size.y)
self.showbase.camLens.setNearFar(0.1, 50000)
self.showbase.camLens.setFov(115)
self.showbase.win.setClearColor(Vec4(1.0, 0.0, 1.0, 1.0))
# Create GI handleer
if self.settings.enableGlobalIllumination:
self._setupGlobalIllumination()
# Create occlusion handler
self._setupOcclusion()
if self.settings.displayOnscreenDebugger:
self.guiManager = PipelineGuiManager(self)
self.guiManager.setup()
# Generate auto-configuration for shaders
self._generateShaderConfiguration()
# Create light manager, which handles lighting + shadows
if self.haveLightingPass:
self.lightManager = LightManager(self)
self.patchSize = LVecBase2i(
self.settings.computePatchSizeX,
self.settings.computePatchSizeY)
# Create separate scene graphs. The deferred graph is render
self.forwardScene = NodePath("Forward-Rendering")
self.transparencyScene = NodePath("Transparency-Rendering")
self.transparencyScene.setBin("transparent", 30)
# We need no transparency (we store other information in the alpha
# channel)
self.showbase.render.setAttrib(
TransparencyAttrib.make(TransparencyAttrib.MNone), 100)
# Now create deferred render buffers
self._makeDeferredTargets()
# Create the target which constructs the view-space normals and
# position from world-space position
if self.occlusion.requiresViewSpacePosNrm():
self._createNormalPrecomputeBuffer()
# Setup the buffers for lighting
self._createLightingPipeline()
# Setup combiner for temporal reprojetion
if self.haveCombiner and self.settings.enableTemporalReprojection:
self._createCombiner()
if self.occlusion.requiresBlurring():
self._createOcclusionBlurBuffer()
self._setupAntialiasing()
if self.blurEnabled:
self._createDofStorage()
self._createBlurBuffer()
# Not sure why it has to be 0.25. But that leads to the best result
aspect = float(self.size.y) / self.size.x
self.onePixelShift = Vec2(
0.125 / self.size.x, 0.125 / self.size.y / aspect) * self.settings.jitterAmount
# Annoying that Vec2 has no multliply-operator for non-floats
multiplyVec2 = lambda a, b: Vec2(a.x*b.x, a.y*b.y)
if self.antialias.requiresJittering():
self.pixelShifts = [
multiplyVec2(self.onePixelShift, Vec2(-0.25, 0.25)),
multiplyVec2(self.onePixelShift, Vec2(0.25, -0.25))
]
else:
self.pixelShifts = [Vec2(0), Vec2(0)]
self.currentPixelShift = PTAVecBase2f.emptyArray(1)
self.lastPixelShift = PTAVecBase2f.emptyArray(1)
self._setupFinalPass()
self._setShaderInputs()
# add update task
self._attachUpdateTask()
