def __init__(self, id = 0, plane = Plane(0, 0, 1, 0), solid = None): MapWritable.__init__(self, base.document) self.id = id self.material = FaceMaterial() self.vertices = [] self.isSelected = False self.plane = plane self.solid = solid self.hasGeometry = False self.vdata = None # Different primitive representations of this face. self.geom3D = None self.geom3DLines = None self.geom2D = None # Index into the Solid's GeomNode of the Geoms we render for this face. self.index3D = -1 self.index3DLines = -1 self.index2D = -1 # RenderState for each Geom we render for this face. self.state3D = RenderState.makeEmpty() self.state3DLines = RenderState.make(AntialiasAttrib.make(AntialiasAttrib.MLine), ColorAttrib.makeFlat(Vec4(1, 1, 0, 1))) self.state2D = RenderState.makeEmpty() if solid: self.setColor(self.solid.color) # Not None if face is a displacement. self.dispInfo = None
def step(self): self.rotate_light() self.graphicsEngine.renderFrame() image = self.get_camera_image() TransformState.garbageCollect() RenderState.garbageCollect() return
def _clear_state_cache(self, task=None): """ Task which repeatedly clears the state cache to avoid storing unused states. """ task.delayTime = 2.0 TransformState.clear_cache() RenderState.clear_cache() return task.again
def newGame(): global thickness thickness=1 render.setState(RenderState.makeEmpty()) model.setState(RenderState.makeEmpty()) func5() print('NEW GAME')
def step(self, action): dt = 1/self.fps self.framecount += 1 max_dist = 1.1 # Move finger finger_max_speed = 2 finger_accel = 10.0 finger_deccel = 10.0 self.action_buffer.pop(0) self.action_buffer.append(action) action = self.action_buffer[0] if action == 0: self.finger_speed_mps += dt * finger_accel if self.finger_speed_mps > finger_max_speed: self.finger_speed_mps = 2 if action == 1: if self.finger_speed_mps > 0.01: self.finger_speed_mps -= finger_deccel * dt if self.finger_speed_mps < -0.01: self.finger_speed_mps += finger_deccel * dt if action == 2: self.finger_speed_mps -= dt * finger_accel if self.finger_speed_mps < -finger_max_speed: self.finger_speed_mps = -finger_max_speed real_displacement = self.finger_speed_mps * dt self.finger_np.setY(self.finger_np.getY() + real_displacement) if self.finger_np.getY() > max_dist: self.finger_np.setY(max_dist) self.finger_speed_mps = 0 if self.finger_np.getY() < -max_dist: self.finger_np.setY(-max_dist) self.finger_speed_mps = 0 # self.world.doPhysics(dt, 5, 1.0/120.0) self.world.doPhysics(dt, 20, 1.0/240.0) self.reset_conv() self.check_teleportable(blocks_per_minute=59) # Keep the conveyor moving self.conv_np.node().setLinearVelocity(Vec3(1.0, 0.0, 0.0)) if self.human_playable is False: self.graphicsEngine.renderFrame() TransformState.garbageCollect() RenderState.garbageCollect() image = self.get_camera_image() else: image = None score = 0 score += self.check_rewards() done = False return image, score, done
def _checkForStateClear(self): """ This method regulary clears the state cache """ if not hasattr(self, "lastStateClear"): self.lastStateClear = 0 if Globals.clock.getFrameTime() - self.lastStateClear > self.settings.stateCacheClearInterval: RenderState.clearCache() TransformState.clearCache() self.lastStateClear = Globals.clock.getFrameTime()
def _clear_state_cache(self, task=None): """ Task which repeatedly clears the state cache to avoid storing unused states. While running once a while, this task prevents over-polluting the state-cache with unused states. This complements Panda3D's internal state garbarge collector, which does a great job, but still cannot clear up all states. """ task.delayTime = 2.0 TransformState.clear_cache() RenderState.clear_cache() return task.again
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 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 _update_stats(self): """ Updates the stats overlay """ clock = Globals.clock self._debug_lines[0].set_text("{:3.0f} fps | {:3.1f} ms | {:3.1f} ms max".format( clock.get_average_frame_rate(), 1000.0 / max(0.001, clock.get_average_frame_rate()), clock.get_max_frame_duration() * 1000.0)) text = "{:4d} render states | {:4d} transforms" text += " | {:4d} commands | {:6d} lights | {:5d} shadow sources" self._debug_lines[1].set_text(text.format( RenderState.get_num_states(), TransformState.get_num_states(), self._pipeline.light_mgr.get_cmd_queue().get_num_processed_commands(), self._pipeline.light_mgr.get_num_lights(), self._pipeline.light_mgr.get_num_shadow_sources(), )) text = "{:3.0f} MiB VRAM usage | {:5d} images | {:5d} textures | " text += "{:5d} render targets | {:3d} plugins" tex_info = self._buffer_viewer.get_stage_information() self._debug_lines[2].set_text(text.format( tex_info["memory"] / (1024**2) , Image._NUM_IMAGES, tex_info["count"], RenderTarget._NUM_BUFFERS_ALLOCATED, self._pipeline.plugin_mgr.get_interface().get_active_plugin_count() )) text = "{} ({:1.3f}) | {:3d} active constraints" self._debug_lines[3].set_text(text.format( self._pipeline.daytime_mgr.get_time_str(), self._pipeline.daytime_mgr.get_time(), self._pipeline.daytime_mgr.get_num_constraints() ))
def unregister_camera(self, container, source): if source not in container.cameras: print("Could not remove source, was never attached!") return container.cameras.remove(source) source.clear_tag_states() source.set_initial_state(RenderState.make_empty())
def addFace(self, meshVertices, state=RenderState.makeEmpty()): row = self.vwriter.getWriteRow() for vert in meshVertices: self.vwriter.setData3f(vert.pos) self.nwriter.setData3f(vert.normal) self.twriter.setData2f(vert.texcoord) for view in self.views: view.generateIndices()
def _initModels(self): models = [] for model in self.scene.scene.findAllMatches( '**/objects/**/+ModelNode'): models.append(model) for model in self.scene.scene.findAllMatches( '**/layouts/**/+ModelNode'): models.append(model) for model in models: objectNp = model.getParent() rendererNp = objectNp.attachNewNode('render-semantics') model = model.copyTo(rendererNp) # Set the model to be visible only to this camera model.node().adjustDrawMask(self.cameraMask, self.cameraMask, self.cameraMask) model.show() # Get semantic-related color of model modelId = model.getNetTag('model-id') if 'fr_' in modelId: if modelId.endswith('c'): catName = 'ceiling' elif modelId.endswith('f'): catName = 'floor' elif modelId.endswith('w'): catName = 'wall' else: pass catName = self.categoryMapping.getFineGrainedCategoryForModelId( modelId) color = MODEL_CATEGORY_COLOR_MAPPING[catName] # Clear all GeomNode render attributes and set a specified flat color for nodePath in model.findAllMatches('**/+GeomNode'): geomNode = nodePath.node() for n in range(geomNode.getNumGeoms()): geomNode.setGeomState( n, RenderState.make( ColorAttrib.makeFlat( LColor(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0, 1.0)), 1)) # Disable lights for this model model.setLightOff(1) # Enable antialiasing model.setAntialias(AntialiasAttrib.MAuto) # Reparent render node below the existing physic node (if any) physicsNp = objectNp.find('**/physics') if not physicsNp.isEmpty(): rendererNp.reparentTo(physicsNp)
def DoubleSidedNoZ(): global _DoubleSidedNoZ if not _DoubleSidedNoZ: _DoubleSidedNoZ = RenderState.make( CullFaceAttrib.make(CullFaceAttrib.MCullNone), DepthTestAttrib.make(DepthTestAttrib.MOff), DepthWriteAttrib.make(DepthWriteAttrib.MOff), CullBinAttrib.make("fixed", LEGlobals.WidgetSort)) return _DoubleSidedNoZ
def unregister_camera(self, container_name, source): container = self.containers[container_name] if source not in container.cameras: print("Could not remove source, was never attached!") return container.cameras.remove(source) source.clear_tag_states() source.set_initial_state(RenderState.make_empty())
def update_serialized_material(self, data): """ Internal method to update a material from a given serialized material """ name = data[0] for i, material in enumerate(Globals.render.find_all_materials()): if self._get_serialized_material_name(material, i) == name: material.set_base_color(Vec4(float(data[1]), float(data[2]), float(data[3]), 1.0)) material.set_roughness(float(data[4])) material.set_refractive_index(float(data[5])) material.set_metallic(float(data[6])) material.set_emission(Vec4( float(data[7]), float(data[8]), float(data[9]), float(data[10]), )) RenderState.clear_cache()
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 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 update_serialized_material(self, data): """ Internal method to update a material from a given serialized material """ name = data[0] for i, material in enumerate(Globals.render.find_all_materials()): if self._get_serialized_material_name(material, i) == name: material.set_base_color( Vec4(float(data[1]), float(data[2]), float(data[3]), 1.0)) material.set_roughness(float(data[4])) material.set_refractive_index(float(data[5])) material.set_metallic(float(data[6])) material.set_emission( Vec4( float(data[7]), float(data[8]), float(data[9]), float(data[10]), )) RenderState.clear_cache()
def DashedLineNoZ(): global _DashedLineNoZ if not _DashedLineNoZ: shattr = getStippleShader() _DashedLineNoZ = RenderState.make( shattr, DepthTestAttrib.make(DepthTestAttrib.MOff), DepthWriteAttrib.make(DepthWriteAttrib.MOff), CullFaceAttrib.make(CullFaceAttrib.MCullNone), ) _DashedLineNoZ = _DashedLineNoZ.setAttrib(CullBinAttrib.make("fixed", LEGlobals.BoxSort)) return _DashedLineNoZ
def __init__(self): assert engine_initialized( ), "You should initialize engine before adding camera to vehicle" config = get_global_config()["vehicle_config"]["depth_camera"] self.BUFFER_W, self.BUFFER_H = config[0], config[1] self.VIEW_GROUND = config[2] super(DepthCamera, self).__init__() cam = self.get_cam() lens = self.get_lens() cam.lookAt(0, 2.4, 1.3) lens.setFov(60) lens.setAspectRatio(2.0) if get_engine( ).mode == RENDER_MODE_NONE or not AssetLoader.initialized(): return # add shader for it if get_global_config()["headless_machine_render"]: vert_path = AssetLoader.file_path("shaders", "depth_cam_gles.vert.glsl") frag_path = AssetLoader.file_path("shaders", "depth_cam_gles.frag.glsl") else: from pgdrive.utils import is_mac if is_mac(): vert_path = AssetLoader.file_path("shaders", "depth_cam_mac.vert.glsl") frag_path = AssetLoader.file_path("shaders", "depth_cam_mac.frag.glsl") else: vert_path = AssetLoader.file_path("shaders", "depth_cam.vert.glsl") frag_path = AssetLoader.file_path("shaders", "depth_cam.frag.glsl") custom_shader = Shader.load(Shader.SL_GLSL, vertex=vert_path, fragment=frag_path) cam.node().setInitialState( RenderState.make(ShaderAttrib.make(custom_shader, 1))) if self.VIEW_GROUND: self.GROUND = GeoMipTerrain("mySimpleTerrain") self.GROUND.setHeightfield( AssetLoader.file_path("textures", "height_map.png")) # terrain.setBruteforce(True) # # Since the terrain is a texture, shader will not calculate the depth information, we add a moving terrain # # model to enable the depth information of terrain self.GROUND_MODEL = self.GROUND.getRoot() self.GROUND_MODEL.setPos(-128, 0, self.GROUND_HEIGHT) self.GROUND_MODEL.hide(CamMask.AllOn) self.GROUND_MODEL.show(CamMask.DepthCam) self.GROUND.generate()
def removeEverything(self): for task in self.taskMgr.getTasks(): if task.getName() not in ['dataLoop', 'igLoop']: task.remove() camera.reparentTo(render) for tex in render.findAllTextures(): tex.releaseAll() for tex in aspect2d.findAllTextures(): tex.releaseAll() for tex in render2d.findAllTextures(): tex.releaseAll() for tex in hidden.findAllTextures(): tex.releaseAll() for node in render.findAllMatches("**;+s"): node.removeNode() for node in aspect2d.findAllMatches("**;+s"): node.removeNode() for node in render2d.findAllMatches("**;+s"): node.removeNode() for node in hidden.findAllMatches("**;+s"): node.removeNode() TexturePool.garbageCollect() ModelPool.garbageCollect() RenderState.garbageCollect() RenderState.clearCache() RenderState.clearMungerCache() self.win.getGsg().getPreparedObjects().releaseAll() self.graphicsEngine.renderFrame()
def _update_stats(self, task=None): """ Updates the stats overlay """ clock = Globals.clock self._debug_lines[0].text = "{:3.0f} fps | {:3.1f} ms | {:3.1f} ms max".format( clock.get_average_frame_rate(), 1000.0 / max(0.001, clock.get_average_frame_rate()), clock.get_max_frame_duration() * 1000.0) text = "{:4d} render states | {:4d} transforms" text += " | {:4d} commands | {:4d} lights | {:5d} shadow sources " text += "| {:3.1f}% atlas usage" self._debug_lines[1].text = text.format( RenderState.get_num_states(), TransformState.get_num_states(), self._pipeline.light_mgr.cmd_queue.num_processed_commands, self._pipeline.light_mgr.num_lights, self._pipeline.light_mgr.num_shadow_sources, self._pipeline.light_mgr.shadow_atlas_coverage) text = "Pipeline: {:3.0f} MiB VRAM | {:5d} images | {:5d} textures | " text += "{:5d} render targets | {:3d} plugins" tex_memory, tex_count = self._buffer_viewer.stage_information self._debug_lines[2].text = text.format( tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count, RenderTarget.NUM_ALLOCATED_BUFFERS, len(self._pipeline.plugin_mgr.enabled_plugins)) text = "Scene: {:4.0f} MiB VRAM | {:3d} textures | {:4d} geoms " text += "| {:4d} nodes | {:7,.0f} vertices | {:5.0f} MiB vTX data " scene_tex_size = 0 for tex in TexturePool.find_all_textures(): scene_tex_size += tex.estimate_texture_memory() self._debug_lines[3].text = text.format( scene_tex_size / (1024**2), len(TexturePool.find_all_textures()), self._analyzer.get_num_geoms(), self._analyzer.get_num_nodes(), self._analyzer.get_num_vertices(), self._analyzer.get_vertex_data_size() / (1024**2), ) text = "{} ({:1.3f}) | {:3d} daytime settings | X {:3.1f} Y {:3.1f} Z {:3.1f}" self._debug_lines[4].text = text.format( self._pipeline.daytime_mgr.formatted_time, self._pipeline.daytime_mgr.time, len(self._pipeline.plugin_mgr.day_settings), Globals.base.camera.get_x(Globals.base.render), Globals.base.camera.get_y(Globals.base.render), Globals.base.camera.get_z(Globals.base.render),) if task: return task.again
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 __init__(self): self.enabled = True sMgr = CIGlobals.getSettingsMgr() reso = sMgr.ReflectionQuality[sMgr.getSetting("refl").getValue()] if reso == 0: self.enabled = False return self.waterPlaneNP = None self.waterNodes = [] # Buffer and reflection camera buffer = base.win.makeTextureBuffer('waterBuffer', reso, reso) buffer.setClearColor(Vec4(0, 0, 0, 1)) cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) self.watercamNP = base.makeCamera(buffer) self.watercamNP.reparentTo(render) self.makePlane(0.0) cam = self.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(1) cam.getLens().setFar(5000) cam.setInitialState(rs) cam.setTagStateKey('Clipped') self.ts0 = TextureStage("tex_0") self.tex0 = buffer.getTexture() self.tex0.setWrapU(Texture.WMClamp) self.tex0.setWrapV(Texture.WMClamp) self.ts1 = TextureStage("tex_1") self.waterTex = loader.loadTexture('phase_3/maps/water_distort.png') self.waterQuad = None self.waterStage = TextureStage("waterStage") image0 = OnscreenImage(image=self.tex0, scale=0.3, pos=(-0.5, 0, 0.7)) image1 = OnscreenImage(image=waterTex, scale=0.3, pos=(0.5, 0, 0.7)) taskMgr.add(self.update, "waterTask")
def gen_arc_left(self, left_side, radius, end_radius, orig_radius, arc, x3, y3, z3, new_z1, new_z2, segment_shape): left_surface = self.surfaces[left_side["surface"]] start_width = left_side["start_width"] end_width = left_side["end_width"] left_section = geom.make_circle( self.cur_x1, self.cur_y1, self.cur_z1, self.cur_x1 + (x3 * start_width), self.cur_y1 + (y3 * start_width), self.cur_z1 + (z3 * start_width), radius + orig_radius, end_radius + orig_radius, arc, new_z1, new_z2, left_surface["len"], left_surface["width"], end_width, False)[0] tex_attr = TextureAttrib.make(left_surface["tex"]) state = RenderState.make(tex_attr) self.snode.addGeom(left_section, state) self.mesh.addGeom(left_section) segment_shape.addGeom(left_section)
def gen_arc_right(self, right_side, radius, end_radius, orig_radius, arc, x3, y3, z3, new_z1, new_z2, segment_shape): right_surface = self.surfaces[right_side["surface"]] start_width = right_side["start_width"] end_width = right_side["end_width"] right_section = \ geom.make_circle(self.cur_x2 - (x3 * start_width), self.cur_y2 - (y3 * start_width), self.cur_z1 - (z3 * start_width), self.cur_x2, self.cur_y2, self.cur_z2, radius - orig_radius, end_radius - orig_radius, arc, new_z1, new_z2, right_surface["len"], right_surface["width"], end_width, True)[0] tex_attr = TextureAttrib.make(right_surface["tex"]) state = RenderState.make(tex_attr) self.snode.addGeom(right_section, state) self.mesh.addGeom(right_section) segment_shape.addGeom(right_section)
def create_cam(cls): cls.create_buffer() if cls.watercamNP is None: cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) cls.watercamNP = base.makeCamera(cls.buffer) cls.watercamNP.reparentTo(render) #sa = ShaderAttrib.make() #sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') ) cam = cls.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(1) cam.getLens().setFar(5000) cam.setInitialState(rs) cam.setTagStateKey('Clipped')
def gen_str_left(self, segment, left_side, x3, y3, x4, y4, z4, new_z1, segment_shape): left_surface = self.surfaces[left_side["surface"]] start_width = left_side["start_width"] end_width = left_side["end_width"] left_section = geom.make_square( self.cur_x1 + (x4 * start_width), self.cur_y1 + (y4 * start_width), self.cur_z1 + (z4 * start_width), self.cur_x1, self.cur_y1, self.cur_z1, self.cur_x1 + (x3 * segment["length"]), self.cur_y1 + (y3 * segment["length"]), new_z1, self.cur_x1 + (x3 * segment["length"]) + (x4 * end_width), self.cur_y1 + (y3 * segment["length"]) + (y4 * end_width), new_z1 + (z4 * end_width), left_surface["len"], left_surface["width"]) tex_attr = TextureAttrib.make(left_surface["tex"]) state = RenderState.make(tex_attr) self.snode.addGeom(left_section, state) self.mesh.addGeom(left_section) segment_shape.addGeom(left_section)
def gen_str_right(self, segment, right_side, x3, y3, x4, y4, new_z2, segment_shape): right_surface = self.surfaces[right_side["surface"]] start_width = right_side["start_width"] end_width = right_side["end_width"] right_section = geom.make_square( self.cur_x2, self.cur_y2, self.cur_z2, self.cur_x2 - (x4 * start_width), self.cur_y2 - (y4 * start_width), self.cur_z2, self.cur_x2 + (x3 * segment["length"]) - (x4 * end_width), self.cur_y2 + (y3 * segment["length"]) - (y4 * end_width), new_z2, self.cur_x2 + (x3 * segment["length"]), self.cur_y2 + (y3 * segment["length"]), new_z2, right_surface["len"], right_surface["width"]) tex_attr = TextureAttrib.make(right_surface["tex"]) state = RenderState.make(tex_attr) self.snode.addGeom(right_section, state) self.mesh.addGeom(right_section) segment_shape.addGeom(right_section)
def doSceneCleanup(): from panda3d.core import ModelPool, TexturePool, RenderState, RenderAttrib, TransformState, GeomCacheManager ModelPool.garbageCollect() TexturePool.garbageCollect() RenderState.clearMungerCache() RenderState.clearCache() RenderState.garbageCollect() RenderAttrib.garbageCollect() TransformState.clearCache() TransformState.garbageCollect() GeomCacheManager.getGlobalPtr().flush() base.graphicsEngine.renderFrame()
def update(self): if self.memUsageText: memstr = str( round(MemoryMonitor.getEstimatedMemUsage() / 1024.0 / 1024.0, 2)) numTextureBytes = 0 renderTextures = Globals.render.findAllTextures() for tex in renderTextures: numTextureBytes += MemoryMonitor._calculateTexSize(tex) texstr = str(round(numTextureBytes / 1024.0 / 1024.0, 2)) otherTextures = TexturePool.findAllTextures() numOtherBytes = 0 for tex in otherTextures: if tex not in renderTextures: numOtherBytes += MemoryMonitor._calculateTexSize(tex) otherstr = str(round(numOtherBytes / 1024.0 / 1024.0, 2)) self.memUsageText.setText("VRAM Usage: " + memstr + " MB / Textures: " + texstr + " MB / Other: " + otherstr + " MB") if self.fpsText: clock = Globals.clock self.fpsText.setText( "Frame time over {:3.1f}s Avg: {:3.2f} Max: {:3.2f} Deviation: {:3.2f}" .format(clock.getAverageFrameRateInterval(), 1000.0 / clock.getAverageFrameRate(), clock.getMaxFrameDuration() * 1000.0, clock.calcFrameRateDeviation() * 1000.0)) if self.stateText: self.stateText.setText( "{:6d} Render States, {:6d} Transform States".format( RenderState.getNumStates(), TransformState.getNumStates())) if self.perfOverlay: self.perfOverlay.update()
def make_cloud_node(pts, col=LColorf(1.0, 0.0, 0.0, 1.0)): ptCloudData = GeomVertexData("PointCloudData", GeomVertexFormat.getV3c4(), GeomEnums.UH_static) vertexWriter = GeomVertexWriter(ptCloudData, Thread.getCurrentThread()) vertexWriter.setColumn("vertex") colorWriter = GeomVertexWriter(ptCloudData, Thread.getCurrentThread()) colorWriter.setColumn("color") for (x, y, z) in pts: vertexWriter.addData3(x, y, z) colorWriter.addData4(col) geomPts = GeomPoints(GeomEnums.UH_static) geomPts.addConsecutiveVertices(0, len(pts)) geomPts.closePrimitive() geom = Geom(ptCloudData) geom.addPrimitive(geomPts) node = GeomNode("PointCloudNode") node.addGeom(geom, RenderState.makeEmpty()) return node
def __init__(self, base): # Load texture tex = Loader(base).loadTexture((Path(path.realpath(__file__)).parent.parent.parent / "res/images/checkerboard.png").absolute()) tex.setMagfilter(SamplerState.FT_nearest) tex.setMinfilter(SamplerState.FT_nearest) # Set up vertex data vdata = GeomVertexData("floor_data", GeomVertexFormat.get_v3t2(), Geom.UHStatic) vdata.setNumRows(6) vertex = GeomVertexWriter(vdata, "vertex") texcoord = GeomVertexWriter(vdata, "texcoord") vertex.addData3(-5, -5, 0) texcoord.addData3(0, 0, 0) vertex.addData3(-5, 5, 0) texcoord.addData3(0, 10, 0) vertex.addData3(5, 5, 0) texcoord.addData3(10, 10, 0) vertex.addData3(5, 5, 0) texcoord.addData3(10, 10, 0) vertex.addData3(5, -5, 0) texcoord.addData3(10, 0, 0) vertex.addData3(-5, -5, 0) texcoord.addData3(0, 0, 0) # Create primitive prim = GeomTriangles(Geom.UHStatic) prim.addVertices(0, 1, 2) prim.addVertices(3, 4, 5) geom = Geom(vdata) geom.add_primitive(prim) # Initialize geometry node GeomNode.__init__(self, "floor") attrib = TextureAttrib.make(tex) state = RenderState.make(attrib) self.addGeom(geom, state)
def create_cam(cls): cls.create_buffer() if cls.watercamNP is None: cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) cls.watercamNP = base.makeCamera(cls.buffer, camName='waterCam') cls.watercamNP.reparentTo(render) #sa = ShaderAttrib.make() #sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') ) cam = cls.watercamNP.node() cam.set_camera_mask(BaseObject.WaterCameraMask) cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(0.01) cam.getLens().setFar(float("inf")) cam.setInitialState(rs) cam.setTagStateKey('Clipped') #cam.setTagState('True', RenderState.make(sa)) #cam.showFrustum() cls.task = taskMgr.add(cls.update, "waterTask")
def gen_segments(self): i = 0 for segment in self.track_data["segments"]: seg_type = segment["type"] surface = self.surfaces[segment["surface"]] gradient = segment.get("grade") gradient = gradient if gradient is not None else 0 segment_mesh = BulletTriangleMesh() if seg_type == "str": section = self.gen_str_segment(segment, surface, gradient, segment_mesh) elif seg_type == "arc": section = self.gen_arc_segment(segment, surface, gradient, segment_mesh) else: continue tex_attr = TextureAttrib.make(surface["tex"]) state = RenderState.make(tex_attr) self.snode.addGeom(section, state) self.mesh.addGeom(section) segment_mesh.addGeom(section) segment_shape = BulletTriangleMeshShape(segment_mesh, dynamic=False) segment_ghost = render.attachNewNode( BulletGhostNode(f'track_segment_{i}')) segment_ghost.node().addShape(segment_shape) self.world.attachGhost(segment_ghost.node()) segment_ghost.setTwoSided(True) self.segments.append(segment_ghost) i += 1
def getStateFromMaterial(prim_material, texture_cache, col_inst=None): state = RenderState.makeEmpty() mat = Material() texattr = TextureAttrib.makeAllOff() hasDiffuse = False if prim_material and prim_material.effect: diffuse = getattr(prim_material.effect, 'diffuse', None) transparent = getattr(prim_material.effect, 'transparent', None) if isinstance(diffuse, collada.material.Map) and isinstance(transparent, collada.material.Map): if diffuse.sampler.surface.image == transparent.sampler.surface.image: #some exporters put the same map in the diffuse channel # and the transparent channel when they don't really mean to transparent = None if isinstance(diffuse, collada.material.Map) or isinstance(transparent, collada.material.Map): diffuseMap = None transparentMap = None diffuseInitColor = None if isinstance(diffuse, collada.material.Map): diffuseMap = diffuse else: diffuseInitColor = v4fromtuple(diffuse) if isinstance(transparent, collada.material.Map): transparentMap = transparent if diffuseMap == transparentMap: transparentMap = None diffuseTexture = getTexture(color=diffuseMap, alpha=transparentMap, texture_cache=texture_cache, diffuseinit=diffuseInitColor) texattr = addTextureStage('tsDiff', TextureStage.MModulate, texattr, diffuseTexture) hasDiffuse = True if type(diffuse) is tuple: mat.setDiffuse(v4fromtuple(diffuse)) # hack to look for sketchup version < 8 where transparency was exported flipped # also ColladaMaya v2.03b had this same issue flip_alpha = False if col_inst and col_inst.assetInfo: for contributor in col_inst.assetInfo.contributors: tool_name = contributor.authoring_tool if tool_name is None: continue split = tool_name.split() if len(split) == 3 and \ split[0].strip().lower() == 'google' and \ split[1].strip().lower() == 'sketchup': version = split[2].strip().split('.') try: major_version = int(version[0]) if major_version < 8: flip_alpha = True except (ValueError, TypeError): continue try: collada_maya_idx = split.index('ColladaMaya') if split[collada_maya_idx + 1] == 'v2.03b': flip_alpha = True except (ValueError, IndexError): continue if type(transparent) is tuple: trR, trG, trB = transparent[0], transparent[1], transparent[2] trA = transparent[3] if len(transparent) > 3 else 1.0 else: trR, trG, trB = 1.0, 1.0, 1.0 trA = 1.0 transparency = getattr(prim_material.effect, 'transparency', 1.0) if transparency is None: transparency = 1.0 a_one = prim_material.effect.opaque_mode == collada.material.OPAQUE_MODE.A_ONE if a_one: alphaR = alphaG = alphaB = alphaA = transparency * trA else: alphaR = transparency * trR alphaG = transparency * trG alphaB = transparency * trB alphaA = luminance([trR, trG, trB]) flip_alpha = not flip_alpha if flip_alpha: alphaR = 1.0 - alphaR alphaG = 1.0 - alphaG alphaB = 1.0 - alphaB alphaA = 1.0 - alphaA if alphaA < 1.0: state = state.addAttrib(ColorScaleAttrib.make(VBase4(alphaR, alphaG, alphaB, alphaA))) emission = getattr(prim_material.effect, 'emission', None) if isinstance(emission, collada.material.Map): emissionTexture = getTexture(alpha=emission, texture_cache=texture_cache) texattr = addTextureStage('tsEmiss', TextureStage.MGlow, texattr, emissionTexture) elif type(emission) is tuple: mat.setEmission(v4fromtuple(emission)) ambient = getattr(prim_material.effect, 'ambient', None) if type(ambient) is tuple: mat.setAmbient(v4fromtuple(ambient)) specular = getattr(prim_material.effect, 'specular', None) if isinstance(specular, collada.material.Map): specularTexture = getTexture(color=specular, texture_cache=texture_cache) texattr = addTextureStage('tsSpec', TextureStage.MGloss, texattr, specularTexture) mat.setSpecular(VBase4(0.1, 0.1, 0.1, 1.0)) elif type(specular) is tuple: mat.setSpecular(v4fromtuple(specular)) shininess = getattr(prim_material.effect, 'shininess', None) #this sets a sane value for blinn shading if shininess <= 1.0: if shininess < 0.01: shininess = 1.0 shininess = shininess * 128.0 mat.setShininess(shininess) bumpmap = getattr(prim_material.effect, 'bumpmap', None) if isinstance(bumpmap, collada.material.Map): bumpTexture = getTexture(color=bumpmap, texture_cache=texture_cache) texattr = addTextureStage('tsBump', TextureStage.MNormal, texattr, bumpTexture) if prim_material.effect.double_sided: state = state.addAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone)) if hasDiffuse: state = state.addAttrib(DepthOffsetAttrib.make(1)) state = state.addAttrib(MaterialAttrib.make(mat)) state = state.addAttrib(texattr) return state
def update_stats(self, task=None): """ Updates the stats overlay """ clock = Globals.clock self.debug_lines[0].text = "{:3.0f} fps | {:3.1f} ms | {:3.1f} ms max".format( clock.get_average_frame_rate(), 1000.0 / max(0.001, clock.get_average_frame_rate()), clock.get_max_frame_duration() * 1000.0) if not self.advanced_info: return task.again if task else None text = "{:4d} states | {:4d} transforms " text += "| {:4d} cmds | {:4d} lights | {:4d} shadows " text += "| {:5.1f}% atlas usage" self.debug_lines[1].text = text.format( RenderState.get_num_states(), TransformState.get_num_states(), self.pipeline.light_mgr.cmd_queue.num_processed_commands, self.pipeline.light_mgr.num_lights, self.pipeline.light_mgr.num_shadow_sources, self.pipeline.light_mgr.shadow_atlas_coverage) text = "Internal: {:3.0f} MB VRAM | {:5d} img | {:5d} tex | " text += "{:5d} fbos | {:3d} plugins | {:2d} views ({:2d} active)" tex_memory, tex_count = self.buffer_viewer.stage_information views, active_views = 0, 0 for target in RenderTarget.REGISTERED_TARGETS: if not target.create_default_region: num_regions = target.internal_buffer.get_num_display_regions() for i, region in enumerate(target.internal_buffer.get_display_regions()): # Skip overlay display region if i == 0 and num_regions > 1: continue views += 1 active_views += 1 if target.active and region.active else 0 self.debug_lines[2].text = text.format( tex_memory / (1024**2), len(Image.REGISTERED_IMAGES), tex_count, RenderTarget.NUM_ALLOCATED_BUFFERS, len(self.pipeline.plugin_mgr.enabled_plugins), views, active_views) text = "Scene: {:4.0f} MB VRAM | {:3d} tex | {:4d} geoms " text += "| {:4d} nodes | {:7,.0f} vertices" scene_tex_size = 0 for tex in TexturePool.find_all_textures(): scene_tex_size += tex.estimate_texture_memory() self.debug_lines[3].text = text.format( scene_tex_size / (1024**2), len(TexturePool.find_all_textures()), self.analyzer.get_num_geoms(), self.analyzer.get_num_nodes(), self.analyzer.get_num_vertices(), ) sun_vector = Vec3(0) if self.pipeline.plugin_mgr.is_plugin_enabled("scattering"): sun_vector = self.pipeline.plugin_mgr.instances["scattering"].sun_vector text = "Time: {} ({:1.3f}) | Sun {:0.2f} {:0.2f} {:0.2f}" text += " | X {:3.1f} Y {:3.1f} Z {:3.1f}" text += " | {:2d} tasks | scheduled: {:2d}" self.debug_lines[4].text = text.format( self.pipeline.daytime_mgr.formatted_time, self.pipeline.daytime_mgr.time, sun_vector.x, sun_vector.y, sun_vector.z, Globals.base.camera.get_x(Globals.base.render), Globals.base.camera.get_y(Globals.base.render), Globals.base.camera.get_z(Globals.base.render), self.pipeline.task_scheduler.num_tasks, self.pipeline.task_scheduler.num_scheduled_tasks,) text = "Scene shadows: " if "pssm" in self.pipeline.plugin_mgr.enabled_plugins: focus = self.pipeline.plugin_mgr.instances["pssm"].scene_shadow_stage.last_focus if focus is not None: text += "{:3.1f} {:3.1f} {:3.1f} r {:3.1f}".format( focus[0].x, focus[0].y, focus[0].z, focus[1]) else: text += "none" else: text += "inactive" text += " | HPR ({:3.1f}, {:3.1f}, {:3.1f}) | {:4d} x {:4d} pixels @ {:3.1f} %" text += " | {:3d} x {:3d} tiles" self.debug_lines[5].text = text.format( Globals.base.camera.get_h(Globals.base.render), Globals.base.camera.get_p(Globals.base.render), Globals.base.camera.get_r(Globals.base.render), Globals.native_resolution.x, Globals.native_resolution.y, self.pipeline.settings["pipeline.resolution_scale"] * 100.0, self.pipeline.light_mgr.num_tiles.x, self.pipeline.light_mgr.num_tiles.y,) if task: return task.again
def getStateFromMaterial(prim_material): state = RenderState.makeFullDefault() emission = None ambient = None diffuse = None specular = None shininess = None reflection = None reflectivity = None if prim_material: for prop in prim_material.supported: value = getattr(prim_material, prop) if value is None: continue if type(value) is tuple: val4 = value[3] if len(value) > 3 else 1.0 value = VBase4(value[0], value[1], value[2], val4) if isinstance(value, collada.material.Map): texture_file = value.sampler.surface.image.path if not texture_file is None: (root, leaf) = os.path.split(sys.argv[1]) tex_absolute = os.path.join(root, texture_file) myImage = PNMImage() myImage.read(Filename(tex_absolute)) myTexture = Texture(texture_file) myTexture.load(myImage) state = state.addAttrib(TextureAttrib.make(myTexture)) elif prop == 'emission': emission = value elif prop == 'ambient': ambient = value elif prop == 'diffuse': diffuse = value elif prop == 'specular': specular = value elif prop == 'shininess': shininess = value elif prop == 'reflective': reflective = value elif prop == 'reflectivity': reflectivity = value elif prop == 'transparent': pass elif prop == 'transparency': pass else: raise mat = Material() if not emission is None: mat.setEmission(emission) if not ambient is None: mat.setAmbient(ambient) if not diffuse is None: mat.setDiffuse(diffuse) if not specular is None: mat.setSpecular(specular) if not shininess is None: mat.setShininess(shininess) state = state.addAttrib(MaterialAttrib.make(mat)) return state
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): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) self.setBackgroundColor((0, 0, 0, 0)) # Preliminary capabilities check. if not self.win.getGsg().getSupportsBasicShaders(): self.t = addTitle("Firefly Demo: Video driver reports that Cg " "shaders are not supported.") return if not self.win.getGsg().getSupportsDepthTexture(): self.t = addTitle("Firefly Demo: Video driver reports that depth " "textures are not supported.") return # This algorithm uses two offscreen buffers, one of which has # an auxiliary bitplane, and the offscreen buffers share a single # depth buffer. This is a heck of a complicated buffer setup. self.modelbuffer = self.makeFBO("model buffer", 1) self.lightbuffer = self.makeFBO("light buffer", 0) # Creation of a high-powered buffer can fail, if the graphics card # doesn't support the necessary OpenGL extensions. if self.modelbuffer is None or self.lightbuffer is None: self.t = addTitle("Toon Shader: Video driver does not support " "multiple render targets") return # Create four render textures: depth, normal, albedo, and final. # attach them to the various bitplanes of the offscreen buffers. self.texDepth = Texture() self.texDepth.setFormat(Texture.FDepthStencil) self.texAlbedo = Texture() self.texNormal = Texture() self.texFinal = Texture() self.modelbuffer.addRenderTexture(self.texDepth, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepthStencil) self.modelbuffer.addRenderTexture(self.texAlbedo, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor) self.modelbuffer.addRenderTexture(self.texNormal, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0) self.lightbuffer.addRenderTexture(self.texFinal, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor) # Set the near and far clipping planes. self.cam.node().getLens().setNear(50.0) self.cam.node().getLens().setFar(500.0) lens = self.cam.node().getLens() # This algorithm uses three cameras: one to render the models into the # model buffer, one to render the lights into the light buffer, and # one to render "plain" stuff (non-deferred shaded) stuff into the # light buffer. Each camera has a bitmask to identify it. self.modelMask = 1 self.lightMask = 2 self.plainMask = 4 self.modelcam = self.makeCamera(self.modelbuffer, lens=lens, scene=render, mask=self.modelMask) self.lightcam = self.makeCamera(self.lightbuffer, lens=lens, scene=render, mask=self.lightMask) self.plaincam = self.makeCamera(self.lightbuffer, lens=lens, scene=render, mask=self.plainMask) # Panda's main camera is not used. self.cam.node().setActive(0) # Take explicit control over the order in which the three # buffers are rendered. self.modelbuffer.setSort(1) self.lightbuffer.setSort(2) self.win.setSort(3) # Within the light buffer, control the order of the two cams. self.lightcam.node().getDisplayRegion(0).setSort(1) self.plaincam.node().getDisplayRegion(0).setSort(2) # By default, panda usually clears the screen before every # camera and before every window. Tell it not to do that. # Then, tell it specifically when to clear and what to clear. self.modelcam.node().getDisplayRegion(0).disableClears() self.lightcam.node().getDisplayRegion(0).disableClears() self.plaincam.node().getDisplayRegion(0).disableClears() self.cam.node().getDisplayRegion(0).disableClears() self.cam2d.node().getDisplayRegion(0).disableClears() self.modelbuffer.disableClears() self.win.disableClears() self.modelbuffer.setClearColorActive(1) self.modelbuffer.setClearDepthActive(1) self.lightbuffer.setClearColorActive(1) self.lightbuffer.setClearColor((0, 0, 0, 1)) # Miscellaneous stuff. self.disableMouse() self.camera.setPos(-9.112, -211.077, 46.951) self.camera.setHpr(0, -7.5, 2.4) random.seed() # Calculate the projection parameters for the final shader. # The math here is too complex to explain in an inline comment, # I've put in a full explanation into the HTML intro. proj = self.cam.node().getLens().getProjectionMat() proj_x = 0.5 * proj.getCell(3, 2) / proj.getCell(0, 0) proj_y = 0.5 * proj.getCell(3, 2) proj_z = 0.5 * proj.getCell(3, 2) / proj.getCell(2, 1) proj_w = -0.5 - 0.5 * proj.getCell(1, 2) # Configure the render state of the model camera. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib( AlphaTestAttrib.make(RenderAttrib.MGreaterEqual, 0.5)) tempnode.setShader(loader.loadShader("model.sha")) tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual)) self.modelcam.node().setInitialState(tempnode.getState()) # Configure the render state of the light camera. tempnode = NodePath(PandaNode("temp node")) tempnode.setShader(loader.loadShader("light.sha")) tempnode.setShaderInput("texnormal", self.texNormal) tempnode.setShaderInput("texalbedo", self.texAlbedo) tempnode.setShaderInput("texdepth", self.texDepth) tempnode.setShaderInput("proj", (proj_x, proj_y, proj_z, proj_w)) tempnode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne)) tempnode.setAttrib( CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise)) # The next line causes problems on Linux. # tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual)) tempnode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff)) self.lightcam.node().setInitialState(tempnode.getState()) # Configure the render state of the plain camera. rs = RenderState.makeEmpty() self.plaincam.node().setInitialState(rs) # Clear any render attribs on the root node. This is necessary # because by default, panda assigns some attribs to the root # node. These default attribs will override the # carefully-configured render attribs that we just attached # to the cameras. The simplest solution is to just clear # them all out. render.setState(RenderState.makeEmpty()) # My artist created a model in which some of the polygons # don't have textures. This confuses the shader I wrote. # This little hack guarantees that everything has a texture. white = loader.loadTexture("models/white.jpg") render.setTexture(white, 0) # Create two subroots, to help speed cull traversal. self.lightroot = NodePath(PandaNode("lightroot")) self.lightroot.reparentTo(render) self.modelroot = NodePath(PandaNode("modelroot")) self.modelroot.reparentTo(render) self.lightroot.hide(BitMask32(self.modelMask)) self.modelroot.hide(BitMask32(self.lightMask)) self.modelroot.hide(BitMask32(self.plainMask)) # Load the model of a forest. Make it visible to the model camera. # This is a big model, so we load it asynchronously while showing a # load text. We do this by passing in a callback function. self.loading = addTitle("Loading models...") self.forest = NodePath(PandaNode("Forest Root")) self.forest.reparentTo(render) self.forest.hide(BitMask32(self.lightMask | self.plainMask)) loader.loadModel([ "models/background", "models/foliage01", "models/foliage02", "models/foliage03", "models/foliage04", "models/foliage05", "models/foliage06", "models/foliage07", "models/foliage08", "models/foliage09"], callback=self.finishLoading) # Cause the final results to be rendered into the main window on a # card. self.card = self.lightbuffer.getTextureCard() self.card.setTexture(self.texFinal) self.card.reparentTo(render2d) # Panda contains a built-in viewer that lets you view the results of # your render-to-texture operations. This code configures the viewer. self.bufferViewer.setPosition("llcorner") self.bufferViewer.setCardSize(0, 0.40) self.bufferViewer.setLayout("vline") self.toggleCards() self.toggleCards() # Firefly parameters self.fireflies = [] self.sequences = [] self.scaleseqs = [] self.glowspheres = [] self.fireflysize = 1.0 self.spheremodel = loader.loadModel("misc/sphere") # Create the firefly model, a fuzzy dot dotSize = 1.0 cm = CardMaker("firefly") cm.setFrame(-dotSize, dotSize, -dotSize, dotSize) self.firefly = NodePath(cm.generate()) self.firefly.setTexture(loader.loadTexture("models/firefly.png")) self.firefly.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.M_add, ColorBlendAttrib.O_incoming_alpha, ColorBlendAttrib.O_one)) # these allow you to change parameters in realtime self.accept("escape", sys.exit, [0]) self.accept("arrow_up", self.incFireflyCount, [1.1111111]) self.accept("arrow_down", self.decFireflyCount, [0.9000000]) self.accept("arrow_right", self.setFireflySize, [1.1111111]) self.accept("arrow_left", self.setFireflySize, [0.9000000]) self.accept("v", self.toggleCards) self.accept("V", self.toggleCards)
def createBox(self): """ Create the skybox GeomNode :return: """ obj = '' obj += "# Skybox\n" obj += 'mtllib skybox.mtl\n' mtl = '# material for skybox\n' fmt = GeomVertexFormat.getV3n3t2() vdata = GeomVertexData('skybox', fmt, Geom.UHStatic) vdata.setNumRows(24) vertex = GeomVertexWriter(vdata, 'vertex') normals = GeomVertexWriter(vdata, 'normal') texcoord = GeomVertexWriter(vdata, 'texcoord') node = GeomNode('skybox') for normal in self.normals: geom = Geom(vdata) prim = GeomTriangles(Geom.UHStatic) idx = vertex.getWriteRow() verts = self.vertMappings[normal] tcs = self.getFaceMapping(normal) for v, t in zip(verts, tcs): vertex.addData3f(v[0]*2, v[1]*2, v[2]*2) normals.addData3f(normal) texcoord.addData2f(t) obj += 'v {0} {1} {2}\n'.format(v[0]*2, v[1]*2, v[2]*2) obj += 'vn {0} {1} {2}\n'.format(*normal) obj += 'vt {0} {1}\n'.format(*t) tex = self.getFaceTexture(normal) prim.addVertices(idx, idx + 1, idx + 3) prim.closePrimitive() obj += "usemtl {0}\n".format(tex.getName()) obj += 'f {0}/{0} {1}/{1} {2}/{2}\n'.format(1+idx, 1+idx+1, 1+idx+3) prim.addVertices(idx + 1, idx + 2, idx + 3) prim.closePrimitive() obj += "usemtl {0}\n".format(tex.getName()) obj += 'f {0}/{0} {1}/{1} {2}/{2}\n'.format(1+idx+1, 1+idx+2, 1+idx+3) geom.addPrimitive(prim) tex.setWrapU(Texture.WMMirror) tex.setWrapV(Texture.WMMirror) node.addGeom(geom, RenderState.make(TextureAttrib.make(tex))) mtl += "newmtl {0}\n".format(tex.getName()) mtl += "Ka 1 1 1\n" mtl += "Kd 1 1 1\n" mtl += "map_Kd {0}\n".format(tex.getFilename().toOsSpecific()) return node
def __init__(self,geomVertexFormat,renderState=RenderState.makeEmpty()): self.geomVertexFormat=geomVertexFormat self.renderState=renderState
def __init__(self,parentIndex,renderState=RenderState.makeEmpty()): # parentIndex of -1 == root self.renderState=renderState self.parentIndex=parentIndex
def update(self): if self.memUsageText: memstr = str(round(MemoryMonitor.getEstimatedMemUsage() / 1024.0 / 1024.0, 2)) numTextureBytes = 0 renderTextures = Globals.render.findAllTextures() for tex in renderTextures: numTextureBytes += MemoryMonitor._calculateTexSize(tex) texstr = str(round(numTextureBytes / 1024.0 / 1024.0, 2)) otherTextures = TexturePool.findAllTextures() numOtherBytes = 0 for tex in otherTextures: if tex not in renderTextures: numOtherBytes += MemoryMonitor._calculateTexSize(tex) otherstr = str(round(numOtherBytes / 1024.0 / 1024.0, 2)) self.memUsageText.setText("VRAM Usage: " + memstr + " MB / Textures: " + texstr + " MB / Other: " + otherstr + " MB") if self.fpsText: clock = Globals.clock self.fpsText.setText("Frame time over {:3.1f}s Avg: {:3.2f} Max: {:3.2f} Deviation: {:3.2f}".format( clock.getAverageFrameRateInterval(), 1000.0 / clock.getAverageFrameRate(), clock.getMaxFrameDuration() * 1000.0, clock.calcFrameRateDeviation() * 1000.0 )) if self.stateText: self.stateText.setText("{:6d} Render States, {:6d} Transform States".format(RenderState.getNumStates(), TransformState.getNumStates())) if self.perfOverlay: self.perfOverlay.update()
def __init__(self, name, size=10000, resolution=1024): """Arguments: size -- Edge length of the water square. resolution -- Texture size of the rendered reflection buffer. """ # Uncomment to see the output of the refclection buffer. base.bufferViewer.toggleEnable() AssetBase.__init__(self) self.name = name self.cm = CardMaker("water surface") self.cm.setFrame(-0.5 * size, 0.5 * size, -0.5 * size, 0.5 * size) self.cm.setHasUvs(True) self.node = NodePath(self.cm.generate()) self.node.setP(self.node, -90) self.node.flattenLight() self.node.hide(BitMask32.bit(1)) # self.node.setTwoSided(True) self.node.setShaderOff() # size of one texture tile in meters self.tex_size = 100.0 diffuse = TexturePool.loadTexture("textures/water.diffuse.png") diffuse.setWrapU(Texture.WMRepeat) diffuse.setWrapV(Texture.WMRepeat) diffuse.setMinfilter(Texture.FTLinearMipmapLinear) diffuse.setMagfilter(Texture.FTLinearMipmapLinear) self.diffuse_stage = TextureStage("diffuse") self.diffuse_stage.setSort(2) self.node.setTexture(self.diffuse_stage, diffuse) self.node.setTexScale(self.diffuse_stage, size / self.tex_size, size / self.tex_size) # Reflection camera renders to 'buffer' which is projected onto the # water surface. buffer = base.win.makeTextureBuffer("water reflection", resolution, resolution) buffer.setClearColor(Vec4(0, 0, 0, 1)) self.refl_cam = base.makeCamera(buffer) self.refl_cam.reparentTo(self.node) self.refl_cam.node().setCameraMask(BitMask32.bit(1)) self.refl_cam.node().getLens().setFov(base.camLens.getFov()) self.refl_cam.node().getLens().setNearFar(1, 100000) plane = PlaneNode("water culling plane", Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) cfa = CullFaceAttrib.makeReverse() cpa = ClipPlaneAttrib.make(PlaneNode.CEVisible, plane) rs = RenderState.make(cfa, cpa) self.refl_cam.node().setInitialState(rs) reflection = buffer.getTexture() reflection.setMinfilter(Texture.FTLinear) reflection.setMagfilter(Texture.FTLinear) self.refl_stage = TextureStage("reflection") self.refl_stage.setSort(1) self.node.projectTexture(self.refl_stage, reflection, base.cam) self.node.setTexture(self.refl_stage, reflection) # Blend between diffuse and reflection. self.diffuse_stage.setColor(VBase4(1, 1, 1, 0.2)) # opacity of 20% self.diffuse_stage.setCombineRgb( TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSConstant, TextureStage.COSrcAlpha, ) self.addTask(self.update, name="water update", sort=1, taskChain="world")