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 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 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)