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 __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 _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 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 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, 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='', 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()