def setShaders(self): shaderCoC = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFCoC.fragment") self.targetCoC.setShader(shaderCoC) # shaderSprites = Shader.load(Shader.SLGLSL, # "Shader/DoF/DoFSprite.vertex", # "Shader/DoF/DoFSprite.fragment") # self.targetSpawnSprites.setShader(shaderSprites) shaderBlurV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFBlurV.fragment") self.targetBlurV.setShader(shaderBlurV) shaderBlurH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFBlurH.fragment") self.targetBlurH.setShader(shaderBlurH) shaderCombine = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFCombine.fragment") self.targetCombine.setShader(shaderCombine) return [shaderCoC, shaderBlurV, shaderBlurH, shaderCombine]
def setShaders(self): shaderCoC = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFCoC.fragment") self.targetCoC.setShader(shaderCoC) # shaderSprites = Shader.load(Shader.SLGLSL, # "Shader/DoF/DoFSprite.vertex", # "Shader/DoF/DoFSprite.fragment") # self.targetSpawnSprites.setShader(shaderSprites) shaderBlurV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFBlurV.fragment") self.targetBlurV.setShader(shaderBlurV) shaderBlurH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFBlurH.fragment") self.targetBlurH.setShader(shaderBlurH) shaderCombine = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DoF/DoFCombine.fragment") self.targetCombine.setShader(shaderCombine) return [shaderCoC, shaderBlurV, shaderBlurH, shaderCombine]
def test_shader_load_multi(vfs, ramdir): # Try non-existent first. shad0 = Shader.load(Shader.SL_GLSL, vertex="/nonexistent.glsl", fragment="/nonexistent.glsl") assert shad0 is None vert_file = Filename(ramdir, "shader.glsl") frag_file = Filename(ramdir, "shader.glsl") # Now write some actual content to the shader files. vfs.write_file(vert_file, b"#version 100\nvoid main() {}\n", False) shad1 = Shader.load(Shader.SL_GLSL, vertex=vert_file, fragment=frag_file) assert shad1 is not None assert shad1.this # Load the same shader, it should return the cached result. shad2 = Shader.load(Shader.SL_GLSL, vertex=vert_file, fragment=frag_file) assert shad2 is not None assert shad1.this == shad2.this # After waiting a second to make the timestamp different, modify the # shader and load again, it should result in a different object now time.sleep(1.0) vfs.write_file(vert_file, b"#version 110\nvoid main() {}\n", False) shad2 = Shader.load(Shader.SL_GLSL, vertex=vert_file, fragment=frag_file) assert shad2.this != shad1.this
def shader(self, value): try: self.setShader(Shader.load(f'{value}.sha', Shader.SL_Cg)) except: self.setShader( Shader.load(Shader.SL_GLSL, vertex=f'{value}.vert', fragment=f'{value}.frag'))
def __init__(self): ShowBase.__init__(self) self.disableMouse() self.scene = self.loader.loadModel('models/environment') self.scene.reparentTo(self.render) self.scene.setScale(0.25, 0.25, 0.25) self.scene.setPos(-8, 42, 0) self.taskMgr.add(self.spin_camera_task, 'SpinCameraTask') self.taskMgr.add(self.update_shader_inputs_task, 'UpdateShaderInputsTask') self.pandaActor = Actor('models/panda-model', {'walk': 'models/panda-walk4'}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.reparentTo(self.render) self.pandaActor.loop('walk') pos_interval1 = self.pandaActor.posInterval(13, Point3(0, -10, 0), startPos=Point3(0, 10, 0)) pos_interval2 = self.pandaActor.posInterval(13, Point3(0, 10, 0), startPos=Point3(0, -10, 0)) hpr_interval1 = self.pandaActor.hprInterval(3, Point3(180, 0, 0), startHpr=Point3(0, 0, 0)) hpr_interval2 = self.pandaActor.hprInterval(3, Point3(0, 0, 0), startHpr=Point3(180, 0, 0)) self.pandaPace = Sequence(pos_interval1, hpr_interval1, pos_interval2, hpr_interval2, name="pandaPace") self.pandaPace.loop() my_vertex_shader_path = os.path.join(SHADERS_DIR, 'my_shader.vert') my_fragment_shader_path = os.path.join(SHADERS_DIR, 'my_shader.frag') my_shader = Shader.load(Shader.SL_GLSL, vertex=my_vertex_shader_path, fragment=my_fragment_shader_path) tutorial_vertex_shader_path = os.path.join(SHADERS_DIR, 'tutorial_shader.vert') tutorial_fragment_shader_path = os.path.join(SHADERS_DIR, 'tutorial_shader.frag') tutorial_shader = Shader.load(Shader.SL_GLSL, vertex=tutorial_vertex_shader_path, fragment=tutorial_fragment_shader_path) self.pandaActor.setShaderInputs( **{ 'u_resolution': Vec2(self.win.getXSize(), self.win.getYSize()), }) self.pandaActor.set_shader(tutorial_shader)
def __init__(self, base, render, cam_node): # State vars self.scroll_down = False self.shift_down = False self.cam_node = cam_node self.base = base self.render = render self.cam_active = True self.delta_mouse = (0, 0) self.last_mouse = (0, 0) self.start_mouse = (0, 0) self.orbit_center = LVector3f(0, 0, 0) self.start_orbit = self.orbit_center self.plane_normal = np.array([0, 0, 0]) # Load skinned shader self.base.cam.node().setTagStateKey("shader type") shader_folder_path = Path( path.realpath(__file__)).parent.parent.parent / "res/shaders" self.skinned_shader = Shader.load( Shader.SL_GLSL, vertex=Filename(shader_folder_path / "skinned.vert").cStr(), fragment=Filename(shader_folder_path / "skinned.frag").cStr()) skinned_render_state = NodePath("") skinned_render_state.set_shader(self.skinned_shader) self.base.cam.node().setTagState("skinned", skinned_render_state.get_state()) # Load gizmo shader self.gizmo_shader = Shader.load( Shader.SL_GLSL, vertex=Filename(shader_folder_path / "gizmo.vert").cStr(), fragment=Filename(shader_folder_path / "gizmo.frag").cStr()) gizmo_render_state = NodePath("") gizmo_render_state.set_shader(self.gizmo_shader) self.base.render.set_shader_input("cam_pos", self.cam_node.getPos()) self.base.cam.node().setTagState("gizmo", gizmo_render_state.get_state()) # Register events self.accept("mouse2", self.handle_scroll_pressed) self.accept("mouse2-up", self.handle_scroll_released) self.accept("shift-mouse2", self.handle_shift_scroll_pressed) self.accept("shift-mouse2-up", self.handle_shift_scroll_released) self.accept("wheel_up", self.handle_scroll_up) self.accept("wheel_down", self.handle_scroll_down) # Set up camera self.cam_node.setPos(0, -1, 0) self.forward = (-self.cam_node.getPos()).normalized() self.up_angle = 0 self.left_angle = 0 self.addTask(self.cam_ctrl_task)
def load_shaders(self): shaders = Shader.load(Shader.SL_GLSL, 'gas_giant_vertex.glsl', 'gas_giant_fragment.glsl', '', "Shader/DefaultShaders/Opaque/tesscontrol.glsl", "Shader/DefaultShaders/Opaque/tesseval.glsl") shaders = Shader.load(Shader.SL_GLSL, 'gas_giant_vertex.glsl', 'gas_giant_fragment.glsl') #convertToPatches(self.node_path) self.node_path.set_shader(shaders, 51)
def setShaders(self): shaderV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/OcclusionBlurV.fragment") self.targetV.setShader(shaderV) shaderH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/OcclusionBlurH.fragment") self.targetH.setShader(shaderH) return [shaderV, shaderH]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/MotionBlur.fragment") self.target.setShader(shader) shaderDilate = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/MotionBlurDilate.fragment") self.targetDilate0.setShader(shaderDilate) self.targetDilate1.setShader(shaderDilate) return [shader, shaderDilate]
def setShaders(self): shaderV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/OcclusionBlurV.fragment") self.targetV.setShader(shaderV) shaderH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/OcclusionBlurH.fragment") self.targetH.setShader(shaderH) return [shaderV, shaderH]
def shader(self, value): if isinstance(value, Shader): self.setShader(value) return if value is None: self.setShaderAuto() return try: self.setShader(Shader.load(f'{value}.sha', Shader.SL_Cg)) except: self.setShader(Shader.load(Shader.SL_GLSL, vertex=f'{value}.vert', fragment=f'{value}.frag'))
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/MotionBlur.fragment") self.target.setShader(shader) shaderDilate = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/MotionBlurDilate.fragment") self.targetDilate0.setShader(shaderDilate) self.targetDilate1.setShader(shaderDilate) return [shader, shaderDilate]
def enable_fxaa(self): tex1 = Texture() quad1 = self._manager.renderQuadInto(colortex=tex1) tex2 = Texture() self._quads.append(quad1) quad1.setShader(Shader.load("assets/shaders/post/fxaa.sha")) quad1.setShaderInput("color", tex1) quad1.setShaderInput("active", 1) quad2 = self._manager.renderSceneInto(colortex=tex2) self._quads.append(quad2) quad2.setShader(Shader.load("assets/shaders/post/color.sha")) quad2.setShaderInput("tex", tex2)
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/BloomExtract.fragment") self.target.setShader(shader) shaderV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/BloomBlurV.fragment") self.targetV.setShader(shaderV) shaderH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/BloomBlurH.fragment") self.targetH.setShader(shaderH) shaderMerge = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/BloomMerge.fragment") self.targetMerge.setShader(shaderMerge) return [shader, shaderV, shaderH]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/RenderClouds.fragment") self.target.setShader(shader) shaderV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/CloudBlurV.fragment") self.targetV.setShader(shaderV) shaderH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/CloudBlurH.fragment") self.targetH.setShader(shaderH) return [shader]
def SetupVisibleTerrain(self): self.terrain_node = ShaderTerrainMesh() self.terrain_node.heightfield = self.loader.loadTexture(self.PngDEM) self.terrain_node.target_triangle_width = 100.0 self.terrain_node.generate() self.terrain = self.render.attach_new_node(self.terrain_node) self.terrain.set_scale(self.PixelNr * self.MeterScale, self.PixelNr * self.MeterScale, self.HeightRange) terrain_shader = Shader.load(Shader.SL_GLSL, "terrain.vert.glsl", "terrain.frag.glsl") self.terrain.set_shader(terrain_shader) self.terrain.set_shader_input("camera", self.camera) grass_tex = self.loader.loadTexture(self.TextureImage) grass_tex.set_anisotropic_degree(16) self.terrain.set_texture(grass_tex) self.terrain.setPos(0, 0, self.OffsetHeight)
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/LightingPass.fragment") self.target.setShader(shader) return [shader]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/CombineOcclusion.fragment") self.target.setShader(shader) return [shader]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/CombineOcclusion.fragment") self.target.setShader(shader) return [shader]
def __init__(self, terrain_model="content/models/terrain.egg"): myShader = Shader.load(Shader.SLGLSL, "content/shaders/terr_vert.glsl", "content/shaders/terr_frag.glsl") self.terrain = loader.loadModel("content/models/terrain.egg") self.terrain.reparentTo(render) def prepareTexture(tex): tex.setMinfilter(Texture.FTLinearMipmapLinear) self.terrain.setShaderInput("tilingFactor", 50) dirtTex = loader.loadTexture("content/textures/sand.jpg") prepareTexture(dirtTex) self.terrain.setShaderInput("region1ColorMap", dirtTex) dirtTex = loader.loadTexture("content/textures/dirt.JPG") prepareTexture(dirtTex) self.terrain.setShaderInput("region2ColorMap", dirtTex) dirtTex = loader.loadTexture("content/textures/rock.JPG") prepareTexture(dirtTex) self.terrain.setShaderInput("region3ColorMap", dirtTex) dirtTex = loader.loadTexture("content/textures/snow.JPG") prepareTexture(dirtTex) self.terrain.setShaderInput("region4ColorMap", dirtTex) print self.terrain.ls(); self.collider = self.terrain.find('**/Terrain') self.terrain.setShader(myShader)
def setup(self, scenario: Scenario): self._scenario = scenario self._root_np = NodePath("sim") self._root_np.reparentTo(self.render) with pkg_resources.path( glsl, "unlit_shader.vert" ) as vshader_path, pkg_resources.path( glsl, "unlit_shader.frag" ) as fshader_path: unlit_shader = Shader.load( Shader.SL_GLSL, vertex=str(vshader_path.absolute()), fragment=str(fshader_path.absolute()), ) self._root_np.setShader(unlit_shader) self._setup_road_network() self._vehicles_np = self._root_np.attachNewNode("vehicles") self._bubble_manager = BubbleManager(scenario.bubbles, scenario.road_network) self._trap_manager = TrapManager(scenario) self._setup_bullet_client(self._bullet_client) provider_state = self._setup_providers(self._scenario) self._agent_manager.setup_agents(self) self._harmonize_providers(provider_state) self._last_provider_state = provider_state self._is_setup = True
def create_model(self): # Set up the vertex arrays vformat = GeomVertexFormat.get_v3c4() vdata = GeomVertexData("Data", vformat, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') geom = Geom(vdata) # Vertex data vertex.addData3f(1.5, 0, -1) color.addData4f(1, 0, 0, 1) vertex.addData3f(-1.5, 0, -1) color.addData4f(0, 1, 0, 1) vertex.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) # Primitive tri = GeomTriangles(Geom.UHStatic) tri.add_vertex(2) tri.add_vertex(1) tri.add_vertex(0) tri.close_primitive() geom.addPrimitive(tri) # Create the actual node node = GeomNode('geom_node') node.addGeom(geom) np = NodePath(node) # Shader and initial shader vars np.set_shader(Shader.load(Shader.SL_GLSL, "shader/shader.vert", "shader/shader.frag")) np.set_shader_input("time", 0.0) # No instancing necessary #np.set_instance_count(27) # return np np.reparent_to(base.render) self.model = np
def displayCBuffer(self, manager): tex = Texture() #Color texture dtex = Texture() #Depth texture quad = manager.renderSceneInto(colortex=tex, depthtex=dtex) #Produce filter of window quad.setShader(Shader.load("z_buf.sha")) #Apply shader to scene quad.setShaderInput("dtex", dtex) quad.setTexture(tex) #Apply regular color texture to filter
def __init__(self): ShowBase.__init__(self) mesh = Mesh.create_plate(position=(0, 0), width=6, height=2, num_elements_width=6, num_elements_height=3) geom = mesh.get_render_mesh() node = GeomNode('g-node') node.addGeom(geom) node_path = self.render.attachNewNode(node) # noinspection PyArgumentList shader = Shader.load(lang=Shader.SL_GLSL, vertex="../shaders/grid_shader.vert", fragment="../shaders/grid_shader.frag") node_path.setShader(shader) node_path.set_shader_input('color', (0.2, 0.5, 0)) self.camera.setPos(0, 0, 10) self.camera.lookAt(node_path) self.disableMouse() controller = MouseController(self.camera, self) controller.zoom()
def create_instance(self): self.create_buffer() # Water surface maker = CardMaker('water') maker.setFrame(self.x1, self.x2, self.y1, self.y2) self.waterNP = self.parent.instance.attachNewNode(maker.generate()) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, self.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, self.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, self.z + 1), Point3(0, 0, self.z)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) # 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 reload_shader(self): self.model.set_shader(Shader.load(Shader.SL_GLSL, vertex = "shader.vert", tess_control = "shader.tesc", tess_evaluation = "shader.tese", geometry = "shader.geom", fragment = "shader.frag"))
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/SkyboxMask.fragment") self.target.setShader(shader) return [shader]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/VolumetricLighting.fragment") self.target.setShader(shader) return [shader]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/Antialiasing/FXAA/FXAA3.fragment") self.target.setShader(shader) return [shader]
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/TransparencyPass.fragment") self.target.setShader(shader) return [shader]
def create_instance(self): self.create_buffer() # Water surface maker = CardMaker('water') maker.setFrame(self.x1, self.x2, self.y1, self.y2) self.waterNP = self.parent.instance.attachNewNode(maker.generate()) self.waterNP.hide(BaseObject.AllCamerasMask) self.waterNP.show(BaseObject.DefaultCameraMask) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, self.z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) vertex_shader = defaultDirContext.find_shader('water-vertex.glsl') fragment_shader = defaultDirContext.find_shader('water-fragment.glsl') self.waterNP.setShader( Shader.load( Shader.SL_GLSL, vertex=Filename.from_os_specific(vertex_shader).get_fullpath(), fragment=Filename.from_os_specific( fragment_shader).get_fullpath())) self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, self.scale, 0)) # vx, vy, scale, skip # offset, strength, refraction factor (0=perfect mirror, 1=total refraction), refractivity self.waterNP.setShaderInput('waterdistort', Vec4(0.4, 1.0, 0.25, 0.45)) self.waterNP.setShaderInput('time', 0) self.waterNP.setShaderInput('reflection_tex', self.texture) # distortion texture tex1 = loader.loadTexture('textures/water.png') self.waterNP.setShaderInput('distortion_tex', tex1)
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/PrecomputeLights.fragment") self.target.setShader(shader) return [shader]
def create_model(self): # Set up the vertex arrays vformat = GeomVertexFormat.get_v3c4() vdata = GeomVertexData("Data", vformat, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') geom = Geom(vdata) # Vertex data vertex.addData3f(1.5, 0, -1) color.addData4f(1, 0, 0, 1) vertex.addData3f(-1.5, 0, -1) color.addData4f(0, 1, 0, 1) vertex.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) # Primitive tri = GeomTriangles(Geom.UHStatic) tri.add_vertex(2) tri.add_vertex(1) tri.add_vertex(0) tri.close_primitive() geom.addPrimitive(tri) # Create the actual node node = GeomNode('geom_node') node.addGeom(geom) np = NodePath(node) # Shader and initial shader vars np.set_shader( Shader.load(Shader.SL_GLSL, "shader/shader.vert", "shader/shader.frag")) np.set_shader_input("time", 0.0) # No instancing necessary #np.set_instance_count(27) # return np np.reparent_to(base.render) self.model = np
def enableEffects(self, reflScene, refrScene, underwaterRefrScene): self.disableFakeEffect() static = loader.loadTexture(self.spec.staticTex) if not self.spec.cheap: self.topNP.setShader( Shader.load(Shader.SL_GLSL, "phase_14/models/shaders/water_v.glsl", "phase_14/models/shaders/water_f.glsl"), 2) self.topNP.setShaderInput("dudv", static) self.topNP.setShaderInput("dudv_tile", self.spec.dudvTile) self.topNP.setShaderInput("dudv_strength", self.spec.dudvStrength) self.topNP.setShaderInput("move_factor", self.spec.moveFactor) self.topNP.setShaderInput("near", CIGlobals.DefaultCameraNear) self.topNP.setShaderInput("far", CIGlobals.DefaultCameraFar) self.topNP.setShaderInput("normal_map", static) self.topNP.setShaderInput("fog_density", self.spec.fog.density) self.topNP.setShaderInput("fog_color", self.spec.fog.color) self.topNP.setShaderInput("water_tint", self.spec.tint) self.topNP.setShaderInput("reflect_factor", self.spec.reflectFactor) self.topNP.setShaderInput("static_depth", self.depth) self.botNP.setShader( Shader.load(Shader.SL_GLSL, "phase_14/models/shaders/water_bottom_v.glsl", "phase_14/models/shaders/water_bottom_f.glsl"), 2) self.botNP.setShaderInput("dudv", static) self.botNP.setShaderInput("dudv_tile", self.spec.dudvTile) self.botNP.setShaderInput("dudv_strength", self.spec.dudvStrength) self.botNP.setShaderInput("move_factor", self.spec.moveFactor) self.botNP.setShaderInput("water_tint", self.spec.tint) else: # We are doing cheap water self.topNP.setShader( Shader.load(Shader.SL_GLSL, "phase_14/models/shaders/water_cheap_v.glsl", "phase_14/models/shaders/water_cheap_f.glsl"), 2) self.topNP.setShaderInput("tex_scale", self.spec.dudvTile) self.topNP.setShaderInput("cube_map", self.cubemap) self.topNP.setShaderInput("normal_map", static) self.topNP.setShaderInput("base_map", static) self.topNP.setShaderInput("reflectivity", self.spec.reflectivity) self.topNP.setShaderInput("water_tint", self.spec.tint) self.setTextureInputs(reflScene, refrScene, underwaterRefrScene)
def __init__(self,manager,xml): self.updateTask = None self.sun = base.cam.attachNewNode('sun') loader.loadModel(manager.get('paths').getConfig().find('misc').get('path')+'/sphere').reparentTo(self.sun) self.sun.setScale(0.1) self.sun.setTwoSided(True) self.sun.setColorScale(10.0, 10.0, 10.0, 1.0, 10001) self.sun.setLightOff(1) self.sun.setShaderOff(1) self.sun.setFogOff(1) self.sun.setCompass() self.sun.setBin('background', 10) self.sun.setDepthWrite(False) self.sun.setDepthTest(False) # Workaround an annoyance in Panda. No idea why it's needed. self.sun.node().setBounds(OmniBoundingVolume()) isa = xml.find('isa') inst = xml.find('instance') if isa != None or inst != None: if inst != None: orig = Vec3(float(inst.get('x', '0')), float(inst.get('y', '0')), float(inst.get('z', '0'))) else: level = manager.get(isa.get('source')) orig = Vec3(level.getByIsA(isa.get('name'))[0].getPos(render)) orig.normalize() self.sun.setPos(orig) godrays = xml.find('godrays') if godrays != None: self.vlbuffer = base.win.makeTextureBuffer('volumetric-lighting', base.win.getXSize()/2, base.win.getYSize()/2) self.vlbuffer.setClearColor(Vec4(0, 0, 0, 1)) cam = base.makeCamera(self.vlbuffer) cam.node().setLens(base.camLens) cam.reparentTo(base.cam) initstatenode = NodePath('InitialState') initstatenode.setColorScale(0, 0, 0, 1, 10000) initstatenode.setShaderOff(10000) initstatenode.setLightOff(10000) initstatenode.setMaterialOff(10000) initstatenode.setTransparency(TransparencyAttrib.MBinary, 10000) cam.node().setCameraMask(BitMask32.bit(2)) cam.node().setInitialState(initstatenode.getState()) self.vltexture = self.vlbuffer.getTexture() self.vltexture.setWrapU(Texture.WMClamp) self.vltexture.setWrapV(Texture.WMClamp) card = CardMaker('VolumetricLightingCard') card.setFrameFullscreenQuad() self.finalQuad = render2d.attachNewNode(card.generate()) self.finalQuad.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OFbufferColor)) self.finalQuad.setShader(Shader.load(posixpath.join(manager.get('paths').getConfig().find('shaders').get('path'), 'filter-vlight.cg'))) self.finalQuad.setShaderInput('src', self.vltexture) self.finalQuad.setShaderInput('vlparams', 32, 0.9/32.0, 0.97, 0.5) # Note - first 32 is now hardcoded into shader for cards that don't support variable sized loops. self.finalQuad.setShaderInput('casterpos', 0.5, 0.5, 0, 0) # Last parameter to vlcolor is the exposure vlcolor = Vec4(float(godrays.get('r', '1')), float(godrays.get('g', '1')), float(godrays.get('b', '1')), 0.04) self.finalQuad.setShaderInput('vlcolor', vlcolor) else: self.finalQuad = None
def __init__(self): ShowBase.__init__(self) self.base = ShowBase self.model = None self.lastModelPath = "" self.showNode = NodePath() self.shader_rainbowGradient = Shader.load( Shader.SL_GLSL, vertex="tt_sha_render_rainbowgrad.vert", fragment="tt_sha_render_rainbowgrad.frag") self.shader_rainbow = Shader.load( Shader.SL_GLSL, vertex="tt_sha_render_rainbow.vert", fragment="tt_sha_render_rainbow.frag") self.shader_downsample = Shader.load(Shader.SL_GLSL, vertex="hdr_scene.vert.glsl", fragment="hdr_scene.frag.glsl") self.shader_fxaa = Shader.load(Shader.SL_GLSL, vertex="fxaa.vert.glsl", fragment="fxaa.frag.glsl") self.shader_drunk = Shader.load(Shader.SL_GLSL, vertex="tt_sha_render_drunk.vert", fragment="tt_sha_render_drunk.frag") self.accept('o', base.oobe) self.loadGUI() # Just in case we have these enabled in the config... base.setFrameRateMeter(False) base.setSceneGraphAnalyzerMeter(False) self.accept('a', render.analyze) self.accept('r', self.resetCam) self.accept('c', self.clearScene) self.accept('s', base.screenshot) self.accept("1", self.enableShader) self.accept("2", self.enableShader1) self.accept("3", self.enableShader2) self.accept("4", self.enableShader3) self.accept("0", self.enableShader0)
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/RenderClouds.fragment") self.target.setShader(shader) shaderV = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/CloudBlurV.fragment") self.targetV.setShader(shaderV) shaderH = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/CloudBlurH.fragment") self.targetH.setShader(shaderH) return [shader]
def reload_shader(self): self.model.set_shader( Shader.load(Shader.SL_GLSL, vertex="shader.vert", tess_control="shader.tesc", tess_evaluation="shader.tese", geometry="shader.geom", fragment="shader.frag"))
def __init__(self, pure_background: bool = False): super(SkyBox, self).__init__() self._accumulate = 0 self.f = 1 if not self.render or pure_background: self.node_path = NodePath("pure_background") return skybox = self.loader.loadModel( AssetLoader.file_path("models", "skybox.bam")) skybox.hide(CamMask.MiniMap | CamMask.RgbCam | CamMask.Shadow | CamMask.ScreenshotCam) skybox.set_scale(20000) skybox_texture = self.loader.loadTexture( AssetLoader.file_path("textures", "skybox.jpg")) skybox_texture.set_minfilter(SamplerState.FT_linear) skybox_texture.set_magfilter(SamplerState.FT_linear) skybox_texture.set_wrap_u(SamplerState.WM_repeat) skybox_texture.set_wrap_v(SamplerState.WM_mirror) skybox_texture.set_anisotropic_degree(16) skybox.set_texture(skybox_texture) gles = ConfigVariableString("load-display").getValue() if gles == "pandagles2": skybox_shader = Shader.load( Shader.SL_GLSL, AssetLoader.file_path("shaders", "skybox_gles.vert.glsl"), # FIXME a potential bug here? AssetLoader.file_path("shaders", "skybox_gles.frag.glsl")) else: if is_mac(): vert_file = "skybox_mac.vert.glsl" frag_file = "skybox_mac.frag.glsl" else: vert_file = "skybox.vert.glsl" frag_file = "skybox.frag.glsl" skybox_shader = Shader.load( Shader.SL_GLSL, AssetLoader.file_path("shaders", vert_file), # FIXME a potential bug here? AssetLoader.file_path("shaders", frag_file)) skybox.set_shader(skybox_shader) self.node_path = skybox skybox.setZ(-4400) skybox.setH(30)
def _setGuiShaders(self): """ Sets the default shaders to the gui, this is required when disabling the fixed function pipeline """ shader = Shader.load(Shader.SLGLSL, "Shader/GUI/vertex.glsl", "Shader/GUI/fragment.glsl") for target in [self.showbase.aspect2d, self.showbase.render2d, self.showbase.pixel2d, self.showbase.aspect2dp, self.showbase.render2dp, self.showbase.pixel2dp]: # target.setShader(shader, 50) pass
def getStippleShader(): global StippleShader if not StippleShader: shattr = ShaderAttrib.make(Shader.load(Shader.SLGLSL, "shaders/editor/lineStipple.vert.glsl", "shaders/editor/lineStipple.frag.glsl")) shattr = shattr.setShaderInput("stippleParams", LVector2i(0xAAAA, 10)) StippleShader = shattr return StippleShader
def setup_post_effect(self): self.manager = FilterManager(base.win, base.cam) tex = Texture() dtex = Texture() quad = self.manager.renderSceneInto(colortex=tex, depthtex=dtex) quad.setShader(Shader.load(Shader.SL_GLSL, "vertex.glsl", "fragment.glsl")) quad.setShaderInput("tex", tex) quad.setShaderInput("dtex", dtex)
def _createGenerateMipmapsShader(self): """ Loads the shader for generating the voxel grid mipmaps """ computeSize = self.voxelGridResolution for child in self.mipmapTargets: computeSize /= 2 shader = Shader.load( Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/GI/GenerateMipmaps/" + str(computeSize) + ".fragment") child.setShader(shader)
def load_shader(self): """ The function loads the vertex and fragment shader. It provides an example of sending the model-view-projection matrix to the shader program when it's calculated. """ self.shader = Shader.load(Shader.SL_GLSL, "vertex.glsl", "fragment.glsl"); self.model.set_shader(self.shader) self.model.set_shader_input("my_ModelViewProjectionMatrix", LMatrix4f())
def setShaders(self): shaderFirstPass = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DownsampleFirstPass.fragment") self.downscalePass0.setShader(shaderFirstPass) shaderDownsample = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/Downsample.fragment") for scalePass in self.downscalePasses: scalePass.setShader(shaderDownsample) shaderFinal = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DownsampleFinalPass.fragment") self.finalDownsamplePass.setShader(shaderFinal) return [shaderFirstPass, shaderDownsample, shaderFinal]
def _createGenerateMipmapsShader(self): """ Loads the shader for generating the voxel grid mipmaps """ computeSize = self.voxelGridResolution for child in self.mipmapTargets: computeSize /= 2 shader = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/GI/GenerateMipmaps/" + str(computeSize) + ".fragment") child.setShader(shader)
def setShaders(self): for name, quad in self.quads.iteritems(): shader = Shader.load(Shader.SLGLSL, "Shader/ApplyLights/ApplyLights.vertex", "Shader/ApplyLights/" + name + ".fragment", "Shader/ApplyLights/ApplyLights.geometry") quad.setShader(shader) return []
def setShaders(self): shaderFirstPass = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DownsampleFirstPass.fragment") self.downscalePass0.setShader(shaderFirstPass) shaderDownsample = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/Downsample.fragment") for scalePass in self.downscalePasses: scalePass.setShader(shaderDownsample) shaderFinal = Shader.load(Shader.SLGLSL, "Shader/DefaultPostProcess.vertex", "Shader/DownsampleFinalPass.fragment") self.finalDownsamplePass.setShader(shaderFinal) return [shaderFirstPass, shaderDownsample, shaderFinal]
def setShaders(self, refreshPipeline=True): """ Sets all shaders """ self.debug("Reloading Shaders ..") if self.renderPipeline: self.scene.setShader( self.renderPipeline.getDefaultObjectShader(False)) self.model.setShader(Shader.load(Shader.SLGLSL, "DefaultObjectShader/vertex.glsl", "dynamicMaterialFragment.glsl")) if refreshPipeline: self.renderPipeline.reloadShaders() if self.skybox: self.skybox.setShader(Shader.load(Shader.SLGLSL, "DefaultObjectShader/vertex.glsl", "Skybox/fragment.glsl"))
def load_shader(self): """ The function loads the vertex and fragment shader. It provides an example of sending the model-view-projection matrix to the shader program when it's calculated. """ self.shader = Shader.load(Shader.SL_GLSL, "vertex.glsl", "fragment.glsl"); self.model.set_shader(self.shader) self.model.set_shader_input("my_ModelViewProjectionMatrix", LMatrix4f())
def setShaders(self): shader = Shader.load(Shader.SLGLSL, "Shader/TransparencyShade/vertex.glsl", "Shader/TransparencyShade/fragment.glsl", "Shader/TransparencyShade/geometry.glsl", ) self.target.setShader(shader) return [shader]
def load_shaders(self): shaders = Shader.load(Shader.SL_GLSL, 'Shader/Planet/surface_vertex.glsl', 'Shader/Planet/surface_fragment.glsl', '', "Shader/DefaultShaders/Opaque/tesscontrol.glsl", "Shader/DefaultShaders/Opaque/tesseval.glsl") convertToPatches(self.node_path) self.node_path.set_shader(shaders, 51)
def setShaders(self): casterShader = Shader.load(Shader.SLGLSL, "Shader/DefaultShaders/ShadowCasting/vertex.glsl", "Shader/DefaultShaders/ShadowCasting/fragment.glsl") initialState = NodePath("ShadowCasterState") initialState.setShader(casterShader, 100) initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff)) for camera in self.shadowCameras: camera.node().setTagState("Default", initialState.getState()) casterShaderTransparent = Shader.load(Shader.SLGLSL, "Shader/DefaultShaders/TransparentShadowCasting/vertex.glsl", "Shader/DefaultShaders/TransparentShadowCasting/fragment.glsl") initialState = NodePath("ShadowCasterStateTransparent") initialState.setShader(casterShaderTransparent, 100) initialState.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff)) for camera in self.shadowCameras: camera.node().setTagState("Transparent", initialState.getState()) return [casterShader, casterShaderTransparent]
def create_model(self): # Set up the vertex arrays vformatArray = GeomVertexArrayFormat() # Panda3D implicitly generates a bounding volume from a # column named "vertex", so you either # * have a column of that name, or # * add a bounding volume yourself. vformatArray.addColumn(InternalName.make("vertex"), 3, Geom.NTFloat32, Geom.CPoint) vformatArray.addColumn(InternalName.make("color"), 4, Geom.NTFloat32, Geom.CColor) vformat = GeomVertexFormat() vformat.addArray(vformatArray) vformat = GeomVertexFormat.registerFormat(vformat) vdata = GeomVertexData("Data", vformat, Geom.UHStatic) vertex = GeomVertexWriter(vdata, 'vertex') color = GeomVertexWriter(vdata, 'color') geom = Geom(vdata) # Vertex data vertex.addData3f(1.5, 0, -1) color.addData4f(1, 0, 0, 1) vertex.addData3f(-1.5, 0, -1) color.addData4f(0, 1, 0, 1) vertex.addData3f(0, 0, 1) color.addData4f(0, 0, 1, 1) # Primitive tri = GeomPatches(3, Geom.UHStatic) tri.add_vertex(2) tri.add_vertex(1) tri.add_vertex(0) tri.close_primitive() geom.addPrimitive(tri) # Create the actual node node = GeomNode('geom_node') node.addGeom(geom) np = NodePath(node) # Shader, initial shader vars, number of instances np.set_shader(Shader.load(Shader.SL_GLSL, vertex = "shader.vert", tess_control = "shader.tesc", tess_evaluation = "shader.tese", geometry = "shader.geom", fragment = "shader.frag")) np.set_shader_input("time", 0.0) np.set_shader_input("tess_level", 32.0) np.set_instance_count(num_instances) np.set_shader_input("numInstances", num_instances) return np
def _createRT(self, name, width, height, attachAuxTexture=False, shaderName="", layers=1): """ Internal shortcut to create a new render target. The name should be a unique identifier. When attachAuxTexture is True, an aux texture will be attached to the buffer, additionally to the color texture. The shader name determines the shader to load for the target, see below. When layers is > 1, a layered render target will be created to render to a 3D texture.""" # Setup the render target target = RenderTarget("Scattering" + name) target.setSize(width, height) target.addColorTexture() target.setColorBits(32) # Adds aux textures if specified if attachAuxTexture: target.addAuxTextures(1) target.setAuxBits(32) # Add render layers if specified if layers > 1: target.setLayers(layers) target.prepareOffscreenBuffer() # Load the appropriate shader sArgs = ["Shader/Scattering/DefaultVertex.vertex", "Shader/Scattering/" + shaderName + ".fragment"] # When using layered rendering, a geometry shader is required if layers > 1: sArgs.append("Shader/Scattering/DefaultGeometry.geometry") shader = Shader.load(Shader.SLGLSL, *sArgs) target.setShader(shader) # Make the scattering options available self._setInputs(target, "options") # Lowercase the first letter lowerCaseFirst = lambda x: x[0].lower() + x[1:] # Make all rendered textures so far available to the target for key, tex in self.textures.iteritems(): target.setShaderInput(key, tex) # Register the created textures self.textures[lowerCaseFirst(name) + "Color"] = target.getColorTexture() if attachAuxTexture: self.textures[lowerCaseFirst(name) + "Aux"] = target.getAuxTexture(0) return target
def __init__(self): ShowBase.__init__(self) manager = FilterManager(base.win, base.cam) tex = Texture() quad = manager.renderSceneInto(colortex=tex) quad.setShader(Shader.load("myfilter.sha")) quad.setShaderInput("tex", tex) # Disable the camera trackball controls. self.disableMouse() # Load the environment model. self.environ = self.loader.loadModel("models/environment") # Reparent the model to render. self.environ.reparentTo(self.render) # Apply scale and position transforms on the model. self.environ.setScale(0.25, 0.25, 0.25) self.environ.setPos(-8, 42, 0) # Add the spinCameraTask procedure to the task manager. self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Load and transform the panda actor. self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.reparentTo(self.render) # Loop its animation. self.pandaActor.loop("walk") # Create the four lerp intervals needed for the panda to # walk back and forth. pandaPosInterval1 = self.pandaActor.posInterval(13, Point3(0, -10, 0), startPos=Point3(0, 10, 0)) pandaPosInterval2 = self.pandaActor.posInterval(13, Point3(0, 10, 0), startPos=Point3(0, -10, 0)) pandaHprInterval1 = self.pandaActor.hprInterval(3, Point3(180, 0, 0), startHpr=Point3(0, 0, 0)) pandaHprInterval2 = self.pandaActor.hprInterval(3, Point3(0, 0, 0), startHpr=Point3(180, 0, 0)) # Create and play the sequence that coordinates the intervals. self.pandaPace = Sequence(pandaPosInterval1, pandaHprInterval1, pandaPosInterval2, pandaHprInterval2, name="pandaPace") self.pandaPace.loop()
def _createShaderObjects(self): """ Creates the shaders from the parsed shader code """ for stage, parts in self.shaderParts.iteritems(): programs = {"vertex": "", "fragment": "", "geometry": "", "tesscontrol": "", "tesseval": ""} for progName, progCode in parts.iteritems(): fname = self._createShaderFile(stage, progName, progCode) programs[progName] = fname params = [programs["vertex"], programs["fragment"], programs["geometry"], programs["tesscontrol"], programs["tesseval"]] shaderObj = Shader.load(Shader.SLGLSL, *params) self.shaderObjs[stage] = shaderObj
def make_star(name='star', scale=1, color=Vec3(1), texture_size=64, debug=False): card_maker = CardMaker(name) card_maker.set_frame(-1, 1, -1, 1) node_path = NodePath(name) node = card_maker.generate() final_node_path = node_path.attach_new_node(node) final_node_path.set_billboard_point_eye() from panda3d.core import Filename shaders = Shader.load(Shader.SL_GLSL, Filename('Shader/Star/vertex.glsl'), Filename('Shader/Star/fragment.glsl'), Filename(''), Filename(''), Filename('')) if not shaders: print("WARNING. STAR SHADER FAILED TO LOAD", type(shaders)) else: final_node_path.set_shader_input('cameraSpherePos', 1, 1, 1) final_node_path.set_shader_input('sphereRadius', 1.0) final_node_path.set_shader_input('myCamera', base.camera) final_node_path.set_shader(shaders) final_node_path.set_shader_input('blackbody', color) material = Material() material.set_emission(VBase4(color, 1.0)) final_node_path.set_material(material) xn = PerlinNoise3(0.5, 0.5, 0.5) #yn = PerlinNoise3(0.5, 0.5, 0.5) texture = Texture('star') texture.setup_3d_texture() for z in range(texture_size): p = PNMImage(texture_size, texture_size) for y in range(texture_size): for x in range(texture_size): p.set_gray(x, y, abs(xn.noise(x, y, z))) texture.load(p, z, 0) diffuse = texture diffuse.setMinfilter(Texture.FTLinearMipmapLinear) diffuse.setAnisotropicDegree(4) final_node_path.set_texture(diffuse) normal = sandbox.base.loader.loadTexture('data/empty_textures/empty_normal.png') normalts = TextureStage('normalts') final_node_path.set_texture(normalts, normal) specular = sandbox.base.loader.loadTexture('data/empty_textures/empty_specular.png') spects = TextureStage('spects') final_node_path.set_texture(spects, specular) roughness = sandbox.base.loader.loadTexture('data/empty_textures/empty_roughness.png') roughts= TextureStage('roughts') final_node_path.set_texture(roughts, roughness) return final_node_path
def _load_shader(self, *args): """ Loads a shader from the given args. If only one argument is passed, the default template for the stage is loaded. If two arguments are passed, the first argument should be the vertex shader and the second argument should be the fragment shader. If three arguments are passed, the order should be vertex, fragment, geometry """ assert len(args) > 0 and len(args) <= 3 args = ["Shader/" + i + ".glsl" if "$$PipelineTemp" not in i else i for i in args] # If only one shader is specified, assume its a postprocess fragment shader, # and use the default vertex shader if len(args) == 1: args = ["Shader/DefaultPostProcess.vert.glsl"] + args return Shader.load(Shader.SLGLSL, *args)