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 __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 _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 __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 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): 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 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_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 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 __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 gen_geom(self, mesh_json): # Create vertex format geom_array = GeomVertexArrayFormat() geom_array.add_column("vertex", 3, Geom.NTFloat32, Geom.CPoint) has_normals = False has_texcoords = False has_weights = False if "normals" in mesh_json: geom_array.add_column("normal", 3, Geom.NTFloat32, Geom.CNormal) has_normals = True if "texcoords" in mesh_json: geom_array.add_column("texcoord", 3, Geom.NTFloat32, Geom.CTexcoord) has_texcoords = True if "weights" in mesh_json: geom_array.add_column("joint", 4, Geom.NTUint8, Geom.CIndex) geom_array.add_column("weight", 4, Geom.NTFloat32, Geom.COther) has_weights = True geom_format = GeomVertexFormat() geom_format.add_array(geom_array) geom_format = GeomVertexFormat.register_format(geom_format) # Set up vertex data vdata = GeomVertexData( str(random.randint(0, 255)) + "_vdata", geom_format, Geom.UHStatic) vcount = len(mesh_json["vertices"]) // 3 vdata.setNumRows(vcount) vertex = GeomVertexWriter(vdata, "vertex") for i in range(vcount): vertex.addData3(mesh_json["vertices"][3 * i], mesh_json["vertices"][3 * i + 1], mesh_json["vertices"][3 * i + 2]) if has_normals: normal = GeomVertexWriter(vdata, "normal") for i in range(vcount): normal.addData3(mesh_json["normals"][3 * i], mesh_json["normals"][3 * i + 1], mesh_json["normals"][3 * i + 2]) if has_texcoords: texcoord = GeomVertexWriter(vdata, "texcoord") for i in range(vcount): texcoord.addData2(mesh_json["texcoords"][2 * i], mesh_json["texcoords"][2 * i + 1]) if has_weights: joint = GeomVertexWriter(vdata, "joint") weight = GeomVertexWriter(vdata, "weight") for i in range(vcount): joint_count = len(mesh_json["joints"][i]) joint.addData4( 0 if joint_count < 1 else mesh_json["joints"][i][0], 0 if joint_count < 2 else mesh_json["joints"][i][1], 0 if joint_count < 3 else mesh_json["joints"][i][2], 0 if joint_count < 4 else mesh_json["joints"][i][3]) weight.addData4( 0 if joint_count < 1 else mesh_json["weights"][i][0], 0 if joint_count < 2 else mesh_json["weights"][i][1], 0 if joint_count < 3 else mesh_json["weights"][i][2], 0 if joint_count < 4 else mesh_json["weights"][i][3]) # Create primitive prim = GeomTriangles(Geom.UHStatic) for i in range(vcount // 3): prim.addVertices(3 * i, 3 * i + 1, 3 * i + 2) geom = Geom(vdata) geom.add_primitive(prim) # Load texture tex = None if "texture" in mesh_json: tex = Loader(EComponent.base).loadTexture( (Path("resources") / mesh_json["texture"]).absolute()) tex.setMagfilter(SamplerState.FT_nearest) tex.setMinfilter(SamplerState.FT_nearest) # Create new geometry node geom_node = GeomNode(str(random.randint(0, 255)) + "_node") if tex is None: geom_node.addGeom(geom) else: attrib = TextureAttrib.make(tex) state = RenderState.make(attrib) geom_node.addGeom(geom, state) if EComponent.panda_root_node is not None: self.geom_path = EComponent.panda_root_node.attach_new_node( geom_node) self.geom_path.set_shader_input("object_id", self.object_id) # Set shader if has_weights and self.geom_path is not None: self.geom_path.setTag("shader type", "skinned") bone_mats = PTA_LMatrix4f() for _ in range(100): bone_mats.push_back(helper.np_mat4_to_panda(np.identity(4))) self.geom_path.set_shader_input(f"boneMats", bone_mats) # Disable culling self.geom_path.node().setBounds(OmniBoundingVolume()) self.geom_path.node().setFinal(True)
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")
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
class ClipState(IntEnum): Off = 0 Drawing = 1 Drawn = 2 MovingPoint1 = 3 MovingPoint2 = 4 MovingPoint3 = 5 class ClipSide(IntEnum): Both = 0 Front = 1 Back = 2 PlaneVis3DState = RenderState.make( ColorAttrib.makeFlat(Vec4(0, 1, 1, 0.5)), TransparencyAttrib.make(TransparencyAttrib.MAlpha), CullFaceAttrib.make(CullFaceAttrib.MCullNone) ) PlaneVis2DState = RenderState.make( ColorAttrib.makeFlat(Vec4(0, 1, 1, 1)), CullBinAttrib.make("fixed", LEGlobals.BoxSort), CullFaceAttrib.make(CullFaceAttrib.MCullNone) ) # Draws the clip plane lines and move handles in each 2D viewport class ClipToolViewport2D: def __init__(self, tool, vp): self.tool = tool self.vp = vp
def __init__(self, length: int, width: int, view_ground: bool, chassis_np: NodePath, pg_world: PGWorld): """ :param length: Control resolution of this sensor :param width: Control resolution of this sensor :param view_ground: Lane line will be invisible when set to True :param chassis_np: The vehicle chassis to place this sensor :param pg_world: PG-World """ self.view_ground = view_ground self.BUFFER_W = length self.BUFFER_H = width super(DepthCamera, self).__init__(self.BUFFER_W, self.BUFFER_H, Vec3(0.0, 0.8, 1.5), self.BKG_COLOR, pg_world=pg_world, parent_node=chassis_np) self.add_to_display(pg_world, self.default_region) self.cam.lookAt(0, 2.4, 1.3) self.lens.setFov(60) self.lens.setAspectRatio(2.0) # add shader for it if pg_world.world_config["headless_image"]: vert_path = AssetLoader.file_path("shaders", "depth_cam_gles.vert.glsl") frag_path = AssetLoader.file_path("shaders", "depth_cam_gles.frag.glsl") else: 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) self.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.reparentTo(chassis_np) self.ground_model.setPos(-128, 0, self.GROUND) self.ground_model.hide(BitMask32.allOn()) self.ground_model.show(CamMask.DepthCam) self.ground.generate() pg_world.taskMgr.add(self.renew_pos_of_ground_mode, self.TASK_NAME, extraArgs=[chassis_np], appendTask=True)
def __init__(self, x1, y1, x2, y2, z, scale, parent): # Water surface maker = CardMaker('water') maker.setFrame(x1, x2, y1, y2) self.waterNP = parent.instance.attachNewNode(maker.generate()) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) self.waterNP.setShader( Shader.load( Shader.SL_GLSL, vertex=defaultDirContext.find_shader('water-vertex.glsl'), fragment=defaultDirContext.find_shader('water-fragment.glsl'))) self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, scale, 0)) # vx, vy, scale, skip # offset, strength, refraction factor (0=perfect mirror, 1=total refraction), refractivity self.waterNP.setShaderInput('waterdistort', Vec4(0.4, 4.0, 0.25, 0.45)) self.waterNP.setShaderInput('time', 0) # Reflection plane self.waterPlane = Plane(Vec3(0, 0, z + 1), Point3(0, 0, z)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) if self.watercamNP is None: # Buffer and reflection camera WaterNode.buffer = base.win.makeTextureBuffer( 'waterBuffer', 512, 512) self.buffer.setClearColor(Vec4(0, 0, 0, 1)) cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) WaterNode.watercamNP = base.makeCamera(self.buffer) self.watercamNP.reparentTo(render) #sa = ShaderAttrib.make() #sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') ) cam = self.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(1) cam.getLens().setFar(5000) cam.setInitialState(rs) cam.setTagStateKey('Clipped') #cam.setTagState('True', RenderState.make(sa)) # ---- water textures --------------------------------------------- # reflection texture, created in realtime by the 'water camera' tex0 = self.buffer.getTexture() tex0.setWrapU(Texture.WMClamp) tex0.setWrapV(Texture.WMClamp) ts0 = TextureStage('reflection') self.waterNP.setTexture(ts0, tex0) # distortion texture tex1 = loader.loadTexture('textures/water.png') ts1 = TextureStage('distortion') self.waterNP.setTexture(ts1, tex1) self.task = taskMgr.add(self.update, "waterTask")
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")
def __init__(self, pipeline): """ Creates a new LightManager. It expects a RenderPipeline as parameter. """ DebugObject.__init__(self, "LightManager") self._initArrays() self.pipeline = pipeline self.settings = pipeline.getSettings() # Create arrays to store lights & shadow sources self.lights = [] self.shadowSources = [] self.queuedShadowUpdates = [] self.allLightsArray = ShaderStructArray(Light, self.maxTotalLights) self.cullBounds = None self.shadowScene = Globals.render # Create atlas self.shadowAtlas = ShadowAtlas() self.shadowAtlas.setSize(self.settings.shadowAtlasSize) self.shadowAtlas.create() self.maxShadowMaps = 24 self.maxShadowUpdatesPerFrame = self.settings.maxShadowUpdatesPerFrame self.numShadowUpdatesPTA = PTAInt.emptyArray(1) self.updateShadowsArray = ShaderStructArray( ShadowSource, self.maxShadowUpdatesPerFrame) self.allShadowsArray = ShaderStructArray( ShadowSource, self.maxShadowMaps) # Create shadow compute buffer self._createShadowComputationBuffer() # Create the initial shadow state self.shadowComputeCamera.setTagStateKey("ShadowPassShader") self.shadowComputeCamera.setInitialState(RenderState.make( ColorWriteAttrib.make(ColorWriteAttrib.C_off), DepthWriteAttrib.make(DepthWriteAttrib.M_on), # CullFaceAttrib.make(CullFaceAttrib.MCullNone), 100)) self._createTagStates() self.shadowScene.setTag("ShadowPassShader", "Default") # Create debug overlay self._createDebugTexts() # Disable buffer on start self.shadowComputeTarget.setActive(False) # Bind arrays self.updateShadowsArray.bindTo(self.shadowScene, "updateSources") self.updateShadowsArray.bindTo( self.shadowComputeTarget, "updateSources") # Set initial inputs for target in [self.shadowComputeTarget, self.shadowScene]: target.setShaderInput("numUpdates", self.numShadowUpdatesPTA) self.lightingComputator = None self.lightCuller = None
def __init__(self): DebugObject.__init__(self, "LightManager") self._initArrays() # create arrays to store lights & shadow sources self.lights = [] self.shadowSources = [] self.allLightsArray = ShaderStructArray(Light, 30) self.cullBounds = None self.shadowScene = render ## SHADOW ATLAS ## # todo: move to separate class # When you change this, change also SHADOW_MAP_ATLAS_SIZE in configuration.include, # and reduce the default shadow map resolution of point lights self.shadowAtlasSize = 512 self.maxShadowMaps = 24 # When you change it , change also SHAODOW_GEOMETRY_MAX_VERTICES and # SHADOW_MAX_UPDATES_PER_FRAME in configuration.include! self.maxShadowUpdatesPerFrame = 2 self.tileSize = 128 self.tileCount = self.shadowAtlasSize / self.tileSize self.tiles = [] self.updateShadowsArray = ShaderStructArray( ShadowSource, self.maxShadowUpdatesPerFrame) self.allShadowsArray = ShaderStructArray(ShadowSource, self.maxShadowMaps) # self.shadowAtlasTex = Texture("ShadowAtlas") # self.shadowAtlasTex.setup2dTexture( # self.shadowAtlasSize, self.shadowAtlasSize, Texture.TFloat, Texture.FRg16) # self.shadowAtlasTex.setMinfilter(Texture.FTLinear) # self.shadowAtlasTex.setMagfilter(Texture.FTLinear) self.debug("Init shadow atlas with tileSize =", self.tileSize, ", tileCount =", self.tileCount) for i in xrange(self.tileCount): self.tiles.append([None for j in xrange(self.tileCount)]) # create shadow compute buffer self.shadowComputeCamera = Camera("ShadowComputeCamera") self.shadowComputeCameraNode = self.shadowScene.attachNewNode( self.shadowComputeCamera) self.shadowComputeCamera.getLens().setFov(90, 90) self.shadowComputeCamera.getLens().setNearFar(10.0, 100000.0) self.shadowComputeCameraNode.setPos(0, 0, 150) self.shadowComputeCameraNode.lookAt(0, 0, 0) self.shadowComputeTarget = RenderTarget("ShadowCompute") self.shadowComputeTarget.setSize(self.shadowAtlasSize, self.shadowAtlasSize) # self.shadowComputeTarget.setLayers(self.maxShadowUpdatesPerFrame) self.shadowComputeTarget.addRenderTexture(RenderTargetType.Depth) self.shadowComputeTarget.setDepthBits(32) self.shadowComputeTarget.setSource(self.shadowComputeCameraNode, base.win) self.shadowComputeTarget.prepareSceneRender() self.shadowComputeTarget.getInternalRegion().setSort(3) self.shadowComputeTarget.getRegion().setSort(3) self.shadowComputeTarget.getInternalRegion().setNumRegions( self.maxShadowUpdatesPerFrame + 1) self.shadowComputeTarget.getInternalRegion().setDimensions( 0, (0, 1, 0, 1)) self.shadowComputeTarget.setClearDepth(False) self.depthClearer = [] for i in xrange(self.maxShadowUpdatesPerFrame): buff = self.shadowComputeTarget.getInternalBuffer() dr = buff.makeDisplayRegion() dr.setSort(2) dr.setClearDepthActive(True) dr.setClearDepth(1.0) dr.setClearColorActive(False) dr.setDimensions(0, 0, 0, 0) self.depthClearer.append(dr) self.queuedShadowUpdates = [] # Assign copy shader self._setCopyShader() # self.shadowComputeTarget.setShaderInput("atlas", self.shadowComputeTarget.getColorTexture()) # self.shadowComputeTarget.setShaderInput( # "renderResult", self.shadowComputeTarget.getDepthTexture()) # self.shadowComputeTarget.setActive(False) # Create shadow caster shader self.shadowCasterShader = BetterShader.load( "Shader/DefaultShadowCaster.vertex", "Shader/DefaultShadowCaster.fragment", "Shader/DefaultShadowCaster.geometry") self.shadowComputeCamera.setTagStateKey("ShadowPass") initialState = NodePath("ShadowCasterState") initialState.setShader(self.shadowCasterShader, 30) self.shadowComputeCamera.setInitialState( RenderState.make(ColorWriteAttrib.make(ColorWriteAttrib.C_off), DepthWriteAttrib.make(DepthWriteAttrib.M_on), 100)) self.shadowComputeCamera.setTagState("True", initialState.getState()) self.shadowScene.setTag("ShadowPass", "True") self._createDebugTexts() self.updateShadowsArray.bindTo(self.shadowScene, "updateSources") self.updateShadowsArray.bindTo(self.shadowComputeTarget, "updateSources") self.numShadowUpdatesPTA = PTAInt.emptyArray(1) # Set initial inputs for target in [self.shadowComputeTarget, self.shadowScene]: target.setShaderInput("numUpdates", self.numShadowUpdatesPTA) self.lightingComputator = None self.lightCuller = None
from src.leveleditor.geometry.Box import Box from src.leveleditor.geometry.GeomView import GeomView from src.leveleditor.grid.GridSettings import GridSettings from src.leveleditor.mapobject.Entity import Entity from src.leveleditor import LEUtils, LEGlobals from src.leveleditor.actions.Create import Create from src.leveleditor.actions.Select import Deselect from src.leveleditor.actions.ChangeSelectionMode import ChangeSelectionMode from src.leveleditor.selection.SelectionType import SelectionType from src.leveleditor.actions.Select import Select from src.leveleditor.actions.ActionGroup import ActionGroup from src.leveleditor.menu.KeyBind import KeyBind import random VisState = RenderState.make(ColorAttrib.makeFlat(Vec4(0, 1, 0, 1)), LightAttrib.makeAllOff(), FogAttrib.makeOff()) class EntityToolOptions(ToolOptions): GlobalPtr = None @staticmethod def getGlobalPtr(): self = EntityToolOptions if not self.GlobalPtr: self.GlobalPtr = EntityToolOptions() return self.GlobalPtr def __init__(self): ToolOptions.__init__(self)
def initialize(self): Viewport.initialize(self) self.gizmo.np.setHpr(self.getViewHpr()) self.camNode.setInitialState( RenderState.make(FogAttrib.makeOff(), LightAttrib.makeAllOff()))
from .MapWritable import MapWritable from src.leveleditor import LEGlobals from .TransformProperties import OriginProperty, AnglesProperty, ScaleProperty, ShearProperty from . import MetaData from .ObjectProperty import ObjectProperty from src.leveleditor.math.Line import Line from src.leveleditor.geometry.Box import Box from src.leveleditor.geometry.GeomView import GeomView from src.leveleditor.viewport.ViewportType import VIEWPORT_2D_MASK, VIEWPORT_3D_MASK from enum import IntEnum BoundsBox3DState = RenderState.make( ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)) ) BoundsBox2DState = RenderState.make( ColorAttrib.makeFlat(Vec4(1, 0, 0, 1)), CullBinAttrib.make("selected-foreground", 0) ) MapObjectInit = PStatCollector("Arch:CreateSolid:MapObjInit") # Base class for any object in the map (brush, entity, etc) class MapObject(MapWritable): ObjectName = "object" def __init__(self, id):
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.hide(BitMask32.allOn()) model.show(self.cameraMask) # Get semantic-related color of model modelId = model.getNetTag('model-id') if self.segment_by_instance: instance_id = objectNp.getTag('instance-id') instance_color = None if 'fr_' in modelId: if modelId.endswith('c'): catName = 'ceiling' elif modelId.endswith('f'): catName = 'floor' elif modelId.endswith('w'): catName = 'wall' if self.segment_by_instance: instance_color = self.instance_color_mapping[catName] else: catName = self.categoryMapping.getFineGrainedCategoryForModelId( modelId) color = MODEL_CATEGORY_COLOR_MAPPING[catName] if self.segment_by_instance: if not instance_color: instance_color = list(np.random.choice(range(256), size=3)) self.instance_color_mapping[instance_id] = instance_color color = instance_color # 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)) self.color_instance_mapping = { tuple(v): k for k, v in self.instance_color_mapping.iteritems() } # 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)
from src.leveleditor.actions.Delete import Delete from src.leveleditor.actions.ChangeSelectionMode import ChangeSelectionMode from src.leveleditor.DocObject import DocObject from .GroupsMode import GroupsMode from .ObjectMode import ObjectMode from .FaceMode import FaceMode from .VertexMode import VertexMode from enum import IntEnum from functools import partial from PyQt5 import QtWidgets, QtCore Bounds3DState = RenderState.make( ColorAttrib.makeFlat(Vec4(1, 1, 0, 1)) ) Bounds2DState = RenderModes.DashedLineNoZ() Bounds2DState = Bounds2DState.setAttrib(ColorAttrib.makeFlat(Vec4(1, 1, 0, 1))) class SelectionManager(DocObject): Modes = [ GroupsMode, ObjectMode, FaceMode, VertexMode ] def __init__(self, doc):