def load_shaders():
global render_prog
global uniforms
global skybox_prog
if (render_prog):
glDeleteProgram(render_prog)
vs = shader_load("render.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("render.fs.glsl", GL_FRAGMENT_SHADER)
render_prog = glCreateProgram()
glAttachShader(render_prog, vs)
glAttachShader(render_prog, fs)
glLinkProgram(render_prog)
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.render.mv_matrix = glGetUniformLocation(render_prog, "mv_matrix")
uniforms.render.proj_matrix = glGetUniformLocation(render_prog, "proj_matrix")
vs = shader_load("skybox.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("skybox.fs.glsl", GL_FRAGMENT_SHADER)
skybox_prog = glCreateProgram()
glAttachShader(skybox_prog, vs)
glAttachShader(skybox_prog, fs)
glLinkProgram(skybox_prog)
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.skybox.view_matrix = glGetUniformLocation(skybox_prog, "view_matrix")
def load_shaders():
global view_program
global uniforms
vs = shader_load("stereo-render.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("stereo-render.fs.glsl", GL_FRAGMENT_SHADER)
if (view_program):
glDeleteProgram(view_program)
view_program = glCreateProgram()
glAttachShader(view_program, vs)
glAttachShader(view_program, fs)
glLinkProgram(view_program)
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.view.proj_matrix = glGetUniformLocation(view_program,
"proj_matrix")
uniforms.view.mv_matrix = glGetUniformLocation(view_program, "mv_matrix")
uniforms.view.shadow_matrix = glGetUniformLocation(view_program,
"shadow_matrix")
uniforms.view.full_shading = glGetUniformLocation(view_program,
"full_shading")
uniforms.view.specular_albedo = glGetUniformLocation(
view_program, "specular_albedo")
uniforms.view.diffuse_albedo = glGetUniformLocation(
view_program, "diffuse_albedo")
def load_shaders():
global program
shaders = [GLuint(0) for _ in range(2)]
shaders[0] = shader_load("render.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("render.fs.glsl", GL_FRAGMENT_SHADER)
program = link_from_shaders(shaders, 2, True)
def load_shaders():
global program_naive
global program_adaptive
global program_exposure
global uniforms
if (program_naive):
glDeleteProgram(program_naive)
program_naive = glCreateProgram()
vs = shader_load("tonemap.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("tonemap_naive.fs.glsl", GL_FRAGMENT_SHADER)
glAttachShader(program_naive, vs)
glAttachShader(program_naive, fs)
glLinkProgram(program_naive)
glDeleteShader(fs)
fs = shader_load("tonemap_adaptive.fs.glsl", GL_FRAGMENT_SHADER)
if (program_adaptive):
glDeleteProgram(program_adaptive)
program_adaptive = glCreateProgram()
glAttachShader(program_adaptive, vs)
glAttachShader(program_adaptive, fs)
glLinkProgram(program_adaptive)
glDeleteShader(fs)
fs = shader_load("tonemap_exposure.fs.glsl", GL_FRAGMENT_SHADER)
if (program_exposure):
glDeleteProgram(program_exposure)
program_exposure = glCreateProgram()
glAttachShader(program_exposure, vs)
glAttachShader(program_exposure, fs)
glLinkProgram(program_exposure)
uniforms.exposure.exposure = glGetUniformLocation(program_exposure, "exposure")
glDeleteShader(vs)
glDeleteShader(fs)
def load_shaders():
global view_program
global display_program
global filter_program
shaders = [GLuint(0) for _ in range(4)]
shaders[0] = shader_load("render.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("render.fs.glsl", GL_FRAGMENT_SHADER)
if (view_program):
glDeleteProgram(view_program)
view_program = link_from_shaders(shaders, 2, True)
uniforms.view.proj_matrix = glGetUniformLocation(view_program,
"proj_matrix")
uniforms.view.mv_matrix = glGetUniformLocation(view_program, "mv_matrix")
uniforms.view.full_shading = glGetUniformLocation(view_program,
"full_shading")
uniforms.view.diffuse_albedo = glGetUniformLocation(
view_program, "diffuse_albedo")
shaders[0] = shader_load("display.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("display.fs.glsl", GL_FRAGMENT_SHADER)
if (display_program):
glDeleteProgram(display_program)
display_program = link_from_shaders(shaders, 2, True)
uniforms.dof.focal_distance = glGetUniformLocation(display_program,
"focal_distance")
uniforms.dof.focal_depth = glGetUniformLocation(display_program,
"focal_depth")
shaders[0] = shader_load("gensat.cs.glsl", GL_COMPUTE_SHADER)
if (filter_program):
glDeleteProgram(filter_program)
filter_program = link_from_shaders(shaders, 1, True)
def load_shaders():
global render_prog
global uniforms
if (render_prog):
glDeleteProgram(render_prog)
vs = shader_load("perpixelgloss.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("perpixelgloss.fs.glsl", GL_FRAGMENT_SHADER)
render_prog = glCreateProgram()
glAttachShader(render_prog, vs)
glAttachShader(render_prog, fs)
glLinkProgram(render_prog)
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.mv_matrix = glGetUniformLocation(render_prog, "mv_matrix")
uniforms.proj_matrix = glGetUniformLocation(render_prog, "proj_matrix")
def loadShaders():
global program
global uniforms
vs = shader_load("render.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("render.fs.glsl", GL_FRAGMENT_SHADER)
if (program != 0):
glDeleteProgram(program)
program = glCreateProgram()
glAttachShader(program, vs)
glAttachShader(program, fs)
glLinkProgram(program)
uniforms.mv_matrix = glGetUniformLocation(program, "mv_matrix")
uniforms.proj_matrix = glGetUniformLocation(program, "proj_matrix")
uniforms.rim_color = glGetUniformLocation(program, "rim_color")
uniforms.rim_power = glGetUniformLocation(program, "rim_power")
def load_shaders():
global render_program
global light_program
global render_program_nm
global vis_program
global loc_vis_mode
if (render_program):
glDeleteProgram(render_program)
if (light_program):
glDeleteProgram(light_program)
vs = shader_load("render.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("render.fs.glsl", GL_FRAGMENT_SHADER)
render_program = glCreateProgram()
glAttachShader(render_program, vs)
glAttachShader(render_program, fs)
glLinkProgram(render_program)
glDeleteShader(vs)
glDeleteShader(fs)
vs = shader_load("render-nm.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("render-nm.fs.glsl", GL_FRAGMENT_SHADER)
render_program_nm = glCreateProgram()
glAttachShader(render_program_nm, vs)
glAttachShader(render_program_nm, fs)
glLinkProgram(render_program_nm)
glDeleteShader(vs)
glDeleteShader(fs)
vs = shader_load("light.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("light.fs.glsl", GL_FRAGMENT_SHADER)
light_program = glCreateProgram()
glAttachShader(light_program, vs)
glAttachShader(light_program, fs)
glLinkProgram(light_program)
glDeleteShader(fs)
fs = shader_load("render-vis.fs.glsl", GL_FRAGMENT_SHADER)
vis_program = glCreateProgram()
glAttachShader(vis_program, vs)
glAttachShader(vis_program, fs)
glLinkProgram(vis_program)
loc_vis_mode = glGetUniformLocation(vis_program, "vis_mode")
glDeleteShader(vs)
glDeleteShader(fs)
def load_shaders():
global uniform
global tess_program
global draw_cp_program
if (tess_program):
glDeleteProgram(tess_program)
shaders = [GLuint(0) for _ in range(4)]
shaders[0] = shader_load("cubicbezier.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("cubicbezier.tcs.glsl", GL_TESS_CONTROL_SHADER)
shaders[2] = shader_load("cubicbezier.tes.glsl", GL_TESS_EVALUATION_SHADER)
shaders[3] = shader_load("cubicbezier.fs.glsl", GL_FRAGMENT_SHADER)
tess_program = link_from_shaders(shaders, 4, True)
uniform.patch.mv_matrix = glGetUniformLocation(tess_program, "mv_matrix")
uniform.patch.proj_matrix = glGetUniformLocation(tess_program, "proj_matrix")
uniform.patch.mvp = glGetUniformLocation(tess_program, "mvp")
if (draw_cp_program):
glDeleteProgram(draw_cp_program)
shaders[0] = shader_load("draw-control-points.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("draw-control-points.fs.glsl", GL_FRAGMENT_SHADER)
draw_cp_program = link_from_shaders(shaders, 2, True)
uniform.control_point.draw_color = glGetUniformLocation(draw_cp_program, "draw_color")
uniform.control_point.mvp = glGetUniformLocation(draw_cp_program, "mvp")
def load_shaders():
global light_program
global view_program
global show_light_depth_program
global uniforms
vs = shader_load("shadowmapping-light.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("shadowmapping-light.fs.glsl", GL_FRAGMENT_SHADER)
if (light_program):
glDeleteProgram(light_program)
light_program = glCreateProgram()
glAttachShader(light_program, vs)
glAttachShader(light_program, fs)
glLinkProgram(light_program)
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.light.mvp = glGetUniformLocation(light_program, "mvp")
vs = shader_load("shadowmapping-camera.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("shadowmapping-camera.fs.glsl", GL_FRAGMENT_SHADER)
if (light_program):
glDeleteProgram(view_program)
view_program = glCreateProgram()
glAttachShader(view_program, vs)
glAttachShader(view_program, fs)
glLinkProgram(view_program)
glDeleteShader(vs)
glDeleteShader(fs)
uniforms.view.proj_matrix = glGetUniformLocation(view_program,
"proj_matrix")
uniforms.view.mv_matrix = glGetUniformLocation(view_program, "mv_matrix")
uniforms.view.shadow_matrix = glGetUniformLocation(view_program,
"shadow_matrix")
uniforms.view.full_shading = glGetUniformLocation(view_program,
"full_shading")
if (show_light_depth_program):
glDeleteProgram(show_light_depth_program)
show_light_depth_program = glCreateProgram()
vs = shader_load("shadowmapping-light-view.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("shadowmapping-light-view.fs.glsl", GL_FRAGMENT_SHADER)
glAttachShader(show_light_depth_program, vs)
glAttachShader(show_light_depth_program, fs)
glLinkProgram(show_light_depth_program)
glDeleteShader(vs)
glDeleteShader(fs)
def load_shaders():
global per_fragment_program
global uniforms
vs = GLuint(0)
fs = GLuint(0)
vs = shader_load("blinnphong.vs.glsl", GL_VERTEX_SHADER)
fs = shader_load("blinnphong.fs.glsl", GL_FRAGMENT_SHADER)
if (per_fragment_program):
glDeleteProgram(per_fragment_program)
per_fragment_program = glCreateProgram()
glAttachShader(per_fragment_program, vs)
glAttachShader(per_fragment_program, fs)
glLinkProgram(per_fragment_program)
uniforms[0].diffuse_albedo = glGetUniformLocation(per_fragment_program,
"diffuse_albedo")
uniforms[0].specular_albedo = glGetUniformLocation(per_fragment_program,
"specular_albedo")
uniforms[0].specular_power = glGetUniformLocation(per_fragment_program,
"specular_power")
def load_shaders():
global prefix_sum_prog
global show_image_prog
cs = shader_load("prefixsum2d.cs.glsl", GL_COMPUTE_SHADER)
if (prefix_sum_prog):
glDeleteProgram(prefix_sum_prog)
prefix_sum_prog = link_from_shaders(cs, 1, True)
class show_image_shaders_:
vs = GLuint(0)
fs = GLuint(0)
show_image_shaders = show_image_shaders_()
show_image_shaders.vs = shader_load("showimage.vs.glsl", GL_VERTEX_SHADER)
show_image_shaders.fs = shader_load("showimage.fs.glsl",
GL_FRAGMENT_SHADER)
show_image_shaders_list = [show_image_shaders.vs, show_image_shaders.fs]
show_image_prog = link_from_shaders(show_image_shaders_list, 2, True)
def load_shaders():
global program_render
global program_filter
global program_resolve
global uniforms
shaders = [GLuint(0), GLuint(0)]
if (program_render):
glDeleteProgram(program_render)
shaders[0] = shader_load("hdrbloom-scene.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("hdrbloom-scene.fs.glsl", GL_FRAGMENT_SHADER)
program_render = link_from_shaders(shaders, 2, True)
uniforms.scene.bloom_thresh_min = glGetUniformLocation(
program_render, "bloom_thresh_min")
uniforms.scene.bloom_thresh_max = glGetUniformLocation(
program_render, "bloom_thresh_max")
if (program_filter):
glDeleteProgram(program_filter)
shaders[0] = shader_load("hdrbloom-filter.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("hdrbloom-filter.fs.glsl", GL_FRAGMENT_SHADER)
program_filter = link_from_shaders(shaders, 2, True)
if (program_resolve):
glDeleteProgram(program_resolve)
shaders[0] = shader_load("hdrbloom-resolve.vs.glsl", GL_VERTEX_SHADER)
shaders[1] = shader_load("hdrbloom-resolve.fs.glsl", GL_FRAGMENT_SHADER)
program_resolve = link_from_shaders(shaders, 2, True)
uniforms.resolve.exposure = glGetUniformLocation(program_resolve,
"exposure")
uniforms.resolve.bloom_factor = glGetUniformLocation(
program_resolve, "bloom_factor")
uniforms.resolve.scene_factor = glGetUniformLocation(
program_resolve, "scene_factor")
