class ShadowedLightsPass(RenderPass):
""" This pass processes all lights which have shadows """
def __init__(self):
RenderPass.__init__(self)
def getID(self):
return "ShadowedLightsPass"
def getRequiredInputs(self):
return {
# Deferred target
"data0": "DeferredScenePass.data0",
"data1": "DeferredScenePass.data1",
"data2": "DeferredScenePass.data2",
"data3": "DeferredScenePass.data3",
"depth": "DeferredScenePass.depth",
# Lighting
"lightsPerTileBuffer": "LightCullingPass.lightsPerTile",
"lightingTileCount": "Variables.lightingTileCount",
"lights": "Variables.allLights",
"shadowAtlasPCF": "ShadowScenePass.atlasPCF",
"shadowAtlas": "ShadowScenePass.atlas",
"shadowSources": "Variables.allShadowSources",
"directionToFace": "Variables.directionToFaceLookup",
# IES Profiles
"IESProfilesTex": "Variables.IESProfilesTex",
"cameraPosition": "Variables.cameraPosition",
"mainCam": "Variables.mainCam",
"mainRender": "Variables.mainRender"
}
def create(self):
self.target = RenderTarget("Shadowed Lights")
self.target.addColorTexture()
self.target.setColorBits(16)
self.target.prepareOffscreenBuffer()
self.target.setClearColor()
def setShaders(self):
shader = Shader.load(Shader.SLGLSL,
"Shader/DefaultPostProcess.vertex",
"Shader/ShadowedLightsPass.fragment")
self.target.setShader(shader)
return [shader]
def getOutputs(self):
return {
"ShadowedLightsPass.resultTex": lambda: self.target.getColorTexture(),
}
class OcclusionBlurPass(RenderPass):
""" This pass performs a edge preserving blur by comparing the scene normals
during the blur pass, aswell as as bilateral upscaling the occlusion input. """
def __init__(self):
RenderPass.__init__(self)
def getID(self):
return "OcclusionBlurPass"
def getRequiredInputs(self):
return {
"sourceTex": "AmbientOcclusionPass.computeResult",
"normalTex": "DeferredScenePass.wsNormal",
}
def create(self):
self.targetV = RenderTarget("OcclusionBlurV")
self.targetV.addColorTexture()
self.targetV.setColorBits(16)
self.targetV.prepareOffscreenBuffer()
self.targetH = RenderTarget("OcclusionBlurH")
self.targetH.addColorTexture()
self.targetH.setColorBits(16)
self.targetH.prepareOffscreenBuffer()
self.targetH.setShaderInput("processedSourceTex", self.targetV.getColorTexture())
def setShaders(self):
shaderV = Shader.load(Shader.SLGLSL,
"Shader/DefaultPostProcess.vertex",
"Shader/OcclusionBlurV.fragment")
self.targetV.setShader(shaderV)
shaderH = Shader.load(Shader.SLGLSL,
"Shader/DefaultPostProcess.vertex",
"Shader/OcclusionBlurH.fragment")
self.targetH.setShader(shaderH)
return [shaderV, shaderH]
def getOutputs(self):
return {
"OcclusionBlurPass.blurResult": lambda: self.targetH.getColorTexture(),
}
def setShaderInput(self, name, value):
self.targetH.setShaderInput(name, value)
self.targetV.setShaderInput(name, value)
class TransparencyPass(RenderPass):
""" This pass reads the per pixel linked lists generated during the deferred
scene pass and applies them to the rendered image. To sort the lists a bubble
sort algorithm is used """
def __init__(self):
RenderPass.__init__(self)
def getID(self):
return "TransparencyPass"
def getRequiredInputs(self):
return {
"sceneTex": "LightingPass.resultTex",
"cameraPosition": "Variables.cameraPosition",
"currentMVP": "Variables.currentMVP",
"positionTex": "DeferredScenePass.wsPosition",
"mainCam": "Variables.mainCam",
"mainRender": "Variables.mainRender",
"fallbackCubemap": "Variables.defaultEnvironmentCubemap",
"fallbackCubemapMipmaps": "Variables.defaultEnvironmentCubemapMipmaps",
"depthTex": "DeferredScenePass.depth",
"pixelCountBuffer": "Variables.transpPixelCountBuffer",
"spinLockBuffer": "Variables.transpSpinLockBuffer",
"listHeadBuffer": "Variables.transpListHeadBuffer",
"materialDataBuffer": "Variables.transpMaterialDataBuffer",
}
def setShaders(self):
shader = Shader.load(Shader.SLGLSL,
"Shader/DefaultPostProcess.vertex",
"Shader/TransparencyPass.fragment")
self.target.setShader(shader)
return [shader]
def create(self):
self.target = RenderTarget("TransparencyPass")
self.target.addColorTexture()
self.target.setColorBits(16)
self.target.prepareOffscreenBuffer()
def getOutputs(self):
return {
"TransparencyPass.resultTex": lambda: self.target.getColorTexture(),
}
class GlobalIlluminationPass(RenderPass):
""" This pass performs voxel cone tracing over the previously generated
voxel grid to compute a diffuse, specular and ambient term which can be
used later in the lighting pass """
def __init__(self):
RenderPass.__init__(self)
def getID(self):
return "GlobalIlluminationPass"
def getRequiredInputs(self):
return {
"data0": "DeferredScenePass.data0",
"data1": "DeferredScenePass.data1",
"data2": "DeferredScenePass.data2",
"data3": "DeferredScenePass.data3",
"giData": "Variables.giVoxelGridData",
"cameraPosition": "Variables.cameraPosition",
"mainCam": "Variables.mainCam",
"mainRender": "Variables.mainRender"
}
def create(self):
self.target = RenderTarget("GlobalIlluminationPass")
self.target.setHalfResolution()
self.target.addColorTexture()
self.target.addAuxTexture()
self.target.setColorBits(16)
self.target.setAuxBits(16)
self.target.prepareOffscreenBuffer()
def setShaders(self):
shader = Shader.load(Shader.SLGLSL,
"Shader/DefaultPostProcess.vertex",
"Shader/ComputeGI.fragment")
self.target.setShader(shader)
return [shader]
def getOutputs(self):
return {
"GlobalIlluminationPass.diffuseResult": lambda: self.target.getColorTexture(),
"GlobalIlluminationPass.specularResult": lambda: self.target.getAuxTexture(0)
}
class ScatteringPass(RenderPass):
""" This pass computes the scattering if specified in the settings """
def __init__(self):
RenderPass.__init__(self)
def getID(self):
return "ScatteringPass"
def getRequiredInputs(self):
return {
# Scattering
"transmittanceSampler": ["Variables.transmittanceSampler", "Variables.emptyTextureWhite"],
"inscatterSampler": ["Variables.inscatterSampler", "Variables.emptyTextureWhite"],
"scatteringOptions": ["Variables.scatteringOptions", "Variables.null"],
"mainRender": "Variables.mainRender",
"cameraPosition": "Variables.cameraPosition",
"mainCam": "Variables.mainCam",
"wsPositionTex": "DeferredScenePass.wsPosition",
"basecolorTex": "DeferredScenePass.data3"
# "viewSpaceNormals": "ViewSpacePass.normals",
# "viewSpacePosition": "ViewSpacePass.position"
}
def create(self):
self.target = RenderTarget("Scattering")
self.target.addColorTexture()
self.target.setColorBits(16)
self.target.prepareOffscreenBuffer()
def setShaders(self):
shader = Shader.load(Shader.SLGLSL,
"Shader/DefaultPostProcess.vertex",
"Shader/ScatteringPass.fragment")
self.target.setShader(shader)
return [shader]
def getOutputs(self):
return {
"ScatteringPass.resultTex": lambda: self.target.getColorTexture(),
}
import os
import direct.directbase.DirectStart
from Code.Globals import Globals
Globals.load(base)
from Code.RenderTarget import RenderTarget
import shutil
sz = 2048
target = RenderTarget()
target.setSize(sz, sz)
target.addColorTexture()
target.setColorBits(16)
target.prepareOffscreenBuffer()
vertex_shader = """
#version 400
uniform mat4 p3d_ModelViewProjectionMatrix;
in vec4 p3d_Vertex;
out vec2 texcoord;
void main() {
gl_Position = vec4(p3d_Vertex.x, p3d_Vertex.z, 0, 1);
texcoord = sign(p3d_Vertex.xz * 0.5 + 0.5);
}
"""
import direct.directbase.DirectStart
from Code.Globals import Globals
Globals.load(base)
from Code.RenderTarget import RenderTarget
import shutil
sz = 2048
target = RenderTarget()
target.setSize(sz, sz)
target.addColorTexture()
target.setColorBits(16)
target.prepareOffscreenBuffer()
vertex_shader = """
#version 400
uniform mat4 p3d_ModelViewProjectionMatrix;
in vec4 p3d_Vertex;
out vec2 texcoord;
void main() {
gl_Position = vec4(p3d_Vertex.x, p3d_Vertex.z, 0, 1);
texcoord = sign(p3d_Vertex.xz * 0.5 + 0.5);
}
"""
