def renderQuadInto(self, mul=1, div=1, align=1, depthtex=None, colortex=None, auxtex0=None, auxtex1=None): texgroup = ( depthtex, colortex, auxtex0, auxtex1) winx, winy = self.getScaledSize(mul, div, align) depthbits = bool(depthtex != None) buffer = self.createBuffer('filter-stage', winx, winy, texgroup, depthbits) if buffer == None: return cm = CardMaker('filter-stage-quad') cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setColor(1, 0.5, 0.5, 1) quadcamnode = Camera('filter-quad-cam') lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) dr = buffer.makeDisplayRegion((0, 1, 0, 1)) dr.disableClears() dr.setCamera(quadcam) dr.setActive(True) dr.setScissorEnabled(False) buffer.setClearColor((0, 0, 0, 1)) buffer.setClearColorActive(True) self.buffers.append(buffer) self.sizes.append((mul, div, align)) return quad
def renderQuadInto(self, xsize, ysize, colortex=None, cmode = GraphicsOutput.RTMBindOrCopy, auxtex = None): buffer = self.createBuffer("filter-stage", xsize, ysize, colortex, cmode, auxtex) if (buffer == None): return None cm = CardMaker("filter-stage-quad") cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setColor(Vec4(1,0.5,0.5,1)) quadcamnode = Camera("filter-quad-cam") lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) buffer.getDisplayRegion(0).setCamera(quadcam) buffer.getDisplayRegion(0).setActive(1) return quad, buffer
class PbCameraNode(NodePath): """Pybullet-compatible camera node wrapper """ Z2Y = Mat4(1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1) def __init__(self, render: NodePath): self._camera = Camera('pb_camera') self._lens = MatrixLens() self._camera.set_lens(self._lens) super().__init__(self._camera) self.reparent_to(render) def set_active(self, active: bool): self._camera.set_active(active) def is_active(self): return self._camera.is_active() def update(self, pb_camera): self.set_mat(self.Z2Y * Mat4(*pb_camera.pose_mat)) mat = np.asarray(pb_camera.proj_mat).reshape(4, 4) m22, m32 = -mat[2, 2], -mat[3, 2] zfar = (2.0 * m32) / (2.0 * m22 - 2.0) znear = ((m22 - 1.0) * zfar) / (m22 + 1.0) self._lens.set_near_far(znear, zfar) self._lens.set_user_mat(self.Z2Y * Mat4(*pb_camera.proj_mat))
def create(self): # Create voxelize camera self.voxelizeCamera = Camera("VoxelizeCamera") self.voxelizeCamera.setCameraMask(BitMask32.bit(4)) self.voxelizeCameraNode = Globals.render.attachNewNode( self.voxelizeCamera) self.voxelizeLens = OrthographicLens() self.voxelizeLens.setFilmSize(self.voxelGridSize * 2, self.voxelGridSize * 2) self.voxelizeLens.setNearFar(0.0, self.voxelGridSize * 2) self.voxelizeCamera.setLens(self.voxelizeLens) self.voxelizeCamera.setTagStateKey("VoxelizePassShader") Globals.render.setTag("VoxelizePassShader", "Default") # Create voxelize tareet self.target = RenderTarget("VoxelizePass") self.target.setSize(self.voxelGridResolution * self.gridResolutionMultiplier) if self.pipeline.settings.useDebugAttachments: self.target.addColorTexture() else: self.target.setColorWrite(False) self.target.setCreateOverlayQuad(False) self.target.setSource(self.voxelizeCameraNode, Globals.base.win) self.target.prepareSceneRender() self.target.setActive(False)
def create(self): self.camera = Camera("PSSMDistShadowsESM") self.cam_lens = OrthographicLens() self.cam_lens.set_film_size(12000, 12000) self.cam_lens.set_near_far(10.0, self.sun_distance * 2) self.camera.set_lens(self.cam_lens) self.cam_node = Globals.base.render.attach_new_node(self.camera) self.target = self.create_target("ShadowMap") self.target.size = self.resolution self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.cam_node) self.target_convert = self.create_target("ConvertToESM") self.target_convert.size = self.resolution self.target_convert.add_color_attachment(bits=(32, 0, 0, 0)) self.target_convert.prepare_buffer() self.target_convert.set_shader_input("SourceTex", self.target.depth_tex) self.target_blur_v = self.create_target("BlurVert") self.target_blur_v.size = self.resolution self.target_blur_v.add_color_attachment(bits=(32, 0, 0, 0)) self.target_blur_v.prepare_buffer() self.target_blur_v.set_shader_input("SourceTex", self.target_convert.color_tex) self.target_blur_v.set_shader_input("direction", LVecBase2i(1, 0)) self.target_blur_h = self.create_target("BlurHoriz") self.target_blur_h.size = self.resolution self.target_blur_h.add_color_attachment(bits=(32, 0, 0, 0)) self.target_blur_h.prepare_buffer() self.target_blur_h.set_shader_input("SourceTex", self.target_blur_v.color_tex) self.target_blur_h.set_shader_input("direction", LVecBase2i(0, 1)) # Register shadow camera self._pipeline.tag_mgr.register_camera("shadow", self.camera)
def setupCamera2d(self, sort=10, displayRegion=(0, 1, 0, 1), coords=(-1, 1, -1, 1)): dr = self.win.makeMonoDisplayRegion(*displayRegion) dr.setSort(10) # Enable clearing of the depth buffer on this new display # region (see the comment in setupRender2d, above). dr.setClearDepthActive(1) # Make any texture reloads on the gui come up immediately. dr.setIncompleteRender(False) left, right, bottom, top = coords # Now make a new Camera node. cam2dNode = Camera('cam2d') lens = OrthographicLens() lens.setFilmSize(right - left, top - bottom) lens.setFilmOffset((right + left) * 0.5, (top + bottom) * 0.5) lens.setNearFar(-1000, 1000) cam2dNode.setLens(lens) # self.camera2d is the analog of self.camera, although it's # not as clear how useful it is. self.camera2d = self.render2d.attachNewNode('camera2d') camera2d = self.camera2d.attachNewNode(cam2dNode) dr.setCamera(camera2d) self.cam2d = camera2d return camera2d
def create(self): self.camera = Camera("SkyAOCaptureCam") self.cam_lens = OrthographicLens() self.cam_lens.set_film_size(200, 200) self.cam_lens.set_near_far(0.0, 500.0) self.camera.set_lens(self.cam_lens) self.cam_node = Globals.base.render.attach_new_node(self.camera) self.cam_node.look_at(0, 0, -1) self.cam_node.set_r(0) self.target = self.create_target("SkyAOCapture") self.target.size = 1024 self.target.add_depth_attachment(bits=16) self.target.prepare_render(self.cam_node) self.target_convert = self.create_target("ConvertDepth") self.target_convert.size = 1024 self.target_convert.add_color_attachment(bits=(16, 0, 0, 0)) self.target_convert.prepare_buffer() self.target_convert.set_shader_input("DepthTex", self.target.depth_tex) self.target_convert.set_shader_input("position", self.pta_position) # Register camera self._pipeline.tag_mgr.register_camera("shadow", self.camera)
class _Camera_: key_map = {} mouse_map = {} # Public. def set_focus(self, obj): if self.FOCUS and obj is self.FOCUS: return self.FOCUS = obj self.focus_pos.set(0, obj.radius * 12, 0) obj_state = self.env.client.SIM.get_object_state(obj.name, ["sys_pos"]) obj.sys_pos = LVector3d(*obj_state['sys_pos']) self.sys_pos = obj.sys_pos - self.focus_pos # Setup. def __init__(self, env): self.env = env self.cam_node = Camera(self.__class__.__name__.lower()) self.cam_node.setScene(env.NP) self.NP = NodePath(self.cam_node) self.NP.reparentTo(env.NP) self.LENS = self.cam_node.getLens() self.LENS.setFar(_cam.FAR) self.LENS.setFov(base.camLens.getFov()) self.FOCUS = None self.focus_pos = LVector3d(0, 0, 0) self.sys_pos = LVector3d(0, 0, 0)
def __init__(self, app): self.app = app self.do = DirectObject() self.running = False self.displayRegion = None self.root = NodePath('creditsRender') self.camera = Camera('creditsCam') self.cameraNP = NodePath(self.camera) # Set parameters to match those of render2d self.root.setDepthTest(0) self.root.setDepthWrite(0) self.root.setMaterialOff(1) self.root.setTwoSided(1) self.aspect2d = self.root # self.root.attachNewNode('creditsAspect') lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) self.camera.setLens(lens) self.cameraNP.reparentTo(self.root) self.scrollTask = None self.lastTime = None self.creditsFileLoaded = False
class SkyAOCaptureStage(RenderStage): """ This stage captures the sky ao by rendering the scene from above """ required_inputs = [] required_pipes = [] @property def produced_pipes(self): return {"SkyAOHeight": self.target_convert.color_tex} @property def produced_inputs(self): return {"SkyAOCapturePosition": self.pta_position} def __init__(self, pipeline): RenderStage.__init__(self, pipeline) self.pta_position = PTALVecBase3f.empty_array(1) self.resolution = 512 self.capture_height = 100.0 self.max_radius = 100.0 def create(self): self.camera = Camera("SkyAOCaptureCam") self.cam_lens = OrthographicLens() self.cam_lens.set_film_size(self.max_radius, self.max_radius) self.cam_lens.set_near_far(0, self.capture_height) self.camera.set_lens(self.cam_lens) self.cam_node = Globals.base.render.attach_new_node(self.camera) self.cam_node.look_at(0, 0, -1) self.cam_node.set_r(0) self.target = self.create_target("SkyAOCapture") self.target.size = self.resolution self.target.add_depth_attachment(bits=16) self.target.prepare_render(self.cam_node) self.target_convert = self.create_target("ConvertDepth") self.target_convert.size = self.resolution self.target_convert.add_color_attachment(bits=(16, 0, 0, 0)) self.target_convert.prepare_buffer() self.target_convert.set_shader_inputs( DepthTex=self.target.depth_tex, position=self.pta_position) # Register camera self._pipeline.tag_mgr.register_camera("shadow", self.camera) def update(self): snap_size = self.max_radius / self.resolution cam_pos = Globals.base.camera.get_pos(Globals.base.render) self.cam_node.set_pos( cam_pos.x - cam_pos.x % snap_size, cam_pos.y - cam_pos.y % snap_size, self.capture_height / 2.0) self.pta_position[0] = self.cam_node.get_pos() def reload_shaders(self): self.target_convert.shader = self.load_plugin_shader("convert_depth.frag.glsl")
def __init__(self): """ Creates a new ShadowSource. After the creation, a lens can be added with setupPerspectiveLens or setupOrtographicLens. """ self.index = self._generateUID() DebugObject.__init__(self, "ShadowSource-" + str(self.index)) ShaderStructElement.__init__(self) self.valid = False self.camera = Camera("ShadowSource-" + str(self.index)) self.camera.setActive(False) self.cameraNode = NodePath(self.camera) self.cameraNode.reparentTo(Globals.render.find("RPCameraDummys")) self.cameraNode.hide() self.resolution = 512 self.atlasPos = Vec2(0) self.doesHaveAtlasPos = False self.sourceIndex = 0 self.mvp = UnalignedLMatrix4f() self.sourceIndex = -1 self.nearPlane = 0.0 self.farPlane = 1000.0 self.converterYUR = None self.transforMat = TransformState.makeMat( Mat4.convertMat( Globals.base.win.getGsg().getInternalCoordinateSystem(), CSZupRight))
class _Camera_: key_map = {} mouse_map = {} # Public. def set_focus(self, obj): if self.FOCUS and obj is self.FOCUS: return self.FOCUS = obj self.focus_pos.set(0, obj.radius*12, 0) obj_state = self.env.client.SIM.get_object_state(obj.name, ["sys_pos"]) obj.sys_pos = LVector3d(*obj_state['sys_pos']) self.sys_pos = obj.sys_pos - self.focus_pos # Setup. def __init__(self, env): self.env = env self.cam_node = Camera(self.__class__.__name__.lower()) self.cam_node.setScene(env.NP) self.NP = NodePath(self.cam_node) self.NP.reparentTo(env.NP) self.LENS = self.cam_node.getLens() self.LENS.setFar(_cam.FAR) self.LENS.setFov(base.camLens.getFov()) self.FOCUS = None self.focus_pos = LVector3d(0,0,0) self.sys_pos = LVector3d(0,0,0)
class SkyAOCaptureStage(RenderStage): """ This stage captures the sky ao by rendering the scene from above """ required_inputs = [] required_pipes = [] @property def produced_pipes(self): return {"SkyAOHeight": self.target_convert.color_tex} @property def produced_inputs(self): return {"SkyAOCapturePosition": self.pta_position} def __init__(self, pipeline): RenderStage.__init__(self, pipeline) self.pta_position = PTALVecBase3f.empty_array(1) self.resolution = 512 self.capture_height = 100.0 self.max_radius = 100.0 def create(self): self.camera = Camera("SkyAOCaptureCam") self.cam_lens = OrthographicLens() self.cam_lens.set_film_size(self.max_radius, self.max_radius) self.cam_lens.set_near_far(0, self.capture_height) self.camera.set_lens(self.cam_lens) self.cam_node = Globals.base.render.attach_new_node(self.camera) self.cam_node.look_at(0, 0, -1) self.cam_node.set_r(0) self.target = self.create_target("SkyAOCapture") self.target.size = self.resolution self.target.add_depth_attachment(bits=16) self.target.prepare_render(self.cam_node) self.target_convert = self.create_target("ConvertDepth") self.target_convert.size = self.resolution self.target_convert.add_color_attachment(bits=(16, 0, 0, 0)) self.target_convert.prepare_buffer() self.target_convert.set_shader_inputs(DepthTex=self.target.depth_tex, position=self.pta_position) # Register camera self._pipeline.tag_mgr.register_camera("shadow", self.camera) def update(self): snap_size = self.max_radius / self.resolution cam_pos = Globals.base.camera.get_pos(Globals.base.render) self.cam_node.set_pos(cam_pos.x - cam_pos.x % snap_size, cam_pos.y - cam_pos.y % snap_size, self.capture_height / 2.0) self.pta_position[0] = self.cam_node.get_pos() def reload_shaders(self): self.target_convert.shader = self.load_plugin_shader( "convert_depth.frag.glsl")
class CameraInstanceComponent(PandaInstanceComponent): def __init__(self, entity, component): self._camera = Camera(entity.__class__.__name__) def set_root_nodepath(self, nodepath): nodepath.attach_new_node(self._camera) def on_destroyed(self): self._camera.remove_node()
def renderQuadInto(self, mul=1, div=1, align=1, depthtex=None, colortex=None, auxtex0=None, auxtex1=None): """ Creates an offscreen buffer for an intermediate computation. Installs a quad into the buffer. Returns the fullscreen quad. The size of the buffer is initially equal to the size of the main window. The parameters 'mul', 'div', and 'align' can be used to adjust that size. """ texgroup = (depthtex, colortex, auxtex0, auxtex1) winx, winy = self.getScaledSize(mul, div, align) depthbits = bool(depthtex != None) buffer = self.createBuffer("filter-stage", winx, winy, texgroup, depthbits) if (buffer == None): return None cm = CardMaker("filter-stage-quad") cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setColor(1, 0.5, 0.5, 1) quadcamnode = Camera("filter-quad-cam") lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) dr = buffer.makeDisplayRegion((0, 1, 0, 1)) dr.disableClears() dr.setCamera(quadcam) dr.setActive(True) dr.setScissorEnabled(False) # This clear stage is important if the buffer is padded, so that # any pixels accidentally sampled in the padded region won't # be reading from unititialised memory. buffer.setClearColor((0, 0, 0, 1)) buffer.setClearColorActive(True) self.buffers.append(buffer) self.sizes.append((mul, div, align)) return quad
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 a camera for each update self.shadowCameras = [] for i in xrange(self.maxRegions): shadowCam = Camera("ShadowMapCamera-" + str(i)) shadowCam.setTagStateKey("ShadowPassShader") # 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 _makeFullscreenCam(self): """ Create a orthographic camera for this buffer """ bufferCam = Camera("BufferCamera") lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) bufferCam.setLens(lens) bufferCam.setCullBounds(OmniBoundingVolume()) return bufferCam
def create_camera(self, name, projection_mat): """ Create a camera with the given projection matrix. """ cam_node = Camera(name) lens = MatrixLens() lens.set_user_mat(projection_mat) cam_node.set_lens(lens) return cam_node
def renderSceneInto(self, depthtex=None, colortex=None, auxtex=None, auxbits=0, textures=None): if textures: colortex = textures.get('color', None) depthtex = textures.get('depth', None) auxtex = textures.get('aux', None) auxtex0 = textures.get('aux0', auxtex) auxtex1 = textures.get('aux1', None) else: auxtex0 = auxtex auxtex1 = None if colortex == None: colortex = Texture('filter-base-color') colortex.setWrapU(Texture.WMClamp) colortex.setWrapV(Texture.WMClamp) texgroup = (depthtex, colortex, auxtex0, auxtex1) winx, winy = self.getScaledSize(1, 1, 1) buffer = self.createBuffer('filter-base', winx, winy, texgroup) if buffer == None: return cm = CardMaker('filter-base-quad') cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setTexture(colortex) quad.setColor(1, 0.5, 0.5, 1) cs = NodePath('dummy') cs.setState(self.camstate) if auxbits: cs.setAttrib(AuxBitplaneAttrib.make(auxbits)) self.camera.node().setInitialState(cs.getState()) quadcamnode = Camera('filter-quad-cam') lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) self.region.setCamera(quadcam) self.setStackedClears(buffer, self.rclears, self.wclears) if auxtex0: buffer.setClearActive(GraphicsOutput.RTPAuxRgba0, 1) buffer.setClearValue(GraphicsOutput.RTPAuxRgba0, (0.5, 0.5, 1.0, 0.0)) if auxtex1: buffer.setClearActive(GraphicsOutput.RTPAuxRgba1, 1) self.region.disableClears() if self.isFullscreen(): self.win.disableClears() dr = buffer.makeDisplayRegion() dr.disableClears() dr.setCamera(self.camera) dr.setActive(1) self.buffers.append(buffer) self.sizes.append((1, 1, 1)) return quad
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 a camera for each update self.shadowCameras = [] for i in xrange(self.maxRegions): shadowCam = Camera("ShadowMapCamera-" + str(i)) shadowCam.setTagStateKey("ShadowPassShader") # 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 _make_fullscreen_cam(self): """ Creates an orthographic camera for the buffer """ buffer_cam = Camera("BufferCamera") lens = OrthographicLens() lens.set_film_size(2, 2) lens.set_film_offset(0, 0) lens.set_near_far(-100, 100) buffer_cam.set_lens(lens) buffer_cam.set_cull_bounds(OmniBoundingVolume()) self._camera = self._node.attach_new_node(buffer_cam) self._region.set_camera(self._camera)
def __init__(self, env): self.env = env self.cam_node = Camera(self.__class__.__name__.lower()) self.cam_node.setScene(env.NP) self.NP = NodePath(self.cam_node) self.NP.reparentTo(env.NP) self.LENS = self.cam_node.getLens() self.LENS.setFar(_cam.FAR) self.LENS.setFov(base.camLens.getFov()) self.FOCUS = None self.focus_pos = LVector3d(0, 0, 0) self.sys_pos = LVector3d(0, 0, 0)
def _initDepthCapture(self): for camera in self.cameras: camNode = Camera('Depth camera') camNode.setCameraMask(self.cameraMask) lens = PerspectiveLens() lens.setFov(self.fov) lens.setAspectRatio(float(self.size[0]) / float(self.size[1])) lens.setNear(self.zNear) lens.setFar(self.zFar) camNode.setLens(lens) camNode.setScene(self.scene.scene) cam = camera.attachNewNode(camNode) winprops = WindowProperties.size(self.size[0], self.size[1]) fbprops = FrameBufferProperties.getDefault() fbprops = FrameBufferProperties(fbprops) fbprops.setRgbColor(False) fbprops.setRgbaBits(0, 0, 0, 0) fbprops.setStencilBits(0) fbprops.setMultisamples(0) fbprops.setBackBuffers(0) fbprops.setDepthBits(16) flags = GraphicsPipe.BFFbPropsOptional if self.mode == 'onscreen': flags = flags | GraphicsPipe.BFRequireWindow elif self.mode == 'offscreen': flags = flags | GraphicsPipe.BFRefuseWindow else: raise Exception('Unsupported rendering mode: %s' % (self.mode)) buf = self.graphicsEngine.makeOutput(self.pipe, 'Depth buffer', 0, fbprops, winprops, flags) if buf is None: raise Exception('Unable to create depth buffer') # Set to render at the end buf.setSort(10000) dr = buf.makeDisplayRegion() dr.setSort(0) dr.setCamera(cam) dr = camNode.getDisplayRegion(0) tex = Texture() tex.setFormat(Texture.FDepthComponent) tex.setComponentType(Texture.TFloat) buf.addRenderTexture(tex, GraphicsOutput.RTMCopyRam, GraphicsOutput.RTPDepth) # XXX: should use tex.setMatchFramebufferFormat(True)? agent = camera.getParent() self.depthBuffers[agent.getName()] = buf self.depthTextures[agent.getName()] = tex
def enable(self): camNode = Camera('shadowCam') camNode.setCameraMask(CIGlobals.ShadowCameraBitmask) self.shadowLens = OrthographicLens() self.shadowLens.setFilmSize(60 * 4, 60 * 4) camNode.setLens(self.shadowLens) self.shadowCamArm = camera.attachNewNode('shadowCamArm') self.shadowCam = self.shadowCamArm.attachNewNode(camNode) self.shadowCamArm.setPos(0, 40, 0) self.shadowCam.setPos(0, -40, 0) self.shadowTex = Texture('shadow') self.shadowTex.setBorderColor(self.clearColor) self.shadowTex.setWrapU(Texture.WMBorderColor) self.shadowTex.setWrapV(Texture.WMBorderColor) self.casterState = NodePath('temp') self.casterState.setColorScaleOff(10) self.casterState.setColor(self.shadowColor, self.shadowColor, self.shadowColor, 1, 10) self.casterState.setTextureOff(10) self.casterState.setLightOff(10) self.casterState.setFogOff(10) camNode.setInitialState(self.casterState.getState()) render.hide(CIGlobals.ShadowCameraBitmask) self.shadowStage = TextureStage('shadow') self.shadowStage.setSort(1000) self.turnOnShadows()
def create(self): earlyZ = self.pipeline.settings.enableEarlyZ if earlyZ: self.prepassCam = Camera(Globals.base.camNode) self.prepassCam.setTagStateKey("EarlyZShader") self.prepassCam.setName("EarlyZCamera") self.prepassCamNode = Globals.base.camera.attachNewNode( self.prepassCam) Globals.render.setTag("EarlyZShader", "Default") else: self.prepassCam = None # modify default camera initial state initial = Globals.base.camNode.getInitialState() initialNode = NodePath("IntiialState") initialNode.setState(initial) if earlyZ: initialNode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff)) initialNode.setAttrib(DepthTestAttrib.make(DepthTestAttrib.MEqual)) pass else: initialNode.setAttrib( DepthTestAttrib.make(DepthTestAttrib.MLessEqual)) # initialNode.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 10000) # initialNode.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullClockwise), 10000) Globals.base.camNode.setInitialState(initialNode.getState()) self.target = RenderTarget("DeferredScenePass") self.target.addColorAndDepth() self.target.addAuxTextures(3) self.target.setAuxBits(16) self.target.setDepthBits(32) self.target.setCreateOverlayQuad(False) if earlyZ: self.target.prepareSceneRender(earlyZ=True, earlyZCam=self.prepassCamNode) else: self.target.prepareSceneRender() self.target.setClearColor(True, color=Vec4(1, 1, 0, 1)) if earlyZ: self.target.setClearDepth(False) else: self.target.setClearDepth(True)
def create(self): self.camera = Camera("PSSMSceneSunShadowCam") self.cam_lens = OrthographicLens() self.cam_lens.set_film_size(400, 400) self.cam_lens.set_near_far(100.0, 1800.0) self.camera.set_lens(self.cam_lens) self.cam_node = Globals.base.render.attach_new_node(self.camera) self.target = self.create_target("ShadowMap") self.target.size = self.resolution self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.cam_node) # Register shadow camera self._pipeline.tag_mgr.register_camera("shadow", self.camera)
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 __init__(self, base, *args, label='golog', **kwargs): self.base = base #initialize with an empty nodepath and no window #initialize a golog with no relative path (shouldn't be able to open files without one though) defaults = {'render': 'NodePath(label+\"_render\")'} for key in defaults: if key in kwargs: setattr(self, key, kwargs[key]) else: setattr(self, key, eval(defaults[key])) self.Simplex_to_Graphics = dict() self.Graphics_to_Simplex = dict() self.NP_to_Graphics = dict() # Initialize simplicial set self.label = label self.sSet = hcat.simpSet(label=self.label, data={'node': self.render}) self.sSet.simplex_to_graphics = dict() self.sSet.data['export_tag'] = 'golog' self.NPtoSimplex = dict() # set up camera self.camNode = Camera(label + "camNode") self.camera = self.render.attachNewNode(self.camNode) self.camera.setPos(0, -Camera_Distance, 0) # Load Models self.sphere = base.loader.loadModel("./misc_data/models/sphere.egg.pz") self.cone = base.loader.loadModel("./misc_data/models/sphere.egg.pz") self.cone.setScale(.6) #set up collision traverser #? move to mode_head? self.cTrav = CollisionTraverser(self.label + '_traverser')
def __init__(self): """ Creates a new ShadowSource. After the creation, a lens can be added with setupPerspectiveLens or setupOrtographicLens. """ self.index = self._generateUID() DebugObject.__init__(self, "ShadowSource-" + str(self.index)) ShaderStructElement.__init__(self) self.valid = False self.camera = Camera("ShadowSource-" + str(self.index)) self.camera.setActive(False) self.cameraNode = NodePath(self.camera) self.cameraNode.reparentTo(Globals.render.find("RPCameraDummys")) self.cameraNode.hide() self.resolution = 512 self.atlasPos = Vec2(0) self.doesHaveAtlasPos = False self.sourceIndex = 0 self.mvp = UnalignedLMatrix4f() self.sourceIndex = -1 self.nearPlane = 0.0 self.farPlane = 1000.0 self.converterYUR = None self.transforMat = TransformState.makeMat( Mat4.convertMat(Globals.base.win.getGsg().getInternalCoordinateSystem(), CSZupRight))
def _prepare_early_z(self, early_z=False): """ Prepares the earlyz stage """ if early_z: self._prepass_cam = Camera(Globals.base.camNode) self._prepass_cam.set_tag_state_key("EarlyZShader") self._prepass_cam.set_name("EarlyZCamera") self._prepass_cam_node = Globals.base.camera.attach_new_node( self._prepass_cam) Globals.render.set_tag("EarlyZShader", "Default") else: self._prepass_cam = None # modify default camera initial state initial = Globals.base.camNode.get_initial_state() initial_node = NodePath("IntialState") initial_node.set_state(initial) if early_z: initial_node.set_attrib( DepthWriteAttrib.make(DepthWriteAttrib.M_off)) initial_node.set_attrib( DepthTestAttrib.make(DepthTestAttrib.M_equal)) else: initial_node.set_attrib( DepthTestAttrib.make(DepthTestAttrib.M_less_equal)) Globals.base.camNode.set_initial_state(initial_node.get_state())
def create(self): # Create voxelize camera self.voxelizeCamera = Camera("VoxelizeCamera") self.voxelizeCamera.setCameraMask(BitMask32.bit(4)) self.voxelizeCameraNode = Globals.render.attachNewNode(self.voxelizeCamera) self.voxelizeLens = OrthographicLens() self.voxelizeLens.setFilmSize(self.voxelGridSize * 2, self.voxelGridSize * 2) self.voxelizeLens.setNearFar(0.0, self.voxelGridSize * 2) self.voxelizeCamera.setLens(self.voxelizeLens) self.voxelizeCamera.setTagStateKey("VoxelizePassShader") Globals.render.setTag("VoxelizePassShader", "Default") # Create voxelize tareet self.target = RenderTarget("VoxelizePass") self.target.setSize(self.voxelGridResolution * self.gridResolutionMultiplier) if self.pipeline.settings.useDebugAttachments: self.target.addColorTexture() else: self.target.setColorWrite(False) self.target.setCreateOverlayQuad(False) self.target.setSource(self.voxelizeCameraNode, Globals.base.win) self.target.prepareSceneRender() self.target.setActive(False)
def _prepareVoxelScene(self): """ Creates the internal buffer to voxelize the scene on the fly """ self.voxelizeScene = Globals.render self.voxelizeCamera = Camera("VoxelizeScene") self.voxelizeCameraNode = self.voxelizeScene.attachNewNode( self.voxelizeCamera) self.voxelizeLens = OrthographicLens() self.voxelizeLens.setFilmSize(self.voxelGridSizeWS.x * 2, self.voxelGridSizeWS.y * 2) self.voxelizeLens.setNearFar(0.0, self.voxelGridSizeWS.x * 2) self.voxelizeCamera.setLens(self.voxelizeLens) self.voxelizeCamera.setTagStateKey("VoxelizePassShader") self.targetSpace.setTag("VoxelizePassShader", "Default") self.voxelizeCameraNode.setPos(0, 0, 0) self.voxelizeCameraNode.lookAt(0, 0, 0) self.voxelizeTarget = RenderTarget("DynamicVoxelization") self.voxelizeTarget.setSize(self.voxelBaseResolution) # self.voxelizeTarget.addDepthTexture() # self.voxelizeTarget.addColorTexture() # self.voxelizeTarget.setColorBits(16) self.voxelizeTarget.setSource(self.voxelizeCameraNode, Globals.base.win) self.voxelizeTarget.prepareSceneRender() self.voxelizeTarget.getQuad().node().removeAllChildren() self.voxelizeTarget.getInternalRegion().setSort(-400) self.voxelizeTarget.getInternalBuffer().setSort(-399) # for tex in [self.voxelizeTarget.getColorTexture()]: # tex.setWrapU(Texture.WMClamp) # tex.setWrapV(Texture.WMClamp) # tex.setMinfilter(Texture.FTNearest) # tex.setMagfilter(Texture.FTNearest) voxelSize = Vec3( self.voxelGridSizeWS.x * 2.0 / self.voxelGridResolution.x, self.voxelGridSizeWS.y * 2.0 / self.voxelGridResolution.y, self.voxelGridSizeWS.z * 2.0 / self.voxelGridResolution.z) self.targetSpace.setShaderInput("dv_gridSize", self.voxelGridSizeWS * 2) self.targetSpace.setShaderInput("dv_voxelSize", voxelSize) self.targetSpace.setShaderInput("dv_gridResolution", self.voxelGridResolution)
def _initRgbCapture(self): for camera in self.cameras: camNode = Camera('Semantic camera') camNode.setCameraMask(self.cameraMask) lens = PerspectiveLens() lens.setFov(self.fov) lens.setAspectRatio(float(self.size[0]) / float(self.size[1])) lens.setNear(self.zNear) lens.setFar(self.zFar) camNode.setLens(lens) camNode.setScene(self.scene.scene) cam = camera.attachNewNode(camNode) winprops = WindowProperties.size(self.size[0], self.size[1]) fbprops = FrameBufferProperties.getDefault() fbprops = FrameBufferProperties(fbprops) fbprops.setRgbaBits(8, 8, 8, 8) flags = GraphicsPipe.BFFbPropsOptional if self.mode == 'onscreen': flags = flags | GraphicsPipe.BFRequireWindow elif self.mode == 'offscreen': flags = flags | GraphicsPipe.BFRefuseWindow else: raise Exception('Unsupported rendering mode: %s' % (self.mode)) buf = self.graphicsEngine.makeOutput(self.pipe, 'RGB-buffer-Semantics', 0, fbprops, winprops, flags) if buf is None: raise Exception('Unable to create RGB buffer') # Set to render at the end buf.setSort(10000) dr = buf.makeDisplayRegion() dr.setSort(0) dr.setCamera(cam) dr = camNode.getDisplayRegion(0) tex = Texture() tex.setFormat(Texture.FRgba8) tex.setComponentType(Texture.TUnsignedByte) buf.addRenderTexture(tex, GraphicsOutput.RTMCopyRam, GraphicsOutput.RTPColor) # XXX: should use tex.setMatchFramebufferFormat(True)? self.rgbBuffers[camera.getNetTag('agent-id')] = buf self.rgbTextures[camera.getNetTag('agent-id')] = tex
def __init__(self): DebugObject.__init__(self, "ShadowSource") self.valid = False ShadowSource._GlobalShadowIndex += 1 self.index = ShadowSource._GlobalShadowIndex self.camera = Camera("ShadowSource-" + str(self.index)) self.cameraNode = NodePath(self.camera) self.cameraNode.reparentTo(render) # self.camera.showFrustum() self.resolution = 1024 self.atlasPos = Vec2(0) self.doesHaveAtlasPos = False self.sourceIndex = 0 self.mvp = Mat4() self.sourceIndex = -1 self.nearPlane = 0.0 self.farPlane = 1000.0
class ForwardStage(RenderStage): """ Forward shading stage, which first renders all forward objects, and then merges them with the scene """ required_inputs = [ "DefaultEnvmap", "PrefilteredBRDF", "PrefilteredCoatBRDF", "EnvProbes" ] required_pipes = [ "SceneDepth", "ShadedScene", "PerCellProbes", "CellIndices" ] @property def produced_pipes(self): return {"ShadedScene": self.target_merge.color_tex} def create(self): self.forward_cam = Camera("ForwardShadingCam") self.forward_cam.set_lens(Globals.base.camLens) self.forward_cam_np = Globals.base.camera.attach_new_node( self.forward_cam) self.target = self.create_target("ForwardShading") self.target.add_color_attachment(bits=16, alpha=True) self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.forward_cam_np) self.target.set_clear_color(0, 0, 0, 0) self._pipeline.tag_mgr.register_camera("forward", self.forward_cam) self.target_merge = self.create_target("MergeWithDeferred") self.target_merge.add_color_attachment(bits=16) self.target_merge.prepare_buffer() self.target_merge.set_shader_input("ForwardDepth", self.target.depth_tex) self.target_merge.set_shader_input("ForwardColor", self.target.color_tex) def set_shader_input(self, *args): Globals.base.render.set_shader_input(*args) RenderStage.set_shader_input(self, *args) def reload_shaders(self): self.target_merge.shader = self.load_plugin_shader( "merge_with_deferred.frag.glsl")
def create_additional_display_regions(self): self.near_dr = self.win.make_display_region() self.near_dr.set_sort(1) self.near_dr.set_clear_depth_active(True) near_cam_node = Camera('nearcam') self.near_cam = self.camera.attach_new_node(near_cam_node) self.near_dr.setCamera(self.near_cam) self.near_cam.node().set_camera_mask(BaseObject.NearCameraMask) self.near_cam.node().get_lens().set_near_far(units.m /settings.scale, float('inf'))
def __init__(self, *args, **kwargs): Controller.__init__(self, *args, **exclude_from_dict(kwargs, ["camera", "origin"])) self.__base = self._services.graphics.window self.__cam = kwargs["camera"] if "camera" in kwargs else self.__base.cam self.__origin = kwargs["origin"] self.camNode = Camera('cam') self.camNP = NodePath(self.camNode) self.camNP.reparentTo(self.__origin) self.lens = self.__base.camNode.getLens() self.target_size = 6.37800000E+06 self.render_ratio = 1.0e-6 self.deg_per_sec = 60.0 self.min_dist = 3.0 self.max_dist = 4000.0 self.zoom_per_sec = 4 self.longitude_deg = 0.0 self.latitude_deg = -25 self.dist = 10.0 self.key_map = { "left": 0, "right": 0, "up": 0, "down": 0, "wheelup": 0, "wheeldown": 0, "top_view": 0 } self.angle = 0 # EVENTS # # disables the default camera behaviour self.__base.disable_mouse() # Setup down events for arrow keys : rotating camera latitude and longitude self.accept("a", self.update_key_map, ["left", 1]) self.accept("d", self.update_key_map, ["right", 1]) self.accept("w", self.update_key_map, ["up", 1]) self.accept("s", self.update_key_map, ["down", 1]) self.accept("q", self.update_key_map, ["top_view", 1]) self.accept("a-up", self.update_key_map, ["left", 0]) self.accept("d-up", self.update_key_map, ["right", 0]) self.accept("w-up", self.update_key_map, ["up", 0]) self.accept("s-up", self.update_key_map, ["down", 0]) # Use the scroll mouse button/touchpad to zoom in and out self.accept("wheel_up", self.update_key_map, ["wheelup", 1]) self.accept("wheel_down", self.update_key_map, ["wheeldown", 1]) self.__task = self.__base.taskMgr.add(self.move_orbital_camera_task, "move_orbital_camera_task")
def __init__(self): """ Creates a new spot light. """ Light.__init__(self) DebugObject.__init__(self, "SpotLight") self.typeName = "SpotLight" self.nearPlane = 0.5 self.radius = 30.0 self.spotSize = Vec2(30, 30) # Used to compute the MVP self.ghostCamera = Camera("PointLight") self.ghostCamera.setActive(False) self.ghostLens = PerspectiveLens() self.ghostLens.setFov(130) self.ghostCamera.setLens(self.ghostLens) self.ghostCameraNode = NodePath(self.ghostCamera) self.ghostCameraNode.reparentTo(Globals.render) self.ghostCameraNode.hide()
def create(self): self.forward_cam = Camera("ForwardShadingCam") self.forward_cam.set_lens(Globals.base.camLens) self.forward_cam_np = Globals.base.camera.attach_new_node(self.forward_cam) self.target = self.create_target("ForwardShading") self.target.add_color_attachment(bits=16, alpha=True) self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.forward_cam_np) self.target.set_clear_color(0, 0, 0, 0) self._pipeline.tag_mgr.register_camera("forward", self.forward_cam) self.target_merge = self.create_target("MergeWithDeferred") self.target_merge.add_color_attachment(bits=16) self.target_merge.prepare_buffer() self.target_merge.set_shader_inputs( ForwardDepth=self.target.depth_tex, ForwardColor=self.target.color_tex)
class ForwardStage(RenderStage): """ Forward shading stage, which first renders all forward objects, and then merges them with the scene """ required_inputs = ["DefaultEnvmap", "PrefilteredBRDF", "PrefilteredCoatBRDF"] required_pipes = ["SceneDepth", "ShadedScene", "CellIndices"] @property def produced_pipes(self): return {"ShadedScene": self.target_merge.color_tex} def create(self): self.forward_cam = Camera("ForwardShadingCam") self.forward_cam.set_lens(Globals.base.camLens) self.forward_cam_np = Globals.base.camera.attach_new_node(self.forward_cam) self.target = self.create_target("ForwardShading") self.target.add_color_attachment(bits=16, alpha=True) self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.forward_cam_np) self.target.set_clear_color(0, 0, 0, 0) self._pipeline.tag_mgr.register_camera("forward", self.forward_cam) self.target_merge = self.create_target("MergeWithDeferred") self.target_merge.add_color_attachment(bits=16) self.target_merge.prepare_buffer() self.target_merge.set_shader_inputs( ForwardDepth=self.target.depth_tex, ForwardColor=self.target.color_tex) def set_shader_input(self, *args): Globals.base.render.set_shader_input(*args) RenderStage.set_shader_input(self, *args) def set_shader_inputs(self, **kwargs): Globals.base.render.set_shader_inputs(**kwargs) RenderStage.set_shader_inputs(self, **kwargs) def reload_shaders(self): self.target_merge.shader = self.load_plugin_shader("merge_with_deferred.frag.glsl")
class ForwardInjectionStage(RenderStage): """ Forward shading stage, which renders all forward objects and injects them into the clustered grid. Also produces a depth map which is used later on in the shading stage. """ required_inputs = [] required_pipes = [] @property def produced_pipes(self): return {} def create(self): self.forward_cam = Camera("ForwardShadingCam") self.forward_cam.set_lens(Globals.base.camLens) self.forward_cam_np = Globals.base.camera.attach_new_node( self.forward_cam) self.target = self.create_target("ForwardShading") self.target.add_color_attachment(bits=16, alpha=True) self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.forward_cam_np) self.target.set_clear_color(0, 0, 0, 0) self._pipeline.tag_mgr.register_camera("forward", self.forward_cam) self.target_merge = self.create_target("MergeWithDeferred") self.target_merge.add_color_attachment(bits=16) self.target_merge.prepare_buffer() self.target_merge.set_shader_input("ForwardDepth", self.target.depth_tex) self.target_merge.set_shader_input("ForwardColor", self.target.color_tex) def set_shader_input(self, *args): Globals.base.render.set_shader_input(*args) RenderStage.set_shader_input(self, *args) def reload_shaders(self): self.target_merge.shader = self.load_plugin_shader( "merge_with_deferred.frag.glsl")
def __init__(self, env): self.env = env self.cam_node = Camera(self.__class__.__name__.lower()) self.cam_node.setScene(env.NP) self.NP = NodePath(self.cam_node) self.NP.reparentTo(env.NP) self.LENS = self.cam_node.getLens() self.LENS.setFar(_cam.FAR) self.LENS.setFov(base.camLens.getFov()) self.FOCUS = None self.focus_pos = LVector3d(0,0,0) self.sys_pos = LVector3d(0,0,0)
class ForwardInjectionStage(RenderStage): """ Forward shading stage, which renders all forward objects and injects them into the clustered grid. Also produces a depth map which is used later on in the shading stage. """ required_inputs = [] required_pipes = [] @property def produced_pipes(self): return {} def create(self): self.forward_cam = Camera("ForwardShadingCam") self.forward_cam.set_lens(Globals.base.camLens) self.forward_cam_np = Globals.base.camera.attach_new_node(self.forward_cam) self.target = self.create_target("ForwardShading") self.target.add_color_attachment(bits=16, alpha=True) self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.forward_cam_np) self.target.set_clear_color(0, 0, 0, 0) self._pipeline.tag_mgr.register_camera("forward", self.forward_cam) self.target_merge = self.create_target("MergeWithDeferred") self.target_merge.add_color_attachment(bits=16) self.target_merge.prepare_buffer() self.target_merge.set_shader_input("ForwardDepth", self.target.depth_tex) self.target_merge.set_shader_input("ForwardColor", self.target.color_tex) def set_shader_input(self, *args): Globals.base.render.set_shader_input(*args) RenderStage.set_shader_input(self, *args) def reload_shaders(self): self.target_merge.shader = self.load_plugin_shader("merge_with_deferred.frag.glsl")
def create(self): earlyZ = self.pipeline.settings.enableEarlyZ if earlyZ: self.prepassCam = Camera(Globals.base.camNode) self.prepassCam.setTagStateKey("EarlyZShader") self.prepassCam.setName("EarlyZCamera") self.prepassCamNode = Globals.base.camera.attachNewNode(self.prepassCam) Globals.render.setTag("EarlyZShader", "Default") else: self.prepassCam = None # modify default camera initial state initial = Globals.base.camNode.getInitialState() initialNode = NodePath("IntiialState") initialNode.setState(initial) if earlyZ: initialNode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff)) initialNode.setAttrib(DepthTestAttrib.make(DepthTestAttrib.MEqual)) pass else: initialNode.setAttrib(DepthTestAttrib.make(DepthTestAttrib.MLessEqual)) # initialNode.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 10000) # initialNode.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullClockwise), 10000) Globals.base.camNode.setInitialState(initialNode.getState()) self.target = RenderTarget("DeferredScenePass") self.target.addColorAndDepth() self.target.addAuxTextures(3) self.target.setAuxBits(16) self.target.setDepthBits(32) self.target.setCreateOverlayQuad(False) if earlyZ: self.target.prepareSceneRender(earlyZ=True, earlyZCam=self.prepassCamNode) else: self.target.prepareSceneRender() self.target.setClearColor(True, color=Vec4(1, 1, 0, 1)) if earlyZ: self.target.setClearDepth(False) else: self.target.setClearDepth(True)
def create(self): self.forward_cam = Camera("ForwardShadingCam") self.forward_cam.set_lens(Globals.base.camLens) self.forward_cam_np = Globals.base.camera.attach_new_node(self.forward_cam) self.target = self.create_target("ForwardShading") self.target.add_color_attachment(bits=16, alpha=True) self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.forward_cam_np) self.target.set_clear_color(0, 0, 0, 0) self._pipeline.tag_mgr.register_camera("forward", self.forward_cam) self.target_merge = self.create_target("MergeWithDeferred") self.target_merge.add_color_attachment(bits=16) self.target_merge.prepare_buffer() self.target_merge.set_shader_input("ForwardDepth", self.target.depth_tex) self.target_merge.set_shader_input("ForwardColor", self.target.color_tex)
def enterGame(self, task): if self.gameState == self.gameStateDict["Login"]: # responseValue = 1 indicates that this state has been finished if self.responseValue == 1: # Authentication succeeded self.cManager.sendRequest(Constants.CMSG_CREATE_LOBBY, ["raceroyal", "0", "1"]) self.gameState = self.gameStateDict["CreateLobby"] self.responseValue = -1 elif self.gameState == self.gameStateDict["CreateLobby"]: if self.responseValue == 1: # Lobby Created and we are already in self.gameState = self.gameStateDict["EnterGame"] self.responseValue = -1 elif self.responseValue == 0: # Game already created, let's join it self.cManager.sendRequest(Constants.CMSG_ENTER_GAME_NAME, "raceroyal") self.gameState = self.gameStateDict["EnterGame"] self.responseValue = -1 elif self.gameState == self.gameStateDict["EnterGame"]: if self.responseValue == 1: # When the positions are sent, an acknowledgment is sent and we begin the InitializeGame self.responseValue = -1 self.gameState = self.gameStateDict["InitializeGame"] # Everyone is in the game, we send ReqReady, and the server will send positions when every client did self.cManager.sendRequest(Constants.CMSG_READY) elif self.gameState == self.gameStateDict["InitializeGame"]: if self.responseValue == 1: # Set up the camera self.camera = Camera(self.mainChar, self.bulletWorld) self.gameState = self.gameStateDict["BeginGame"] self.cManager.sendRequest(Constants.CMSG_READY) self.responseValue = -1 elif self.gameState == self.gameStateDict["BeginGame"]: if self.responseValue == 1: self.loading.finish() taskMgr.doMethodLater(.1, self.updateMove, 'updateMove') taskMgr.doMethodLater(5, self.move, "moveTask") return task.done return task.cont
def create(self): self._camera = Camera("VXGISunShadowCam") self._cam_lens = OrthographicLens() self._cam_lens.set_film_size(400, 400) self._cam_lens.set_near_far(0.0, 800.0) self._camera.set_lens(self._cam_lens) self._cam_node = Globals.base.render.attach_new_node(self._camera) self._target = self.make_target("PSSMDistShadowMap") self._target.set_source(self._cam_node, Globals.base.win) self._target.size = self._resolution self._target.add_depth_texture(bits=32) self._target.create_overlay_quad = False self._target.color_write = False self._target.prepare_scene_render() # Register shadow camera self._pipeline.tag_mgr.register_shadow_camera(self._camera)
def __init__(self): """ Creates a new ShadowSource. After the creation, a lens can be added with setupPerspectiveLens. """ self.index = self._generateUID() DebugObject.__init__(self, "ShadowSource-" + str(self.index)) ShaderStructElement.__init__(self) self.valid = False self.camera = Camera("ShadowSource-" + str(self.index)) self.cameraNode = NodePath(self.camera) self.cameraNode.reparentTo(Globals.render) self.resolution = 1024 self.atlasPos = Vec2(0) self.doesHaveAtlasPos = False self.sourceIndex = 0 self.mvp = Mat4() self.sourceIndex = -1 self.nearPlane = 0.0 self.farPlane = 1000.0 self.converterYUR = None
def init(self): for i in range(self._max_updates): camera = Camera("ShadowCam-" + str(i)) camera.set_lens(MatrixLens()) camera.set_active(False) camera.set_scene(self._scene_parent) self._tag_state_mgr.register_shadow_camera(camera) self._camera_nps.append(self._scene_parent.attach_new_node(camera)) self._cameras.append(camera) region = self._atlas_graphics_output.make_display_region() region.set_sort(1000) region.set_clear_depth_active(True) region.set_clear_depth(1.0) region.set_clear_color_active(False) region.set_camera(self._camera_nps[i]) region.set_active(False) self._display_regions.append(region) self._atlas = ShadowAtlas(self._atlas_size)
def create(self): # Create voxelize camera self.voxelizeCamera = Camera("VoxelizeScene") self.voxelizeCamera.setCameraMask(BitMask32.bit(4)) self.voxelizeCameraNode = Globals.render.attachNewNode(self.voxelizeCamera) self.voxelizeLens = OrthographicLens() self.voxelizeLens.setFilmSize(self.voxelGridSize.x*2, self.voxelGridSize.y*2) self.voxelizeLens.setNearFar(0.0, self.voxelGridSize.x*2) self.voxelizeCamera.setLens(self.voxelizeLens) self.voxelizeCamera.setTagStateKey("VoxelizePassShader") Globals.render.setTag("VoxelizePassShader", "Default") # Create voxelize tareet self.target = RenderTarget("VoxelizePass") self.target.setSize( self.voxelGridResolution.x * 4 ) self.target.setColorWrite(False) self.target.setCreateOverlayQuad(False) self.target.setSource(self.voxelizeCameraNode, Globals.base.win) self.target.prepareSceneRender() self.target.setActive(False) self.target.getInternalRegion().setSort(-400) self.target.getInternalBuffer().setSort(-399)
def _make_particle_scene(self): # Create a new scene root self._particle_scene = Globals.base.render.attach_new_node("CloudParticles") self._particle_scene.hide(self._pipeline.tag_mgr.get_gbuffer_mask()) self._particle_scene.hide(self._pipeline.tag_mgr.get_shadow_mask()) self._particle_scene.hide(self._pipeline.tag_mgr.get_voxelize_mask()) cm = CardMaker("") cm.set_frame(-1.0, 1.0, -1.0, 1.0) cm.set_has_normals(False) cm.set_has_uvs(False) card_node = cm.generate() card_node.set_bounds(OmniBoundingVolume()) card_node.set_final(True) self._particle_np = self._particle_scene.attach_new_node(card_node) self._particle_np.set_shader_input("CloudVoxels", self._cloud_voxels.get_texture()) self._particle_np.set_instance_count(self._voxel_res_xy * self._voxel_res_xy * self._voxel_res_z) self._particle_np.set_transparency(TransparencyAttrib.M_multisample, 1000000) self._particle_scene.set_transparency(TransparencyAttrib.M_multisample, 1000000) self._particle_cam = Camera("CloudParticleCam") self._particle_cam.set_lens(Globals.base.camLens) self._particle_cam_np = self._particle_scene.attach_new_node(self._particle_cam) cloud_particle_mask = BitMask32.bit(16) self._particle_cam.set_camera_mask(cloud_particle_mask) render.hide(cloud_particle_mask) self._particle_scene.show_through(cloud_particle_mask) self._particle_target = self._create_target("Clouds:RenderParticles") self._particle_target.add_color_texture(bits=16) self._particle_target.set_source(self._particle_cam_np, Globals.base.win) self._particle_target.set_enable_transparency(True) self._particle_target.prepare_scene_render() self._particle_target.set_clear_color(True, color=Vec4(0, 0, 0, 0))
class ShadowSource(DebugObject, ShaderStructElement): """ This class can be seen as a camera. It stores the necessary data to generate and store the shadow map for the assigned lens (like computing the MVP), and also stores information about the shadowmap, like position in the shadow atlas, or resolution. Each ShadowSource has a unique index, which is used by the LightClass to identify which sources belong to it. TODO: Support OrtographicLens """ # Store a global index for assigning unique ids to the instances _GlobalShadowIndex = 1000 @classmethod def getExposedAttributes(self): return { "resolution": "int", "atlasPos": "vec2", "mvp": "mat4", "nearPlane": "float", "farPlane": "float" } @classmethod def _generateUID(self): """ Generates an uid and returns that """ self._GlobalShadowIndex += 1 return self._GlobalShadowIndex def __init__(self): """ Creates a new ShadowSource. After the creation, a lens can be added with setupPerspectiveLens. """ self.index = self._generateUID() DebugObject.__init__(self, "ShadowSource-" + str(self.index)) ShaderStructElement.__init__(self) self.valid = False self.camera = Camera("ShadowSource-" + str(self.index)) self.cameraNode = NodePath(self.camera) self.cameraNode.reparentTo(Globals.render) self.resolution = 1024 self.atlasPos = Vec2(0) self.doesHaveAtlasPos = False self.sourceIndex = 0 self.mvp = Mat4() self.sourceIndex = -1 self.nearPlane = 0.0 self.farPlane = 1000.0 self.converterYUR = None def getSourceIndex(self): """ Returns the assigned source index. The source index is the index of the ShadowSource in the ShadowSources array of the assigned Light. """ return self.sourceIndex def getUid(self): """ Returns the uid of the light """ return self.index def setSourceIndex(self, index): """ Sets the source index of this source. This is called by the light, as only the light knows at which position this source is in the Sources array. """ self.sourceIndex = index def computeMVP(self): """ Computes the modelViewProjection matrix for the lens. Actually, this is the worldViewProjection matrix, but for convenience it is called mvp. """ projMat = self.converterYUR transformMat = TransformState.makeMat( Mat4.convertMat(Globals.base.win.getGsg().getInternalCoordinateSystem(), CSZupRight)) modelViewMat = transformMat.invertCompose( Globals.render.getTransform(self.cameraNode)).getMat() self.mvp = UnalignedLMatrix4f(modelViewMat * projMat) def assignAtlasPos(self, x, y): """ Assigns this source a position in the shadow atlas. This is called by the shadow atlas. Coordinates are float from 0 .. 1 """ self.atlasPos = Vec2(x, y) self.doesHaveAtlasPos = True def update(self): """ Updates the shadow source. Currently only recomputes the mvp. """ self.computeMVP() def getAtlasPos(self): """ Returns the assigned atlas pos, if present. Coordinates are float from 0 .. 1 """ return self.atlasPos def hasAtlasPos(self): """ Returns wheter this ShadowSource has already a position in the shadow atlas """ return self.doesHaveAtlasPos def removeFromAtlas(self): """ Deletes the atlas coordinates, called by the atlas after the Source got removed from the atlas """ self.doesHaveAtlasPos = False self.atlasPos = Vec2(0) def setResolution(self, resolution): """ Sets the resolution in pixels of this shadow source. Has to be a multiple of the tileSize specified in LightManager """ assert(resolution > 1 and resolution <= 8192) self.resolution = resolution def getResolution(self): """ Returns the resolution of the shadow source in pixels """ return self.resolution def setupPerspectiveLens(self, near=0.1, far=100.0, fov=(90, 90)): """ Setups a PerspectiveLens with a given nearPlane, farPlane and FoV. The FoV is a tuple in the format (Horizontal FoV, Vertical FoV) """ # self.debug("setupPerspectiveLens(",near,",",far,",",fov,")") self.lens = PerspectiveLens() self.lens.setNearFar(near, far) self.lens.setFov(fov[0], fov[1]) self.camera.setLens(self.lens) self.nearPlane = near self.farPlane = far self.rebuildMatrixCache() def setupOrtographicLens(self, near=0.1, far=100.0, filmSize=(512, 512)): """ Setups a OrtographicLens with a given nearPlane, farPlane and filmSize. The filmSize is a tuple in the format (filmWidth, filmHeight) in world space. """ # self.debug("setupOrtographicLens(",near,",",far,",",filmSize,")") self.lens = OrtographicLens() self.lens.setNearFar(near, far) self.lens.setFilmSize(*filmSize) self.camera.setLens(self.lens) self.nearPlane = near self.farPlane = far self.rebuildMatrixCache() def rebuildMatrixCache(self): """ Computes values frequently used to compute the mvp """ self.converterYUR = Mat4.convertMat(CSYupRight, self.lens.getCoordinateSystem()) * self.lens.getProjectionMat() def setPos(self, pos): """ Sets the position in world space """ self.cameraNode.setPos(pos) def setHpr(self, hpr): """ Sets the rotation in world space """ self.cameraNode.setHpr(hpr) def lookAt(self, pos): """ Looks at a point (in world space) """ self.cameraNode.lookAt(pos.x, pos.y, pos.z) def invalidate(self): """ Invalidates this shadow source, means telling the LightManager that the shadow map for this light should be rebuilt. Otherwise it won't get refreshed """ self.valid = False def setValid(self): """ The LightManager calls this after the shadow map got updated successfully """ self.valid = True def isValid(self): """ Returns wether the shadow map is still valid or should be refreshed """ return self.valid def __repr__(self): """ Returns a representative string of this instance """ return "ShadowSource[id=" + str(self.index) + "]"
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)
class PSSMSceneShadowStage(RenderStage): """ This stage creates the shadow map which covers the whole important part of the scene. This is required because the shadow cascades only cover the view frustum, but many plugins (VXGI, EnvMaps) require a shadow map. """ required_inputs = [] required_pipes = [] def __init__(self, pipeline): RenderStage.__init__(self, pipeline) self.resolution = 2048 self.sun_vector = Vec3(0, 0, 1) self.sun_distance = 10.0 self.pta_mvp = PTAMat4.empty_array(1) self.focus = None # Store last focus entirely for the purpose of being able to see # it in the debugger self.last_focus = None @property def produced_inputs(self): return {"PSSMSceneSunShadowMVP": self.pta_mvp} @property def produced_pipes(self): return {"PSSMSceneSunShadowMapPCF": (self.target.depth_tex, self.make_pcf_state())} def make_pcf_state(self): state = SamplerState() state.set_minfilter(SamplerState.FT_shadow) state.set_magfilter(SamplerState.FT_shadow) return state def request_focus(self, focus_point, focus_size): self.focus = (focus_point, focus_size) self.last_focus = self.focus @property def mvp(self): return Globals.base.render.get_transform(self.cam_node).get_mat() * \ self.cam_lens.get_projection_mat() def update(self): if self._pipeline.task_scheduler.is_scheduled("pssm_scene_shadows"): if self.focus is None: # When no focus is set, there is no point in rendering the shadow map self.target.active = False else: focus_point, focus_size = self.focus self.cam_lens.set_near_far(0.0, 2 * (focus_size + self.sun_distance)) self.cam_lens.set_film_size(2 * focus_size, 2 * focus_size) self.cam_node.set_pos( focus_point + self.sun_vector * (self.sun_distance + focus_size)) self.cam_node.look_at(focus_point) snap_shadow_map(self.mvp, self.cam_node, self.resolution) self.target.active = True self.pta_mvp[0] = self.mvp self.focus = None else: self.target.active = False def create(self): self.camera = Camera("PSSMSceneSunShadowCam") self.cam_lens = OrthographicLens() self.cam_lens.set_film_size(400, 400) self.cam_lens.set_near_far(100.0, 1800.0) self.camera.set_lens(self.cam_lens) self.cam_node = Globals.base.render.attach_new_node(self.camera) self.target = self.create_target("ShadowMap") self.target.size = self.resolution self.target.add_depth_attachment(bits=32) self.target.prepare_render(self.cam_node) # Register shadow camera self._pipeline.tag_mgr.register_camera("shadow", self.camera) def set_shader_input(self, *args): Globals.render.set_shader_input(*args) def set_shader_inputs(self, **kwargs): Globals.render.set_shader_inputs(**kwargs)
class VoxelizationStage(RenderStage): """ This stage voxelizes the whole scene """ required_inputs = ["DefaultEnvmap", "AllLightsData", "maxLightIndex"] required_pipes = [] # The different states of voxelization S_disabled = 0 S_voxelize_x = 1 S_voxelize_y = 2 S_voxelize_z = 3 S_gen_mipmaps = 4 def __init__(self, pipeline): RenderStage.__init__(self, pipeline) self.voxel_resolution = 256 self.voxel_world_size = -1 self.state = self.S_disabled self.create_ptas() def set_grid_position(self, pos): self.pta_next_grid_pos[0] = pos def create_ptas(self): self.pta_next_grid_pos = PTALVecBase3.empty_array(1) self.pta_grid_pos = PTALVecBase3.empty_array(1) @property def produced_inputs(self): return {"voxelGridPosition": self.pta_grid_pos} @property def produced_pipes(self): return {"SceneVoxels": self.voxel_grid} 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 update(self): self.voxel_cam_np.show() self.voxel_target.active = True self.copy_target.active = False for target in self.mip_targets: target.active = False # Voxelization disable if self.state == self.S_disabled: self.voxel_cam_np.hide() self.voxel_target.active = False # Voxelization from X-Axis elif self.state == self.S_voxelize_x: # Clear voxel grid self.voxel_temp_grid.clear_image() self.voxel_cam_np.set_pos( self.pta_next_grid_pos[0] + Vec3(self.voxel_world_size, 0, 0)) self.voxel_cam_np.look_at(self.pta_next_grid_pos[0]) # Voxelization from Y-Axis elif self.state == self.S_voxelize_y: self.voxel_cam_np.set_pos( self.pta_next_grid_pos[0] + Vec3(0, self.voxel_world_size, 0)) self.voxel_cam_np.look_at(self.pta_next_grid_pos[0]) # Voxelization from Z-Axis elif self.state == self.S_voxelize_z: self.voxel_cam_np.set_pos( self.pta_next_grid_pos[0] + Vec3(0, 0, self.voxel_world_size)) self.voxel_cam_np.look_at(self.pta_next_grid_pos[0]) # Generate mipmaps elif self.state == self.S_gen_mipmaps: self.voxel_target.active = False self.copy_target.active = True self.voxel_cam_np.hide() for target in self.mip_targets: target.active = True # As soon as we generate the mipmaps, we need to update the grid position # as well self.pta_grid_pos[0] = self.pta_next_grid_pos[0] def reload_shaders(self): self.copy_target.shader = self.load_plugin_shader( "/$$rp/shader/default_post_process_instanced.vert.glsl", "copy_voxels.frag.glsl") mip_shader = self.load_plugin_shader( "/$$rp/shader/default_post_process_instanced.vert.glsl", "generate_mipmaps.frag.glsl") for target in self.mip_targets: target.shader = mip_shader def set_shader_input(self, *args): Globals.render.set_shader_input(*args)