def prepareOffscreenBuffer(self):
""" Creates an offscreen buffer for this target """
self.debug("Preparing offscreen buffer")
# Init buffer object
self._createBuffer()
# Prepare fullscreen quad
self._node = NodePath("RTRoot")
self._quad = self._makeFullscreenQuad()
self._quad.reparentTo(self._node)
# Prepare fullscreen camera
bufferCam = self._makeFullscreenCam()
initialState = NodePath("is")
if not self._writeColor:
initialState.setAttrib(
ColorWriteAttrib.make(ColorWriteAttrib.COff), 1000)
initialState.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MNone),
1000)
bufferCam.setInitialState(initialState.getState())
self._camera = self._node.attachNewNode(bufferCam)
bufferRegion = self._internalBuffer.getDisplayRegion(0)
bufferRegion.setCamera(self._camera)
bufferRegion.setActive(1)
self._setSizeShaderInput()
self._active = True
self._registerBuffer()
def registerTagState(self, name, state):
""" Registers a new tag state """
state.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
initialState = state.getState()
for camera in self.shadowCameras:
camera.node().setTagState(name, initialState)
def create(self):
winprops = WindowProperties.size(self.size, self.size)
props = FrameBufferProperties()
props.setRgbColor(0)
props.setAlphaBits(0)
props.setDepthBits(1)
self.buffer = base.graphicsEngine.makeOutput(
base.pipe, "shadowsBuffer", -2, props, winprops,
GraphicsPipe.BFRefuseWindow, base.win.getGsg(), base.win)
if not self.buffer:
print("Video driver cannot create an offscreen buffer.")
return
self.depthmap = Texture()
self.buffer.addRenderTexture(self.depthmap,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
self.depthmap.setMinfilter(Texture.FTShadow)
self.depthmap.setMagfilter(Texture.FTShadow)
self.depthmap.setBorderColor(LColor(1, 1, 1, 1))
self.depthmap.setWrapU(Texture.WMBorderColor)
self.depthmap.setWrapV(Texture.WMBorderColor)
self.cam = base.makeCamera(self.buffer, lens=OrthographicLens())
self.cam.reparent_to(render)
self.node = self.cam.node()
self.node.setInitialState(
RenderState.make(
CullFaceAttrib.make_reverse(),
ColorWriteAttrib.make(ColorWriteAttrib.M_none),
))
self.node.setScene(render)
if settings.debug_shadow_frustum:
self.node.showFrustum()
def prepareOffscreenBuffer(self):
""" Creates an offscreen buffer for this target """
self.debug("Preparing offscreen buffer")
# Init buffer object
self._createBuffer()
# Prepare fullscreen quad
self._quad = self._makeFullscreenQuad()
# Prepare fullscreen camera
bufferCam = self._makeFullscreenCam()
initialState = NodePath("is")
if not self._writeColor:
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 1000)
initialState.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MNone), 1000)
bufferCam.setInitialState(initialState.getState())
bufferCamNode = self._quad.attachNewNode(bufferCam)
bufferRegion = self._buffer.getInternalBuffer().getDisplayRegion(0)
bufferRegion.setCamera(bufferCamNode)
bufferRegion.setActive(1)
self._setSizeShaderInput()
def registerTagState(self, name, state):
""" Registers a new tag state """
state.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
initialState = state.getState()
for camera in self.shadowCameras:
camera.node().setTagState(name, initialState)
def create(self):
# Create the voxel grid used to store the voxels
self._voxel_grid = Image.create_3d(
"Voxels", self._voxel_res, self._voxel_res, self._voxel_res, Texture.T_float, Texture.F_r11_g11_b10
)
self._voxel_grid.set_clear_color(Vec4(0))
# Create the camera for voxelization
self._voxel_cam = Camera("VoxelizeCam")
self._voxel_cam.set_camera_mask(self._pipeline.tag_mgr.get_voxelize_mask())
self._voxel_cam_lens = OrthographicLens()
self._voxel_cam_lens.set_film_size(-self._voxel_ws, self._voxel_ws)
self._voxel_cam_lens.set_near_far(0.0, 2.0 * self._voxel_ws)
self._voxel_cam.set_lens(self._voxel_cam_lens)
self._voxel_cam_np = Globals.base.render.attach_new_node(self._voxel_cam)
self._pipeline.tag_mgr.register_voxelize_camera(self._voxel_cam)
# Create the voxelization target
self._voxel_target = self._create_target("VoxelizeScene")
self._voxel_target.set_source(source_cam=self._voxel_cam_np, source_win=Globals.base.win)
self._voxel_target.set_size(self._voxel_res, self._voxel_res)
self._voxel_target.set_create_overlay_quad(False)
self._voxel_target.prepare_scene_render()
# Create the initial state used for rendering voxels
initial_state = NodePath("VXInitialState")
initial_state.set_attrib(CullFaceAttrib.make(CullFaceAttrib.M_cull_none), 100000)
initial_state.set_attrib(DepthTestAttrib.make(DepthTestAttrib.M_none), 100000)
initial_state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 100000)
self._voxel_cam.set_initial_state(initial_state.get_state())
Globals.base.render.set_shader_input("voxelGridPosition", self._pta_grid_pos)
Globals.base.render.set_shader_input("voxelGridRes", self._pta_grid_res)
Globals.base.render.set_shader_input("voxelGridSize", self._pta_grid_size)
Globals.base.render.set_shader_input("VoxelGridDest", self._voxel_grid.texture)
def setEffect(self, obj, effect, properties = None, sort=0):
""" Applies the effect to an object with the given properties """
effect = self.effectLoader.loadEffect(effect, properties)
if effect.getSetting("transparent"):
pass
if effect.getSetting("dynamic"):
self.registerDynamicObject(obj)
if not effect.getSetting("castShadows"):
obj.hide(self.getShadowPassBitmask())
if not effect.getSetting("castGI"):
obj.hide(self.getVoxelizePassBitmask())
obj.setShader(effect.getShader("Default"), sort)
# Create shadow caster state
if effect.getSetting("castShadows"):
initialState = NodePath("EffectInitialState"+str(effect.getEffectID()))
initialState.setShader(effect.getShader("Shadows"), sort + 20)
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
stateName = "NodeEffect" + str(effect.getEffectID())
self.lightManager.shadowPass.registerTagState(stateName, initialState.getState())
obj.setTag("ShadowPassShader", stateName)
def register_camera(self, container, source):
source.set_tag_state_key(container.tag_name)
source.set_camera_mask(container.mask)
state = RenderState.make_empty()
state = state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
source.set_initial_state(state)
container.cameras.append(source)
def apply_state(self, container, np, shader, name, sort):
state = RenderState.make_empty()
state = state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
state = state.set_attrib(ShaderAttrib.make(shader, sort), sort)
container.tag_states[name] = state
np.set_tag(container.tag_name, name)
for camera in container.cameras:
camera.set_tag_state(name, state)
def register_camera(self, container_name, source):
container = self.containers[container_name]
source.set_tag_state_key(container.tag_name)
source.set_camera_mask(container.mask)
state = RenderState.make_empty()
if not container.write_color:
state = state.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
source.set_initial_state(state)
container.cameras.append(source)
def setShaders(self):
casterShader = Shader.load(Shader.SLGLSL,
"Shader/DefaultShaders/ShadowCasting/vertex.glsl",
"Shader/DefaultShaders/ShadowCasting/fragment.glsl")
initialState = NodePath("ShadowCasterState")
initialState.setShader(casterShader, 100)
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
for camera in self.shadowCameras:
camera.node().setTagState("Default", initialState.getState())
casterShaderTransparent = Shader.load(Shader.SLGLSL,
"Shader/DefaultShaders/TransparentShadowCasting/vertex.glsl",
"Shader/DefaultShaders/TransparentShadowCasting/fragment.glsl")
initialState = NodePath("ShadowCasterStateTransparent")
initialState.setShader(casterShaderTransparent, 100)
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
for camera in self.shadowCameras:
camera.node().setTagState("Transparent", initialState.getState())
return [casterShader, casterShaderTransparent]
def create_stencil(self):
stencil = self.node_path.attachNewNode(self.make_circle(100))
stencil.reparentTo(self.camera)
stencil.setPos(0, 5, 0)
stencil.node().setAttrib(constant_one_stencil)
stencil.hide(BitMask32.bit(0))
stencil.node().setAttrib(ColorWriteAttrib.make(0))
stencil.setBin('background', 0)
stencil.setDepthWrite(0)
# self.node_path.node().setAttrib(stencil_reader)
return stencil
def _create_buffer(self):
""" Internal method to create the buffer object """
self._compute_size_from_constraint()
if not self._create():
self.error("Failed to create buffer!")
return False
if self.create_default_region:
self._source_region = PostProcessRegion.make(self._internal_buffer)
if max(self._color_bits) == 0:
self._source_region.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.M_none), 1000)
def registerEarlyZTagState(self, name, state):
""" Registers a new tag state """
if not self.prepassCam:
return
# state.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullClockwise), 10000)
state.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 10000)
state.setAttrib(AlphaTestAttrib.make(AlphaTestAttrib.MNone, 1.0), 10000)
state.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOn), 10000)
state.setAttrib(DepthTestAttrib.make(DepthTestAttrib.MLess), 10000)
state.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone), 10000)
self.prepassCam.setTagState(name, state.getState())
def _createTagStates(self):
# Create shadow caster shader
self.shadowCasterShader = BetterShader.load(
"Shader/DefaultShadowCaster/vertex.glsl",
"Shader/DefaultShadowCaster/fragment.glsl",
"Shader/DefaultShadowCaster/geometry.glsl")
initialState = NodePath("ShadowCasterState")
initialState.setShader(self.shadowCasterShader, 30)
# initialState.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
self.shadowComputeCamera.setTagState(
"Default", initialState.getState())
def _create_buffer(self):
""" Internal method to create the buffer object """
self._compute_size_from_constraint()
if not self._create():
self.error("Failed to create buffer!")
return False
if self.create_default_region:
self._source_region = PostProcessRegion.make(self._internal_buffer)
if max(self._color_bits) == 0:
self._source_region.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.M_none), 1000)
def apply_state(self, container_name, np, shader, name, sort):
assert shader
state = RenderState.make_empty()
container = self.containers[container_name]
if not container.write_color:
state = state.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.C_off), 10000)
state = state.set_attrib(ShaderAttrib.make(shader, sort), sort)
container.tag_states[name] = state
np.set_tag(container.tag_name, name)
for camera in container.cameras:
camera.set_tag_state(name, state)
def registerEarlyZTagState(self, name, state):
""" Registers a new tag state """
if not self.prepassCam:
return
# state.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullClockwise), 10000)
state.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 10000)
state.setAttrib(AlphaTestAttrib.make(AlphaTestAttrib.MNone, 1.0),
10000)
state.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOn), 10000)
state.setAttrib(DepthTestAttrib.make(DepthTestAttrib.MLess), 10000)
state.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone),
10000)
self.prepassCam.setTagState(name, state.getState())
def createWorld(self, task=None):
self.sky.clearAttrib(TransparencyAttrib)
self.deskNP.reparentTo(self.base.render)
self.deskNP.setScale(7.5)
self.deskNP.setPos(0, -5, -6.5)
# make a box that clips content under the desk (e.g. the paper)
bb = self.deskNP.getTightBounds()
sz = (bb[1]-bb[0]) * 0.8
self.underDeskClip = self.base.loader.loadModel('box')
self.underDeskClip.setScale(sz)
self.underDeskClip.reparentTo(self.base.render)
self.underDeskClip.setPos(-sz.x/2, -sz.y*1.1, -sz.z*0.73)
if False:
# --> nope, this actually hides everything the camera might see
self.newBin = CullBinManager.getGlobalPtr().addBin('foo', CullBinManager.BT_state_sorted, -50)
# make the box obscure geometry "inside" it
self.underDeskClip.setAttrib(ColorWriteAttrib.make(False))
self.underDeskClip.setDepthWrite(True)
self.underDeskClip.setBin('foo', -50)
else:
bb = self.underDeskClip.getTightBounds()
self.underDeskClip.removeNode()
self.typewriterNP.reparentTo(self.base.render)
self.typewriterNP.setHpr(0, 0, 0)
self.typewriterNP.setScale(5)
self.base.camera.setPos(0, -25, 5)
self.cameraTarget = Point3(0, -9.5, 7.5)
#self.cameraTarget = Point3(0, -25, 2.5)
self.cameraHprTarget = Point3(0, -19.5, 0)
self.typewriterTarget = Point3(0, -2.5, 2.666)
self.typewriterStart = Point3(0, -5, 10)
if not self.skipIntro:
self.animateArrival()
else:
self.activateTypewriter()
def createWorld(self, task=None):
self.sky.clearAttrib(TransparencyAttrib)
self.deskNP.reparentTo(self.base.render)
self.deskNP.setScale(7.5)
self.deskNP.setPos(0, -5, -6.5)
# make a box that clips content under the desk (e.g. the paper)
bb = self.deskNP.getTightBounds()
sz = (bb[1] - bb[0]) * 0.8
self.underDeskClip = self.base.loader.loadModel('box')
self.underDeskClip.setScale(sz)
self.underDeskClip.reparentTo(self.base.render)
self.underDeskClip.setPos(-sz.x / 2, -sz.y * 1.1, -sz.z * 0.73)
if False:
# --> nope, this actually hides everything the camera might see
self.newBin = CullBinManager.getGlobalPtr().addBin(
'foo', CullBinManager.BT_state_sorted, -50)
# make the box obscure geometry "inside" it
self.underDeskClip.setAttrib(ColorWriteAttrib.make(False))
self.underDeskClip.setDepthWrite(True)
self.underDeskClip.setBin('foo', -50)
else:
bb = self.underDeskClip.getTightBounds()
self.underDeskClip.removeNode()
self.typewriterNP.reparentTo(self.base.render)
self.typewriterNP.setHpr(0, 0, 0)
self.typewriterNP.setScale(5)
self.base.camera.setPos(0, -25, 5)
self.cameraTarget = Point3(0, -9.5, 7.5)
#self.cameraTarget = Point3(0, -25, 2.5)
self.cameraHprTarget = Point3(0, -19.5, 0)
self.typewriterTarget = Point3(0, -2.5, 2.666)
self.typewriterStart = Point3(0, -5, 10)
if not self.skipIntro:
self.animateArrival()
else:
self.activateTypewriter()
def prepare_render(self, camera_np):
""" Prepares to render a scene """
self.create_default_region = False
self._create_buffer()
self._source_region = self._internal_buffer.get_display_region(0)
if camera_np:
initial_state = NodePath("rtis")
initial_state.set_state(camera_np.node().get_initial_state())
if self._aux_count:
initial_state.set_attrib(
AuxBitplaneAttrib.make(self._aux_bits), 20)
initial_state.set_attrib(
TransparencyAttrib.make(TransparencyAttrib.M_none), 20)
if max(self._color_bits) == 0:
initial_state.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.C_off), 20)
# Disable existing regions of the camera
for region in camera_np.node().get_display_regions():
region.set_active(False)
# Remove the existing display region of the camera
for region in self._source_window.get_display_regions():
if region.get_camera() == camera_np:
self._source_window.remove_display_region(region)
camera_np.node().set_initial_state(initial_state.get_state())
self._source_region.set_camera(camera_np)
self._internal_buffer.disable_clears()
self._source_region.disable_clears()
self._source_region.set_active(True)
self._source_region.set_sort(20)
# Reenable depth-clear, usually desireable
self._source_region.set_clear_depth_active(True)
self._source_region.set_clear_depth(1.0)
self._active = True
def _create_buffer(self):
""" Internal method to create the buffer object """
if self._source_window == Globals.base.win:
w, h = Globals.resolution.x, Globals.resolution.y
else:
w, h = self._source_window.get_x_size(), self._source_window.get_y_size()
if self._size.x < 0:
self._size.x = (w - self._size.x - 1) // (-self._size.x)
if self._size.y < 0:
self._size.y = (h - self._size.y - 1) // (-self._size.y)
if not self._create():
self.error("Failed to create buffer!")
return False
if self.create_default_region:
self._source_region = PostProcessRegion.make(self._internal_buffer)
if max(self._color_bits) == 0:
self._source_region.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.M_none), 1000)
def prepare_render(self, camera_np):
""" Prepares to render a scene """
self.create_default_region = False
self._create_buffer()
self._source_region = self._internal_buffer.get_display_region(0)
if camera_np:
initial_state = NodePath("rtis")
initial_state.set_state(camera_np.node().get_initial_state())
if self._aux_count:
initial_state.set_attrib(AuxBitplaneAttrib.make(self._aux_bits), 20)
initial_state.set_attrib(TransparencyAttrib.make(TransparencyAttrib.M_none), 20)
if max(self._color_bits) == 0:
initial_state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 20)
# Disable existing regions of the camera
for region in camera_np.node().get_display_regions():
region.set_active(False)
# Remove the existing display region of the camera
for region in self._source_window.get_display_regions():
if region.get_camera() == camera_np:
self._source_window.remove_display_region(region)
camera_np.node().set_initial_state(initial_state.get_state())
self._source_region.set_camera(camera_np)
self._internal_buffer.disable_clears()
self._source_region.disable_clears()
self._source_region.set_active(True)
self._source_region.set_sort(20)
# Reenable depth-clear, usually desireable
self._source_region.set_clear_depth_active(True)
self._source_region.set_clear_depth(1.0)
self._active = True
def _create_buffer(self):
""" Internal method to create the buffer object """
if self._source_window == Globals.base.win:
w, h = Globals.resolution.x, Globals.resolution.y
else:
w, h = self._source_window.get_x_size(
), self._source_window.get_y_size()
if self._size.x < 0:
self._size.x = (w - self._size.x - 1) // (-self._size.x)
if self._size.y < 0:
self._size.y = (h - self._size.y - 1) // (-self._size.y)
if not self._create():
self.error("Failed to create buffer!")
return False
if self.create_default_region:
self._source_region = PostProcessRegion.make(self._internal_buffer)
if max(self._color_bits) == 0:
self._source_region.set_attrib(
ColorWriteAttrib.make(ColorWriteAttrib.M_none), 1000)
def setEffect(self, obj, effect, properties = None, sort=0):
""" Applies the effect to an object with the given properties """
effect = self.effectLoader.loadEffect(effect, properties)
if effect.getSetting("transparent"):
if not self.settings.useTransparency:
self.error("Cannot assign transparent material when transparency is disabled")
return False
if effect.getSetting("dynamic"):
self.registerDynamicObject(obj)
if not effect.getSetting("castShadows"):
obj.hide(self.getShadowPassBitmask())
if not effect.getSetting("castGI"):
obj.hide(self.getVoxelizePassBitmask())
if not effect.getSetting("mainPass"):
obj.hide(self.getMainPassBitmask())
effect.assignNode(obj, "Default", sort)
# Create shadow caster state
if effect.getSetting("castShadows"):
initialState = NodePath("EffectInitialState"+str(effect.getEffectID()))
initialState.setShader(effect.getShader("Shadows"), sort + 20)
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
# Fix for the shadowed terrain. Initial state doesn't seem to work with instancing
# initialState.setInstanceCount(500)
stateName = "NodeEffect" + str(effect.getEffectID())
self.lightManager.shadowPass.registerTagState(stateName, initialState.getState())
obj.setTag("ShadowPassShader", stateName)
def create(self):
# Create the atlas target
self.target = RenderTarget("ShadowAtlas")
self.target.setSize(self.size)
self.target.addDepthTexture()
self.target.setDepthBits(32)
self.target.setColorWrite(False)
self.target.setCreateOverlayQuad(False)
# self.target.setActive(False)
self.target.setSource(
NodePath(Camera("tmp")), Globals.base.win)
self.target.prepareSceneRender()
self.target.setClearDepth(False)
# Set the appropriate filter modes
dTex = self.target.getDepthTexture()
dTex.setWrapU(SamplerState.WMClamp)
dTex.setWrapV(SamplerState.WMClamp)
# Remove the default postprocess quad
# self.target.getQuad().node().removeAllChildren()
# self.target.getInternalRegion().setSort(-200)
self.target.getInternalRegion().disableClears()
self.target.getInternalBuffer().disableClears()
# self.target.getInternalBuffer().setSort(-300)
# Create default initial state
initialState = NodePath("InitialState")
initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff))
# Create a camera for each update
self.shadowCameras = []
for i in xrange(self.maxRegions):
shadowCam = Camera("ShadowComputeCamera")
shadowCam.setTagStateKey("ShadowPassShader")
shadowCam.setInitialState(initialState.getState())
shadowCam.setCameraMask(BitMask32.bit(3))
shadowCamNode = self.shadowScene.attachNewNode(shadowCam)
self.shadowCameras.append(shadowCamNode)
# Create regions
self.renderRegions = []
buff = self.target.getInternalBuffer()
for i in xrange(self.maxRegions):
dr = buff.makeDisplayRegion()
dr.setSort(1000)
dr.setClearDepthActive(True)
dr.setClearDepth(1.0)
# dr.setClearColorActive(False)
# dr.setClearColor(Vec4(1,1,1,1))
dr.setCamera(self.shadowCameras[i])
dr.setActive(False)
self.renderRegions.append(dr)
self.pcfSampleState = SamplerState()
self.pcfSampleState.setMinfilter(SamplerState.FTShadow)
self.pcfSampleState.setMagfilter(SamplerState.FTShadow)
self.pcfSampleState.setWrapU(SamplerState.WMClamp)
self.pcfSampleState.setWrapV(SamplerState.WMClamp)
def create(self):
# Create the voxel grid used to generate the voxels
self.voxel_temp_grid = Image.create_3d("VoxelsTemp",
self.voxel_resolution,
self.voxel_resolution,
self.voxel_resolution, "RGBA8")
self.voxel_temp_grid.set_clear_color(Vec4(0))
self.voxel_temp_nrm_grid = Image.create_3d("VoxelsTemp",
self.voxel_resolution,
self.voxel_resolution,
self.voxel_resolution,
"R11G11B10")
self.voxel_temp_nrm_grid.set_clear_color(Vec4(0))
# Create the voxel grid which is a copy of the temporary grid, but stable
self.voxel_grid = Image.create_3d("Voxels", self.voxel_resolution,
self.voxel_resolution,
self.voxel_resolution, "RGBA8")
self.voxel_grid.set_clear_color(Vec4(0))
self.voxel_grid.set_minfilter(SamplerState.FT_linear_mipmap_linear)
# Create the camera for voxelization
self.voxel_cam = Camera("VoxelizeCam")
self.voxel_cam.set_camera_mask(
self._pipeline.tag_mgr.get_voxelize_mask())
self.voxel_cam_lens = OrthographicLens()
self.voxel_cam_lens.set_film_size(-2.0 * self.voxel_world_size,
2.0 * self.voxel_world_size)
self.voxel_cam_lens.set_near_far(0.0, 2.0 * self.voxel_world_size)
self.voxel_cam.set_lens(self.voxel_cam_lens)
self.voxel_cam_np = Globals.base.render.attach_new_node(self.voxel_cam)
self._pipeline.tag_mgr.register_camera("voxelize", self.voxel_cam)
# Create the voxelization target
self.voxel_target = self.create_target("VoxelizeScene")
self.voxel_target.size = self.voxel_resolution
self.voxel_target.prepare_render(self.voxel_cam_np)
# Create the target which copies the voxel grid
self.copy_target = self.create_target("CopyVoxels")
self.copy_target.size = self.voxel_resolution
self.copy_target.prepare_buffer()
# TODO! Does not work with the new render target yet - maybe add option
# to post process region for instances?
self.copy_target.instance_count = self.voxel_resolution
self.copy_target.set_shader_input("SourceTex", self.voxel_temp_grid)
self.copy_target.set_shader_input("DestTex", self.voxel_grid)
# Create the target which generates the mipmaps
self.mip_targets = []
mip_size, mip = self.voxel_resolution, 0
while mip_size > 1:
mip_size, mip = mip_size // 2, mip + 1
mip_target = self.create_target("GenMipmaps:" + str(mip))
mip_target.size = mip_size
mip_target.prepare_buffer()
mip_target.instance_count = mip_size
mip_target.set_shader_input("SourceTex", self.voxel_grid)
mip_target.set_shader_input("sourceMip", mip - 1)
mip_target.set_shader_input("DestTex", self.voxel_grid, False,
True, -1, mip, 0)
self.mip_targets.append(mip_target)
# Create the initial state used for rendering voxels
initial_state = NodePath("VXGIInitialState")
initial_state.set_attrib(
CullFaceAttrib.make(CullFaceAttrib.M_cull_none), 100000)
initial_state.set_attrib(DepthTestAttrib.make(DepthTestAttrib.M_none),
100000)
initial_state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off),
100000)
self.voxel_cam.set_initial_state(initial_state.get_state())
Globals.base.render.set_shader_input("voxelGridPosition",
self.pta_next_grid_pos)
Globals.base.render.set_shader_input("VoxelGridDest",
self.voxel_temp_grid)
def __init__(self, pipeline):
""" Creates a new LightManager. It expects a RenderPipeline as parameter. """
DebugObject.__init__(self, "LightManager")
self._initArrays()
self.pipeline = pipeline
self.settings = pipeline.getSettings()
# Create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.queuedShadowUpdates = []
self.allLightsArray = ShaderStructArray(Light, self.maxTotalLights)
self.cullBounds = None
self.shadowScene = Globals.render
# Create atlas
self.shadowAtlas = ShadowAtlas()
self.shadowAtlas.setSize(self.settings.shadowAtlasSize)
self.shadowAtlas.create()
self.maxShadowMaps = 24
self.maxShadowUpdatesPerFrame = self.settings.maxShadowUpdatesPerFrame
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowMaps)
# Create shadow compute buffer
self._createShadowComputationBuffer()
# Create the initial shadow state
self.shadowComputeCamera.setTagStateKey("ShadowPassShader")
self.shadowComputeCamera.setInitialState(RenderState.make(
ColorWriteAttrib.make(ColorWriteAttrib.C_off),
DepthWriteAttrib.make(DepthWriteAttrib.M_on),
# CullFaceAttrib.make(CullFaceAttrib.MCullNone),
100))
self._createTagStates()
self.shadowScene.setTag("ShadowPassShader", "Default")
# Create debug overlay
self._createDebugTexts()
# Disable buffer on start
self.shadowComputeTarget.setActive(False)
# Bind arrays
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(
self.shadowComputeTarget, "updateSources")
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
def __init__(self):
DebugObject.__init__(self, "LightManager")
self._initArrays()
# create arrays to store lights & shadow sources
self.lights = []
self.shadowSources = []
self.allLightsArray = ShaderStructArray(Light, 30)
self.cullBounds = None
self.shadowScene = render
## SHADOW ATLAS ##
# todo: move to separate class
# When you change this, change also SHADOW_MAP_ATLAS_SIZE in configuration.include,
# and reduce the default shadow map resolution of point lights
self.shadowAtlasSize = 512
self.maxShadowMaps = 24
# When you change it , change also SHAODOW_GEOMETRY_MAX_VERTICES and
# SHADOW_MAX_UPDATES_PER_FRAME in configuration.include!
self.maxShadowUpdatesPerFrame = 2
self.tileSize = 128
self.tileCount = self.shadowAtlasSize / self.tileSize
self.tiles = []
self.updateShadowsArray = ShaderStructArray(
ShadowSource, self.maxShadowUpdatesPerFrame)
self.allShadowsArray = ShaderStructArray(ShadowSource,
self.maxShadowMaps)
# self.shadowAtlasTex = Texture("ShadowAtlas")
# self.shadowAtlasTex.setup2dTexture(
# self.shadowAtlasSize, self.shadowAtlasSize, Texture.TFloat, Texture.FRg16)
# self.shadowAtlasTex.setMinfilter(Texture.FTLinear)
# self.shadowAtlasTex.setMagfilter(Texture.FTLinear)
self.debug("Init shadow atlas with tileSize =", self.tileSize,
", tileCount =", self.tileCount)
for i in xrange(self.tileCount):
self.tiles.append([None for j in xrange(self.tileCount)])
# create shadow compute buffer
self.shadowComputeCamera = Camera("ShadowComputeCamera")
self.shadowComputeCameraNode = self.shadowScene.attachNewNode(
self.shadowComputeCamera)
self.shadowComputeCamera.getLens().setFov(90, 90)
self.shadowComputeCamera.getLens().setNearFar(10.0, 100000.0)
self.shadowComputeCameraNode.setPos(0, 0, 150)
self.shadowComputeCameraNode.lookAt(0, 0, 0)
self.shadowComputeTarget = RenderTarget("ShadowCompute")
self.shadowComputeTarget.setSize(self.shadowAtlasSize,
self.shadowAtlasSize)
# self.shadowComputeTarget.setLayers(self.maxShadowUpdatesPerFrame)
self.shadowComputeTarget.addRenderTexture(RenderTargetType.Depth)
self.shadowComputeTarget.setDepthBits(32)
self.shadowComputeTarget.setSource(self.shadowComputeCameraNode,
base.win)
self.shadowComputeTarget.prepareSceneRender()
self.shadowComputeTarget.getInternalRegion().setSort(3)
self.shadowComputeTarget.getRegion().setSort(3)
self.shadowComputeTarget.getInternalRegion().setNumRegions(
self.maxShadowUpdatesPerFrame + 1)
self.shadowComputeTarget.getInternalRegion().setDimensions(
0, (0, 1, 0, 1))
self.shadowComputeTarget.setClearDepth(False)
self.depthClearer = []
for i in xrange(self.maxShadowUpdatesPerFrame):
buff = self.shadowComputeTarget.getInternalBuffer()
dr = buff.makeDisplayRegion()
dr.setSort(2)
dr.setClearDepthActive(True)
dr.setClearDepth(1.0)
dr.setClearColorActive(False)
dr.setDimensions(0, 0, 0, 0)
self.depthClearer.append(dr)
self.queuedShadowUpdates = []
# Assign copy shader
self._setCopyShader()
# self.shadowComputeTarget.setShaderInput("atlas", self.shadowComputeTarget.getColorTexture())
# self.shadowComputeTarget.setShaderInput(
# "renderResult", self.shadowComputeTarget.getDepthTexture())
# self.shadowComputeTarget.setActive(False)
# Create shadow caster shader
self.shadowCasterShader = BetterShader.load(
"Shader/DefaultShadowCaster.vertex",
"Shader/DefaultShadowCaster.fragment",
"Shader/DefaultShadowCaster.geometry")
self.shadowComputeCamera.setTagStateKey("ShadowPass")
initialState = NodePath("ShadowCasterState")
initialState.setShader(self.shadowCasterShader, 30)
self.shadowComputeCamera.setInitialState(
RenderState.make(ColorWriteAttrib.make(ColorWriteAttrib.C_off),
DepthWriteAttrib.make(DepthWriteAttrib.M_on),
100))
self.shadowComputeCamera.setTagState("True", initialState.getState())
self.shadowScene.setTag("ShadowPass", "True")
self._createDebugTexts()
self.updateShadowsArray.bindTo(self.shadowScene, "updateSources")
self.updateShadowsArray.bindTo(self.shadowComputeTarget,
"updateSources")
self.numShadowUpdatesPTA = PTAInt.emptyArray(1)
# Set initial inputs
for target in [self.shadowComputeTarget, self.shadowScene]:
target.setShaderInput("numUpdates", self.numShadowUpdatesPTA)
self.lightingComputator = None
self.lightCuller = None
def prepareSceneRender(self, earlyZ=False, earlyZCam=None):
""" Renders the scene of the source camera to the buffer. See the
documentation of this class for further information """
self.debug("Preparing scene render")
# Init buffer object
self._createBuffer()
# Prepare initial state
cs = NodePath("InitialStateDummy")
cs.setState(self._sourceCam.node().getInitialState())
if self.hasTarget(RenderTargetType.Aux0):
cs.setAttrib(AuxBitplaneAttrib.make(self._auxBits), 20)
cs.setAttrib(StencilAttrib.makeOff(), 20)
if not self._enableTransparency:
cs.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone),
100)
if not self._writeColor:
cs.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 100)
self._sourceCam.node().setInitialState(cs.getState())
if earlyZ:
self._earlyZRegion = self._internalBuffer.makeDisplayRegion()
self._earlyZRegion.setSort(-10)
self._earlyZRegion.setCamera(earlyZCam)
self._node = NodePath("RTRoot")
# Prepare fullscreen quad
if self._createOverlayQuad:
self._quad = self._makeFullscreenQuad()
self._quad.reparentTo(self._node)
bufferCam = self._makeFullscreenCam()
self._camera = self._node.attachNewNode(bufferCam)
self._region.setCamera(self._camera)
self._region.setSort(5)
# Set clears
bufferRegion = self._internalBuffer.getDisplayRegion(0)
self._correctClears()
bufferRegion.setClearStencilActive(False)
# self._sourceWindow.setClearStencilActive(False)
# Set aux clears
targetCheck = [
(RenderTargetType.Aux0, GraphicsOutput.RTPAuxRgba0),
(RenderTargetType.Aux1, GraphicsOutput.RTPAuxRgba1),
(RenderTargetType.Aux2, GraphicsOutput.RTPAuxRgba2),
(RenderTargetType.Aux3, GraphicsOutput.RTPAuxRgba3),
]
for target, targetBindPos in targetCheck:
if self.hasTarget(target):
bufferRegion.setClearActive(targetBindPos, 1)
bufferRegion.setClearValue(targetBindPos,
Vec4(0.5, 0.5, 1.0, 0.0))
self._region.disableClears()
bufferRegion.setCamera(self._sourceCam)
bufferRegion.setActive(1)
bufferRegion.setClearDepthActive(False)
bufferRegion.setSort(20)
if earlyZ:
self._earlyZRegion.disableClears()
self._earlyZRegion.setClearDepthActive(True)
self._earlyZRegion.setActive(1)
self._setSizeShaderInput()
self._active = True
self._registerBuffer()
# Set up stenciling system
stencilReader = StencilAttrib.make(1, StencilAttrib.SCFEqual,
StencilAttrib.SOKeep, StencilAttrib.SOKeep,
StencilAttrib.SOKeep, 1, 1, 0)
constantOneStencil = StencilAttrib.make(1, StencilAttrib.SCFAlways,
StencilAttrib.SOZero,
StencilAttrib.SOReplace,
StencilAttrib.SOReplace, 1, 0, 1)
#mesh = shapeGenerator.Tube(0.18, 0.18, 5.0, 32)
# To be render on texture
#inside_vortex = shapeGenerator.ShellCylinder(-0.18, 5.0, 32)
inside_vortex = shapeGenerator.Circle(0.18, 32)
inside_vortex.node().setAttrib(constantOneStencil)
inside_vortex.node().setAttrib(ColorWriteAttrib.make(0))
inside_vortex.setBin('background', 0)
inside_vortex.setDepthWrite(0)
#inside_vortex.setH(180)
inside_vortex.setP(180)
#inside_vortex.setR(180)
vortex = shapeGenerator.ShellCylinder(-0.18, 10.0, 32)
vortex.node().setAttrib(stencilReader)
# Mask that fades out vortex
#outside_vortex = shapeGenerator.ShellCylinder(0.181, 0.05, 32)
outside_vortex = shapeGenerator.ShellCylinder(0.181, 5.0, 32)
def taskUpdate(task):
def prepareSceneRender(self):
""" Renders the scene of the source camera to the buffer. See the
documentation of this class for further information """
self.debug("Preparing scene render")
# Init buffer object
self._createBuffer()
# Prepare fullscreen quad
self._quad = self._makeFullscreenQuad()
# Prepare initial state
cs = NodePath("InitialStateDummy")
cs.setState(self._sourceCam.node().getInitialState())
if self.hasTarget(RenderTargetType.Aux0):
cs.setAttrib(AuxBitplaneAttrib.make(self._auxBits), 20)
cs.setAttrib(StencilAttrib.makeOff(), 20)
if not self._enableTransparency:
cs.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone), 100)
if not self._writeColor:
cs.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 100)
self._sourceCam.node().setInitialState(cs.getState())
# Set new camera
bufferCam = self._makeFullscreenCam()
bufferCamNode = self._quad.attachNewNode(bufferCam)
self._region.setCamera(bufferCamNode)
self._region.setSort(5)
# Set clears
bufferRegion = self._buffer.getInternalBuffer().getDisplayRegion(0)
self._correctClears()
bufferRegion.setClearStencilActive(False)
# self._sourceWindow.setClearStencilActive(False)
# Set aux clears
targetCheck = [
(RenderTargetType.Aux0, GraphicsOutput.RTPAuxRgba0),
(RenderTargetType.Aux1, GraphicsOutput.RTPAuxRgba1),
(RenderTargetType.Aux2, GraphicsOutput.RTPAuxRgba2),
(RenderTargetType.Aux3, GraphicsOutput.RTPAuxRgba3),
]
for target, targetBindPos in targetCheck:
if self.hasTarget(target):
bufferRegion.setClearActive(targetBindPos, 1)
bufferRegion.setClearValue(
targetBindPos, Vec4(0.5, 0.5, 1.0, 0.0))
self._region.disableClears()
bufferRegion.setCamera(self._sourceCam)
bufferRegion.setActive(1)
# bufferRegion.setClearDepthActive(False)
bufferRegion.setSort(20)
self._setSizeShaderInput()
from panda3d.core import AmbientLight, ColorWriteAttrib, NodePath, Shader, StencilAttrib, Vec4
# Set up stenciling system
stencilReader = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOKeep,
StencilAttrib.SOKeep,StencilAttrib.SOKeep,1,1,0)
constantOneStencil = StencilAttrib.make(1,StencilAttrib.SCFAlways,StencilAttrib.SOZero,
StencilAttrib.SOReplace,StencilAttrib.SOReplace,1,0,1)
#mesh = shapeGenerator.Tube(0.18, 0.18, 5.0, 32)
# To be render on texture
#inside_vortex = shapeGenerator.ShellCylinder(-0.18, 5.0, 32)
inside_vortex = shapeGenerator.Circle(0.18, 32)
inside_vortex.node().setAttrib(constantOneStencil)
inside_vortex.node().setAttrib(ColorWriteAttrib.make(0))
inside_vortex.setBin('background', 0)
inside_vortex.setDepthWrite(0)
#inside_vortex.setH(180)
inside_vortex.setP(180)
#inside_vortex.setR(180)
vortex = shapeGenerator.ShellCylinder(-0.18, 10.0, 32)
vortex.node().setAttrib(stencilReader)
# Mask that fades out vortex
#outside_vortex = shapeGenerator.ShellCylinder(0.181, 0.05, 32)
outside_vortex = shapeGenerator.ShellCylinder(0.181, 5.0, 32)
def taskUpdate(task):
def create(self):
# Create the voxel grid used to generate the voxels
self.voxel_temp_grid = Image.create_3d(
"VoxelsTemp", self.voxel_resolution, self.voxel_resolution,
self.voxel_resolution, "RGBA8")
self.voxel_temp_grid.set_clear_color(Vec4(0))
self.voxel_temp_nrm_grid = Image.create_3d(
"VoxelsTemp", self.voxel_resolution, self.voxel_resolution,
self.voxel_resolution, "R11G11B10")
self.voxel_temp_nrm_grid.set_clear_color(Vec4(0))
# Create the voxel grid which is a copy of the temporary grid, but stable
self.voxel_grid = Image.create_3d(
"Voxels", self.voxel_resolution, self.voxel_resolution, self.voxel_resolution, "RGBA8")
self.voxel_grid.set_clear_color(Vec4(0))
self.voxel_grid.set_minfilter(SamplerState.FT_linear_mipmap_linear)
# Create the camera for voxelization
self.voxel_cam = Camera("VoxelizeCam")
self.voxel_cam.set_camera_mask(self._pipeline.tag_mgr.get_voxelize_mask())
self.voxel_cam_lens = OrthographicLens()
self.voxel_cam_lens.set_film_size(
-2.0 * self.voxel_world_size, 2.0 * self.voxel_world_size)
self.voxel_cam_lens.set_near_far(0.0, 2.0 * self.voxel_world_size)
self.voxel_cam.set_lens(self.voxel_cam_lens)
self.voxel_cam_np = Globals.base.render.attach_new_node(self.voxel_cam)
self._pipeline.tag_mgr.register_camera("voxelize", self.voxel_cam)
# Create the voxelization target
self.voxel_target = self.create_target("VoxelizeScene")
self.voxel_target.size = self.voxel_resolution
self.voxel_target.prepare_render(self.voxel_cam_np)
# Create the target which copies the voxel grid
self.copy_target = self.create_target("CopyVoxels")
self.copy_target.size = self.voxel_resolution
self.copy_target.prepare_buffer()
# TODO! Does not work with the new render target yet - maybe add option
# to post process region for instances?
self.copy_target.instance_count = self.voxel_resolution
self.copy_target.set_shader_input("SourceTex", self.voxel_temp_grid)
self.copy_target.set_shader_input("DestTex", self.voxel_grid)
# Create the target which generates the mipmaps
self.mip_targets = []
mip_size, mip = self.voxel_resolution, 0
while mip_size > 1:
mip_size, mip = mip_size // 2, mip + 1
mip_target = self.create_target("GenMipmaps:" + str(mip))
mip_target.size = mip_size
mip_target.prepare_buffer()
mip_target.instance_count = mip_size
mip_target.set_shader_input("SourceTex", self.voxel_grid)
mip_target.set_shader_input("sourceMip", mip - 1)
mip_target.set_shader_input("DestTex", self.voxel_grid, False, True, -1, mip, 0)
self.mip_targets.append(mip_target)
# Create the initial state used for rendering voxels
initial_state = NodePath("VXGIInitialState")
initial_state.set_attrib(CullFaceAttrib.make(CullFaceAttrib.M_cull_none), 100000)
initial_state.set_attrib(DepthTestAttrib.make(DepthTestAttrib.M_none), 100000)
initial_state.set_attrib(ColorWriteAttrib.make(ColorWriteAttrib.C_off), 100000)
self.voxel_cam.set_initial_state(initial_state.get_state())
Globals.base.render.set_shader_input("voxelGridPosition", self.pta_next_grid_pos)
Globals.base.render.set_shader_input("VoxelGridDest", self.voxel_temp_grid)
