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)
