def __init__(self, *shaders: Shader):
self.name = gl.glCreateProgram()
for shader in shaders:
gl.glAttachShader(self.name, shader.name)
gl.glLinkProgram(self.name)
success = gl.GLint(0)
gl.glGetProgramiv(self.name, gl.GL_LINK_STATUS, byref(success))
if not success:
log_length = gl.GLint(0)
gl.glGetProgramiv(self.name, gl.GL_INFO_LOG_LENGTH,
byref(log_length))
log_buffer = create_string_buffer(log_length.value)
gl.glGetProgramInfoLog(self.name, log_length.value, None,
log_buffer)
self.logger.error("Error linking program %s, error # %d",
self.name, success.value)
self.logger.error("---Message---")
for line in log_buffer.value.decode("ascii").splitlines():
self.logger.error("Program: " + line)
self.logger.error("------")
raise RuntimeError("Linking program failed.")
# free resources
for shader in shaders:
gl.glDeleteShader(shader.name)
def setup_program():
'''
Create the glsl program
'''
vertex_shader = b'''
attribute vec2 position;
attribute vec4 color;
varying vec4 var_color;
void main()
{
gl_Position = vec4(position, 0.0, 1.0);
var_color = color;
}
'''
fragment_shader = b'''
varying vec4 var_color;
void main()
{
gl_FragColor = var_color;
}
'''
program = gl.glCreateProgram()
gl.glAttachShader(program, shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(program, shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
gl.glLinkProgram(program)
gl.glUseProgram(program)
return program
def setup_render_program():
'''
Create the glsl program for rendering the colored triangle
'''
vertex_shader = b'''
attribute vec2 position;
attribute vec4 color;
varying vec4 var_color;
void main()
{
gl_Position = vec4(position, 0.0, 1.0);
var_color = color;
}
'''
fragment_shader = b'''
varying vec4 var_color;
void main()
{
gl_FragColor = var_color;
}
'''
global render_program
render_program = gl.glCreateProgram()
gl.glAttachShader(render_program, compile_shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(render_program, compile_shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
link_program(render_program)
def setupShaders(self):
self.programA = gl.glCreateProgram()
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_VERTEX_SHADER,
self.vertex_source))
if args["operation"] == "similar":
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_FRAGMENT_SHADER,
self.fragment_source_a))
elif args["operation"] == "intersect":
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(
gl.GL_FRAGMENT_SHADER,
self.fragment_source_intersection))
elif args["operation"] == "union":
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_FRAGMENT_SHADER,
self.fragment_source_union))
elif args["operation"] == "difference":
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(
gl.GL_FRAGMENT_SHADER,
self.fragment_source_difference))
else:
print("not a valid operation")
pyglet_helper.link_program(self.programA)
def setup_copy_program():
'''
Create the glsl copy_program for copying the rendered texture
'''
vertex_shader = b'''
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 var_texcoord;
void main()
{
gl_Position = vec4(position, 0.0, 1.0);
var_texcoord = texcoord;
}
'''
fragment_shader = b'''
uniform sampler2D texture;
varying vec2 var_texcoord;
void main()
{
gl_FragColor = texture2D(texture, var_texcoord);
}
'''
global copy_program
copy_program = gl.glCreateProgram()
gl.glAttachShader(copy_program,
compile_shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(copy_program,
compile_shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
link_program(copy_program)
def setup_render_program():
'''
Create the glsl program for rendering the colored triangle
'''
vertex_shader = b'''
attribute vec2 position;
attribute vec4 color;
varying vec4 var_color;
void main()
{
gl_Position = vec4(position, 0.0, 1.0);
var_color = color;
}
'''
fragment_shader = b'''
varying vec4 var_color;
void main()
{
gl_FragColor = var_color;
}
'''
global render_program
render_program = gl.glCreateProgram()
gl.glAttachShader(render_program,
compile_shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(render_program,
compile_shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
link_program(render_program)
def __init__(self, vert='', frag='', geom='', lazy=False):
"""
GLSL Shader program object for rendering in OpenGL.
To activate, call the Shader.bind() method, or pass it to a context manager (the 'with' statement).
Examples and inspiration for shader programs can found at https://www.shadertoy.com/.
Args:
- vert (str): The vertex shader program string
- frag (str): The fragment shader program string
- geom (str): The geometry shader program
Example::
shader = Shader.from_file(vert='vertshader.vert', frag='fragshader.frag')
with shader:
mesh.draw()
"""
self.id = gl.glCreateProgram() # create the program handle
self.is_linked = False
self.is_compiled = False
self.vert = vert
self.frag = frag
self.geom = geom
self.lazy = lazy
if not self.lazy:
self.compile()
def setup_copy_program():
'''
Create the glsl copy_program for copying the rendered texture
'''
vertex_shader = b'''
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 var_texcoord;
void main()
{
gl_Position = vec4(position, 0.0, 1.0);
var_texcoord = texcoord;
}
'''
fragment_shader = b'''
uniform sampler2D texture;
varying vec2 var_texcoord;
void main()
{
gl_FragColor = texture2D(texture, var_texcoord);
}
'''
global copy_program
copy_program = gl.glCreateProgram()
gl.glAttachShader(copy_program, compile_shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(copy_program, compile_shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
link_program(copy_program)
def _create_device_objects(self):
# save state
last_texture = gl.GLint()
gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D, byref(last_texture))
last_array_buffer = gl.GLint()
gl.glGetIntegerv(gl.GL_ARRAY_BUFFER_BINDING, byref(last_array_buffer))
last_vertex_array = gl.GLint()
gl.glGetIntegerv(gl.GL_VERTEX_ARRAY_BINDING, byref(last_vertex_array))
self._shader_handle = gl.glCreateProgram()
# note: no need to store shader parts handles after linking
vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex_shader, 1, make_string_buffer(self.VERTEX_SHADER_SRC), None)
gl.glShaderSource(fragment_shader, 1, make_string_buffer(self.FRAGMENT_SHADER_SRC), None)
gl.glCompileShader(vertex_shader)
gl.glCompileShader(fragment_shader)
gl.glAttachShader(self._shader_handle, vertex_shader)
gl.glAttachShader(self._shader_handle, fragment_shader)
gl.glLinkProgram(self._shader_handle)
# note: after linking shaders can be removed
gl.glDeleteShader(vertex_shader)
gl.glDeleteShader(fragment_shader)
self._attrib_location_tex = gl.glGetUniformLocation(self._shader_handle, create_string_buffer(b"Texture"))
self._attrib_proj_mtx = gl.glGetUniformLocation(self._shader_handle, create_string_buffer(b"ProjMtx"))
self._attrib_location_position = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"Position"))
self._attrib_location_uv = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"UV"))
self._attrib_location_color = gl.glGetAttribLocation(self._shader_handle, create_string_buffer(b"Color"))
self._vbo_handle = gl.GLuint()
gl.glGenBuffers(1, byref(self._vbo_handle))
self._elements_handle = gl.GLuint()
gl.glGenBuffers(1, byref(self._elements_handle))
self._vao_handle = gl.GLuint()
gl.glGenVertexArrays(1, byref(self._vao_handle))
gl.glBindVertexArray(self._vao_handle)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._vbo_handle)
gl.glEnableVertexAttribArray(self._attrib_location_position)
gl.glEnableVertexAttribArray(self._attrib_location_uv)
gl.glEnableVertexAttribArray(self._attrib_location_color)
gl.glVertexAttribPointer(self._attrib_location_position, 2, gl.GL_FLOAT, gl.GL_FALSE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_POS_OFFSET))
gl.glVertexAttribPointer(self._attrib_location_uv, 2, gl.GL_FLOAT, gl.GL_FALSE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_UV_OFFSET))
gl.glVertexAttribPointer(self._attrib_location_color, 4, gl.GL_UNSIGNED_BYTE, gl.GL_TRUE, imgui.VERTEX_SIZE, c_void_p(imgui.VERTEX_BUFFER_COL_OFFSET))
# restore state
gl.glBindTexture(gl.GL_TEXTURE_2D, cast((c_int*1)(last_texture), POINTER(c_uint)).contents)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, cast((c_int*1)(last_array_buffer), POINTER(c_uint)).contents)
gl.glBindVertexArray(cast((c_int*1)(last_vertex_array), POINTER(c_uint)).contents)
def __init__(self, vert=[], frag=[]):
self.handle = gl.glCreateProgram()
self.linked = False
self.createShader(vert, gl.GL_VERTEX_SHADER)
self.createShader(frag, gl.GL_FRAGMENT_SHADER)
self.link()
def __init__(self, ec, fill_color, line_color, line_width, line_loop):
self._ec = ec
self._line_width = line_width
self._line_loop = line_loop # whether or not lines drawn are looped
# initialize program and shaders
from pyglet import gl
self._program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
buf = create_string_buffer(tri_vert.encode('ASCII'))
ptr = cast(pointer(pointer(buf)), POINTER(POINTER(c_char)))
gl.glShaderSource(vertex, 1, ptr, None)
gl.glCompileShader(vertex)
_check_log(vertex, gl.glGetShaderInfoLog)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
buf = create_string_buffer(tri_frag.encode('ASCII'))
ptr = cast(pointer(pointer(buf)), POINTER(POINTER(c_char)))
gl.glShaderSource(fragment, 1, ptr, None)
gl.glCompileShader(fragment)
_check_log(fragment, gl.glGetShaderInfoLog)
gl.glAttachShader(self._program, vertex)
gl.glAttachShader(self._program, fragment)
gl.glLinkProgram(self._program)
_check_log(self._program, gl.glGetProgramInfoLog)
gl.glDetachShader(self._program, vertex)
gl.glDetachShader(self._program, fragment)
gl.glUseProgram(self._program)
# Prepare buffers and bind attributes
loc = gl.glGetUniformLocation(self._program, b'u_view')
view = ec.window_size_pix
view = np.diag([2. / view[0], 2. / view[1], 1., 1.])
view[-1, :2] = -1
view = view.astype(np.float32).ravel()
gl.glUniformMatrix4fv(loc, 1, False, (c_float * 16)(*view))
self._counts = dict()
self._colors = dict()
self._buffers = dict()
self._points = dict()
self._tris = dict()
for kind in ('line', 'fill'):
self._counts[kind] = 0
self._colors[kind] = (0., 0., 0., 0.)
self._buffers[kind] = dict(array=gl.GLuint())
gl.glGenBuffers(1, pointer(self._buffers[kind]['array']))
self._buffers['fill']['index'] = gl.GLuint()
gl.glGenBuffers(1, pointer(self._buffers['fill']['index']))
gl.glUseProgram(0)
self.set_fill_color(fill_color)
self.set_line_color(line_color)
def __init__(self, ec, fill_color, line_color, line_width, line_loop):
self._ec = ec
self._line_width = line_width
self._line_loop = line_loop # whether or not lines drawn are looped
# initialize program and shaders
from pyglet import gl
self._program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
buf = create_string_buffer(tri_vert.encode('ASCII'))
ptr = cast(pointer(pointer(buf)), POINTER(POINTER(c_char)))
gl.glShaderSource(vertex, 1, ptr, None)
gl.glCompileShader(vertex)
_check_log(vertex, gl.glGetShaderInfoLog)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
buf = create_string_buffer(tri_frag.encode('ASCII'))
ptr = cast(pointer(pointer(buf)), POINTER(POINTER(c_char)))
gl.glShaderSource(fragment, 1, ptr, None)
gl.glCompileShader(fragment)
_check_log(fragment, gl.glGetShaderInfoLog)
gl.glAttachShader(self._program, vertex)
gl.glAttachShader(self._program, fragment)
gl.glLinkProgram(self._program)
_check_log(self._program, gl.glGetProgramInfoLog)
gl.glDetachShader(self._program, vertex)
gl.glDetachShader(self._program, fragment)
gl.glUseProgram(self._program)
# Prepare buffers and bind attributes
loc = gl.glGetUniformLocation(self._program, b'u_view')
view = ec.window_size_pix
view = np.diag([2. / view[0], 2. / view[1], 1., 1.])
view[-1, :2] = -1
view = view.astype(np.float32).ravel()
gl.glUniformMatrix4fv(loc, 1, False, (c_float * 16)(*view))
self._counts = dict()
self._colors = dict()
self._buffers = dict()
self._points = dict()
self._tris = dict()
for kind in ('line', 'fill'):
self._counts[kind] = 0
self._colors[kind] = (0., 0., 0., 0.)
self._buffers[kind] = dict(array=gl.GLuint())
gl.glGenBuffers(1, pointer(self._buffers[kind]['array']))
self._buffers['fill']['index'] = gl.GLuint()
gl.glGenBuffers(1, pointer(self._buffers['fill']['index']))
gl.glUseProgram(0)
self.set_fill_color(fill_color)
self.set_line_color(line_color)
def new_program(cls):
"""
Create a new program. The object own the ressources
"""
pobj = super().__new__(cls)
pobj.pid = c_uint(glCreateProgram())
pobj.uniforms = ShaderUniformAccessor(pobj)
pobj.attributes = ShaderAttributeAccessor(pobj)
pobj.owned = True
return pobj
def __init__(self, vert_files, frag_files):
"""
INPUTS:
- `vert_files`: a list of files that contain the vertex shader.
- `frag_files`: a list of files that contain the fragment shader.
"""
self.program = gl.glCreateProgram()
self.compile_and_attach_shader(vert_files, gl.GL_VERTEX_SHADER)
self.compile_and_attach_shader(frag_files, gl.GL_FRAGMENT_SHADER)
self.link()
def __init__(self, vertex_shader, fragment_shader):
self.handle = gl.glCreateProgram()
logging.debug('GLProgram.__init__: self.handle = %r', self.handle)
gl.glAttachShader(self.handle,
shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(self.handle,
shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
gl.glLinkProgram(self.handle)
#call use() early so some programm errors are caught early
self.use()
def __init__(self, vert_files, frag_files):
"""
Parameters
----------
:vert_files: a list of files that contain the vertex shader code.
:frag_files: a list of files that contain the fragment shader code
"""
self.program = gl.glCreateProgram()
self.compile_and_attach_shader(vert_files, gl.GL_VERTEX_SHADER)
self.compile_and_attach_shader(frag_files, gl.GL_FRAGMENT_SHADER)
self.link()
def __init__(self, vertex_source, fragment_source):
self.program = gl.glCreateProgram()
self.vertex_shader = self.create_shader(vertex_source,
gl.GL_VERTEX_SHADER)
self.fragment_shader = self.create_shader(fragment_source,
gl.GL_FRAGMENT_SHADER)
gl.glAttachShader(self.program, self.vertex_shader)
gl.glAttachShader(self.program, self.fragment_shader)
gl.glLinkProgram(self.program)
message = self.get_program_log(self.program)
if message:
raise ShaderException(message)
def __init__(self,
vertex_shader: Shader,
fragment_shader: Shader,
attributes=(),
uniforms=None):
"""
The process of creating a shader can be divided into 6 steps:
1. Create an ID.
2. Attach shaders.
3. Bind attributes.
4. Link program.
5. Validate program.
6. Bind uniforms.
Args:
vertex_shader:
fragment_shader:
attributes:
uniforms: A dictionary with the names of the uniform as the key, and the uniform (glsl value) as value.
"""
if uniforms is None:
uniforms = {}
handle = -1
attribute_location = {}
uniform_location = {}
try:
handle = glCreateProgram()
glAttachShader(handle, vertex_shader)
glAttachShader(handle, fragment_shader)
for index, name in enumerate(attributes):
glBindAttribLocation(handle, index, c_string(name))
attribute_location[name] = index
glLinkProgram(handle)
glValidateProgram(handle)
for uniform in uniforms:
uniform_location[uniform] = glGetUniformLocation(
handle, c_string(uniform))
except GLException:
debug_program(handle)
super(Program, self).__init__(handle)
self.vertex_shader = vertex_shader
self.fragment_shader = fragment_shader
self.attribute_location = attribute_location
self.uniform_location = uniform_location
self.uniforms = uniforms
if CHECK_ERROR:
debug_program(self)
def setupShaders(self):
self.programA = gl.glCreateProgram()
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_VERTEX_SHADER,
self.vertex_source))
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_FRAGMENT_SHADER,
self.fragment_source_a))
pyglet_helper.link_program(self.programA)
def __init__(self, vertex_source, fragment_source):
self.program = gl.glCreateProgram()
self.vertex_shader = self.create_shader(vertex_source,
gl.GL_VERTEX_SHADER)
self.fragment_shader = self.create_shader(fragment_source,
gl.GL_FRAGMENT_SHADER)
gl.glAttachShader(self.program, self.vertex_shader)
gl.glAttachShader(self.program, self.fragment_shader)
gl.glLinkProgram(self.program)
message = self.get_program_log(self.program)
if message:
raise ShaderException(message)
def compile(self):
self.id = gl.glCreateProgram()
for shader in self.shaders:
shader.compile()
gl.glAttachShader(self.id, shader.id)
gl.glLinkProgram(self.id)
message = self._get_message()
if not self.get_link_status():
raise LinkError(message)
return message
def compile(self):
self.id = gl.glCreateProgram()
for shader in self.shaders:
shader.compile()
gl.glAttachShader(self.id, shader.id)
gl.glLinkProgram(self.id)
message = self._get_message()
if not self.get_link_status():
raise LinkError(message)
return message
def __init__(self, vertex, fragment, version=None):
self._pid = gl.glCreateProgram()
self._vertex_source = preprocess_shader(vertex, 'vert', version)
self._fragment_source = preprocess_shader(fragment, 'frag', version)
self.compile_vertex_shader()
self.compile_fragment_shader()
gl.glAttachShader(self._pid, self._vid)
gl.glAttachShader(self._pid, self._fid)
gl.glLinkProgram(self._pid)
self._uniforms = {}
self._attributes = {}
def __init__(self, shaders):
try:
list.__init__(self, shaders)
except TypeError:
# In case only one shader was provided
list.__init__(self, [shaders])
self.handle = gl.glCreateProgram()
# not bound yet (i.e. not in rendering pipeline)
self.bound = False
# Variable types and descriptions
self._uniform_type_info = {}
self._link()
def __init__(self, source):
self.source = source
self.shader_no = gl.glCreateShader(self.shader_type)
if not self.shader_no:
raise Exception("could not create shader")
prog = (c_char_p * 1)(source + chr(0))
length = (c_int * 1)(0)
gl.glShaderSource(self.shader_no, 1,
cast(prog, POINTER(POINTER(c_char))),
cast(0, POINTER(c_int)))
gl.glCompileShader(self.shader_no)
self.program_no = gl.glCreateProgram()
if not self.program_no:
raise Exception("could not create program")
gl.glAttachShader(self.program_no, self.shader_no)
gl.glLinkProgram(self.program_no)
def compile(self):
if self.handle is not None:
glDeleteProgram(self.handle)
self.handle = glCreateProgram()
if len(self.vertex_shader_name) > 0:
with open(self.vertex_shader_name) as f:
vertex_source = f.readlines()
self.create_shader(vertex_source, GL_VERTEX_SHADER)
if len(self.fragment_shader_name) > 0:
with open(self.fragment_shader_name) as f:
fragment_source = f.readlines()
self.create_shader(fragment_source, GL_FRAGMENT_SHADER)
self.link()
def __init__(self, shaders=None, *, do_link=None, do_use=None):
if shaders is None:
shaders = []
if do_link is None:
do_link = True
if do_use is None:
do_use = False
super().__init__(gl.glCreateProgram())
self._shaders_empty = True
self._done_link = False
for shader in shaders:
self.add(shader)
if not self._shaders_empty and do_link:
self.link()
if self._done_link and do_use:
self.use()
def __init__(self, source):
self.source = source
self.shader_no = gl.glCreateShader(self.shader_type)
if not self.shader_no:
raise Exception("could not create shader")
prog = (c_char_p * 1)(source + chr(0))
length = (c_int * 1)(0)
gl.glShaderSource(self.shader_no, 1,
cast(prog, POINTER(POINTER(c_char))),
cast(0, POINTER(c_int)))
gl.glCompileShader(self.shader_no)
self.program_no = gl.glCreateProgram()
if not self.program_no:
raise Exception("could not create program")
gl.glAttachShader(self.program_no, self.shader_no)
gl.glLinkProgram(self.program_no)
def __init__(self, vert = [], frag = [], geom = []):
# create the program handle
self.handle = GL.glCreateProgram()
# we are not linked yet
self.linked = False
self.nErrors = 0
self.errStrs = []
# create the vertex shader
self.createShader(vert, GL.GL_VERTEX_SHADER)
# create the fragment shader
self.createShader(frag, GL.GL_FRAGMENT_SHADER)
# the geometry shader will be the same, once pyglet supports the extension
# self.createShader(frag, GL_GEOMETRY_SHADER_EXT)
# attempt to link the program
self.link()
def __init__(self, vert=[], frag=[], geom=[]):
# create the program handle
self.handle = GL.glCreateProgram()
# we are not linked yet
self.linked = False
self.nErrors = 0
self.errStrs = []
# create the vertex shader
self.createShader(vert, GL.GL_VERTEX_SHADER)
# create the fragment shader
self.createShader(frag, GL.GL_FRAGMENT_SHADER)
# the geometry shader will be the same, once pyglet supports the extension
# self.createShader(frag, GL_GEOMETRY_SHADER_EXT)
# attempt to link the program
self.link()
def setupShaders(self):
self.programA = gl.glCreateProgram()
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_VERTEX_SHADER,
self.vertex_source))
if args["shape"] == "sphere":
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(gl.GL_FRAGMENT_SHADER,
self.fragment_source_a))
elif args["shape"] == "cylinder":
gl.glAttachShader(
self.programA,
pyglet_helper.compile_shader(
gl.GL_FRAGMENT_SHADER, self.fragment_source_cylinder))
pyglet_helper.link_program(self.programA)
def __init__(self, *shaders: Shader):
self.prog_id = prog_id = gl.glCreateProgram()
shaders_id = []
for shader_code, shader_type in shaders:
shader = compile_shader(shader_code, shader_type)
gl.glAttachShader(self.prog_id, shader)
shaders_id.append(shader)
gl.glLinkProgram(self.prog_id)
for shader in shaders_id:
# Flag shaders for deletion. Will only be deleted once detached from program.
gl.glDeleteShader(shader)
self._uniforms: Dict[str, Uniform] = {}
self._introspect_uniforms()
weakref.finalize(self, Program._delete, shaders_id, prog_id)
def __init__(self, vert = None, frag = None, name=''):
''' vert, frag and geom take arrays of source strings
the arrays will be concatenated into one string by OpenGL.'''
self.uniforms = {}
self.name = name
# create the program handle
self.handle = gl.glCreateProgram()
# we are not linked yet
self.linked = False
# create the vertex shader
self._build_shader(vert, gl.GL_VERTEX_SHADER)
# create the fragment shader
self._build_shader(frag, gl.GL_FRAGMENT_SHADER)
# the geometry shader will be the same, once pyglet supports the
# extension self.createShader(frag, GL_GEOMETRY_SHADER_EXT) attempt to
# link the program
self._link()
def __init__(self, vert='', frag='', geom=''):
"""
GLSL Shader program object for rendering in OpenGL.
Args:
- vert (str): The vertex shader program string
- frag (str): The fragment shader program string
- geom (str): The geometry shader program
"""
self.id = gl.glCreateProgram() # create the program handle
# create the vertex, fragment, and geometry shaders
self.createShader(vert, gl.GL_VERTEX_SHADER)
self.createShader(frag, gl.GL_FRAGMENT_SHADER)
if geom:
self.createShader(geom, gl.GL_GEOMETRY_SHADER_EXT)
# attempt to link the program
self.link()
def __init__(self, vert='', frag='', geom=''):
"""
GLSL Shader program object for rendering in OpenGL.
Args:
- vert (str): The vertex shader program string
- frag (str): The fragment shader program string
- geom (str): The geometry shader program
"""
self.id = gl.glCreateProgram() # create the program handle
# create the vertex, fragment, and geometry shaders
self.createShader(vert, gl.GL_VERTEX_SHADER)
self.createShader(frag, gl.GL_FRAGMENT_SHADER)
if geom:
self.createShader(geom, gl.GL_GEOMETRY_SHADER_EXT)
# attempt to link the program
self.link()
def __init__(self, vert='', frag='', geom='', lazy=False):
"""
GLSL Shader program object for rendering in OpenGL.
Args:
- vert (str): The vertex shader program string
- frag (str): The fragment shader program string
- geom (str): The geometry shader program
"""
self.id = gl.glCreateProgram() # create the program handle
self.is_linked = False
self.is_compiled = False
self.vert = vert
self.frag = frag
self.geom = geom
self.lazy = lazy
if not self.lazy:
self.compile()
def __init__(self, vert=None, frag=None, geom=None):
vert = vert or []
frag = frag or []
geom = geom or []
# create the program handle
self.handle = glCreateProgram()
# we are not linked yet
self.linked = False
# create the vertex shader
self.create_shader(vert, GL_VERTEX_SHADER)
# create the fragment shader
self.create_shader(frag, GL_FRAGMENT_SHADER)
# the geometry shader will be the same, once pyglet supports the
# extension
# self.createShader(frag, GL_GEOMETRY_SHADER_EXT)
# attempt to link the program
self.link()
def __init__(self, vert_path, frag_path): self.program = gl.glCreateProgram() # create vertex shader self.vert_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) create_shader(self.vert_shader, vert_path) gl.glAttachShader(self.program, self.vert_shader) # create fragment shader self.frag_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) create_shader(self.frag_shader, frag_path) gl.glAttachShader(self.program, self.frag_shader) # link program and clean up gl.glLinkProgram(self.program) gl.glDeleteShader(self.vert_shader) gl.glDeleteShader(self.frag_shader)
def build_program(name):
"""build_program(name)
Loads and compiles the shaders and afterwards link them into a
program."""
# Compile the shaders
vs = load_shader(name, 'v')
fs = load_shader(name, 'f')
# Create and link the program
program = gl.glCreateProgram()
gl.glAttachShader(program, vs)
gl.glAttachShader(program, fs)
gl.glLinkProgram(program)
# If everything is ok -- return the program
check_program(program)
return program
def test_freeing(self):
" Test if programs are freed correctly "
prog = ShaderProgram.new_program()
vert, frag = self.get_objects()
prog.attach(vert, frag)
# Warning, borrowed_obj do not own the underlying shader so it will not be freed automatically
borrowed_prog = ShaderProgram(glCreateProgram(), owned=False)
pid = prog.pid
pid2 = borrowed_prog.pid
del prog
del borrowed_prog
gc.collect()
self.assertEqual(glIsProgram(pid), GL_FALSE, 'Program was not freed')
self.assertEqual(glIsProgram(pid2), GL_TRUE, 'Program was freed')
self.assertFalse(vert.valid(), 'vert was not freed')
self.assertFalse(frag.valid(), 'frag was not freed')
# Free the program object
glDeleteProgram(pid2)
def __init__(self, vertex_shader, fragment_shader, attributes):
# compile and link
self.program_name = gl.glCreateProgram()
gl.glAttachShader(self.program_name,
compile_shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(
self.program_name,
compile_shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
link_program(self.program_name)
# vertex type
class VERTEX(ctypes.Structure):
_fields_ = [(name, TYPE_NAME_TO_TYPE[tname] * size)
for (name, tname, size) in attributes]
self.VERTEX = VERTEX
# vertex array and buffer
self.vertex_array_name = gl.GLuint(0)
self.vertex_buffer_name = gl.GLuint(0)
gl.glGenVertexArrays(1, ctypes.byref(self.vertex_array_name))
gl.glGenBuffers(1, ctypes.byref(self.vertex_buffer_name))
gl.glBindVertexArray(self.vertex_array_name)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertex_buffer_name)
for (name, tname, size) in attributes:
location = gl.glGetAttribLocation(
self.program_name,
ctypes.create_string_buffer(name.encode('ascii')))
if location < 0:
warnings.warn('Attribute %r is not present.' % name,
stacklevel=2)
continue
gl.glEnableVertexAttribArray(location)
gl.glVertexAttribPointer(
location, size, tname, False, ctypes.sizeof(VERTEX),
ctypes.c_void_p(getattr(VERTEX, name).offset))
gl.glBindVertexArray(0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
def _compile_shader(vs_src, fs_src):
vs = gl.glCreateShader(gl.GL_VERTEX_SHADER)
vs_src_buf = c.create_string_buffer(vs_src)
c_vs_src = c.cast(c.pointer(vs_src_buf), c.POINTER(c.c_char))
i = c.c_int32(len(vs_src))
gl.glShaderSource(vs, 1, c_vs_src, c.byref(i))
gl.glCompileShader(vs)
fs = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
fs_src_buf = c.create_string_buffer(fs_src)
c_fs_src = c.cast(c.pointer(fs_src_buf), c.POINTER(c.c_char))
i = c.c_int32(len(fs_src))
gl.glShaderSource(fs, 1, c_fs_src, c.byref(i))
gl.glCompileShader(fs)
program = gl.glCreateProgram()
gl.glAttachShader(program, vs)
gl.glAttachShader(program, fs)
gl.glLinkProgram(program)
gl.glDeleteShader(vs)
gl.glDeleteShader(fs)
return program
def __init__(self):
self.__value = gl.glCreateProgram()
def __init__(self, vertex_shader, fragment_shader):
self.handle = gl.glCreateProgram()
gl.glAttachShader(self.handle, shader(gl.GL_VERTEX_SHADER, vertex_shader))
gl.glAttachShader(self.handle, shader(gl.GL_FRAGMENT_SHADER, fragment_shader))
gl.glLinkProgram(self.handle)
self.use() # early error
def program(*shaders):
p = gl.glCreateProgram()
for s in shaders:
gl.glAttachShader(p, s)
gl.glLinkProgram(p)
return check_shader_or_program_status(p)
def __init__(self):
self.program_no = gl.glCreateProgram()
_programs[self.program_no] = self
def __init__(self, vert_file, frag_file):
self.program = gl.glCreateProgram()
self.compile_and_attach_shader(vert_file, gl.GL_VERTEX_SHADER)
self.compile_and_attach_shader(frag_file, gl.GL_FRAGMENT_SHADER)
self.link()
