def createShader(vSource, fSource): #Creo y compilo el vertex shader vProgram = ShaderManager.compileProgram(vSource, GL_VERTEX_SHADER) #Creo y compilo el fragment shader fProgram = ShaderManager.compileProgram(fSource, GL_FRAGMENT_SHADER) #Creo un programa de shading vacio en memoria de video shader = glCreateProgram() #Le adjunto el codigo objeto del vertex shader compilado glAttachShader(shader, vProgram) #Le adjunto el codigo objeto del fragment shader compilado glAttachShader(shader, fProgram) #Intento linkear el programa para generar un ejecutable en memoria de video glLinkProgram(shader) #Chequeo si la ejecucion del linkeo del programa fue exitosa if glGetProgramiv(shader, GL_LINK_STATUS) != GL_TRUE: #Si falla, imprimo el mensaje de error y libero los recursos print(glGetProgramInfoLog(shader)) glDeleteProgram(shader) return 0 #Una vez que el programa fue linkeado, haya sido exitoso o no, ya no necesito los shaders #individuales compilados, asi que libero sus recursos glDeleteShader(vProgram) glDeleteShader(fProgram) return shader
def __init__(self, archivo_vert, archivo_frag, nombre_vert="Vertex Shader", nombre_frag="Fragment Shader"): print("Shader creado") # Creación de shaders y programa self.vshader = glCreateShader(GL_VERTEX_SHADER) self.fshader = glCreateShader(GL_FRAGMENT_SHADER) self.programa = glCreateProgram() # Cargamos los datos de los archivos en los shaders self.cargar_datos(self.vshader, archivo_vert) self.cargar_datos(self.fshader, archivo_frag) # Compilamos los shaders resultado_vert = self.compilar(self.vshader, nombre_vert) resultado_frag = self.compilar(self.fshader, nombre_frag) # Error en la compilación if (resultado_vert != 1) or (resultado_frag != 1): self.destruir() # Sin errores hasta ahora else: # Enlazamos los shaders al programa glAttachShader(self.programa, self.vshader) glAttachShader(self.programa, self.fshader) # Enlazamos el programa glLinkProgram(self.programa) # Desenlazaos y eliminamos los shaders glDetachShader(self.programa, self.vshader) glDetachShader(self.programa, self.fshader) glDeleteShader(self.vshader) glDeleteShader(self.fshader) # Errores durante el enlace resultado_progr = glGetProgramiv(self.programa, GL_LINK_STATUS) if resultado_progr != 1: self.destruir()
def add_shader(self, source, shader_type): """ Helper function for compiling a GLSL shader Parameters ---------- source : str String containing shader source code shader_type : valid OpenGL shader type Type of shader to compile Returns ------- value : int Identifier for shader if compilation is successful """ try: shader_id = glCreateShader(shader_type) glShaderSource(shader_id, source) glCompileShader(shader_id) if glGetShaderiv(shader_id, GL_COMPILE_STATUS) != GL_TRUE: info = glGetShaderInfoLog(shader_id) raise RuntimeError('Shader compilation failed: %s' % (info)) return shader_id except: glDeleteShader(shader_id) raise
def destroy(self) -> None: self.stop() glDetachShader(self.__program_id, self.__vertex_shader_id) glDetachShader(self.__program_id, self.__fragment_shader_id) glDeleteShader(self.__vertex_shader_id) glDeleteShader(self.__fragment_shader_id) glDeleteProgram(self.__program_id)
def linkProgram(self): glLinkProgram(self.program_id) program_log = glGetProgramInfoLog(self.program_id) if program_log: raise RuntimeError("shader_program\n%s" % program_log) for shader in self._shaders: glDeleteShader(shader) self._shaders = []
def init_shader(self, vertex=None, fragment=None): if self.gls_pgr: glUseProgram(0) if self.gls_pgr.shader_id: glDeleteShader(self.gls_pgr.shader_id) if vertex is None: vertex = """ #version 330 attribute vec2 xy_pos; uniform vec4 xy_color; uniform vec4 xy_color1; varying vec4 frg_color; void main(void) { frg_color = xy_color; gl_Position = vec4(xy_pos,0, 1.0); } """ print vertex if fragment is None: fragment = """ #version 330 varying vec4 frg_color; void main(void) { gl_FragColor = frg_color; } """ print fragment self.gls_pgr = ShaderProgram(vertex,fragment) glUseProgram(self.gls_pgr.program_id) self.vertIndex = self.gls_pgr.attribute_location('xy_pos') #glVertexAttribPointer(self.gls_pgr.attribute_location('xy_pos'), 2, GL_FLOAT, GL_FALSE, 0, None) # Turn on this vertex attribute in the shader #glEnableVertexAttribArray(0) self.gls_id_xy_color = self.gls_pgr.uniform_location("xy_color") print self.gls_id_xy_color cid=glGetUniformLocation(self.gls_pgr.program_id,"xy_color1") print cid glUniform4fv(self.gls_id_xy_color,1, self.color)
def make_shader(shadertype, source): shader = glCreateShader(shadertype) glShaderSource(shader, source) glCompileShader(shader) retval = ctypes.c_uint(GL_UNSIGNED_INT) glGetShaderiv(shader, GL_COMPILE_STATUS, retval) if not retval: print >> sys.stderr, "Failed to compile shader." print glGetShaderInfoLog(shader) glDeleteShader(shader) raise Exception("Failed to compile shader.") return shader
def init_shader(self, vertex=None, fragment=None): if self.gls_pgr: glUseProgram(0) if self.gls_pgr.shader_id: glDeleteShader(self.gls_pgr.shader_id) if vertex is None: vertex = """ #version 330 attribute vec2 xy_pos; uniform vec4 xy_color; uniform vec4 xy_color1; varying vec4 frg_color; void main(void) { frg_color = xy_color; gl_Position = vec4(xy_pos,0, 1.0); } """ print vertex if fragment is None: fragment = """ #version 330 varying vec4 frg_color; void main(void) { gl_FragColor = frg_color; } """ print fragment self.gls_pgr = ShaderProgram(vertex, fragment) glUseProgram(self.gls_pgr.program_id) self.vertIndex = self.gls_pgr.attribute_location('xy_pos') #glVertexAttribPointer(self.gls_pgr.attribute_location('xy_pos'), 2, GL_FLOAT, GL_FALSE, 0, None) # Turn on this vertex attribute in the shader #glEnableVertexAttribArray(0) self.gls_id_xy_color = self.gls_pgr.uniform_location("xy_color") print self.gls_id_xy_color cid = glGetUniformLocation(self.gls_pgr.program_id, "xy_color1") print cid glUniform4fv(self.gls_id_xy_color, 1, self.color)
def getShader(self, shader_source, shader_type): try: shader_id = glCreateShader(shader_type) glShaderSource(shader_id, shader_source) glCompileShader(shader_id) if glGetShaderiv(shader_id, GL_COMPILE_STATUS) != GL_TRUE: info = glGetShaderInfoLog(shader_id) raise RuntimeError('Shader compilation failed:\n %s' % info) return shader_id except: glDeleteShader(shader_id) raise
def CreateShader(self, VertexShader, FragmentShader): program = glCreateProgram() vs = self.CompileShader(GL_VERTEX_SHADER, VertexShader) fs = self.CompileShader(GL_FRAGMENT_SHADER, FragmentShader) glAttachShader(program, vs) glAttachShader(program, fs) glLinkProgram(program) glValidateProgram(program) glDeleteShader(vs) glDeleteShader(fs) return program
def CompileShader(self, type, source): id = glCreateShader(type) glShaderSource(id, source) glCompileShader(id) result = glGetShaderiv(id, GL_COMPILE_STATUS) if (result==GL_FALSE): message = glGetShaderInfoLog(id).decode('utf-8') shadertype = "Vertex" if type==GL_VERTEX_SHADER else "Fragment" print(f"Failed to compile {shadertype} shader!") print(message) glDeleteShader(id) return 0 return id
def init_shaders(self,vtx=None,frg=None): self.program_id = glCreateProgram() if vtx: self.VTX.source = vtx self.VTX.fname = None #print self.VTX.source self.VTX.id = self.add_shader(self.VTX.source, GL_VERTEX_SHADER) if frg: self.FRG.source = frg self.FRG.fname = None self.FRG.id = self.add_shader(self.FRG.source, GL_FRAGMENT_SHADER) glAttachShader(self.program_id, self.VTX.id) glAttachShader(self.program_id, self.FRG.id) glLinkProgram(self.program_id) if glGetProgramiv(self.program_id, GL_LINK_STATUS) != GL_TRUE: info = glGetProgramInfoLog(self.program_id) glDeleteProgram(self.program_id) glDeleteShader(self.VTX.id) glDeleteShader(self.FRG.id) raise RuntimeError('Error linking program: %s' % (info)) glDeleteShader(self.VTX.id) glDeleteShader(self.FRG.id)
def initProgram(self): # create unique shader program id self.program_id = glCreateProgram() # load and compile individual shaders vertsource = self.loadShader(self.vertpath) fragsource = self.loadShader(self.fragpath) vert_id = self.getShader(vertsource, GL_VERTEX_SHADER) frag_id = self.getShader(fragsource, GL_FRAGMENT_SHADER) # if it's ok, attach them to shader program glAttachShader(self.program_id, vert_id) glAttachShader(self.program_id, frag_id) self.analyze( vertsource ) # in case of new (+#330 ;D) shaders - nothing will happen. # link program means make program obj with created executables for different programmable processors for shaders, # that were attached. glLinkProgram(self.program_id) # if something went wrong if glGetProgramiv(self.program_id, GL_LINK_STATUS) != GL_TRUE: info = glGetProgramInfoLog(self.program_id) glDeleteProgram(self.program_id) # they should be deleted anyway glDeleteShader(vert_id) glDeleteShader(frag_id) raise RuntimeError("Error in program linking: %s" % info) # shaders are attached, program is linked -> full shader program with compiled executables is ready, # no need in individual shaders ids, i suppose glDeleteShader(vert_id) glDeleteShader(frag_id)
def add_shader(self, source, shader_type): try: #print "TEST" #print source shader_id = glCreateShader(shader_type) glShaderSource(shader_id, source) glCompileShader(shader_id) if glGetShaderiv(shader_id, GL_COMPILE_STATUS) != GL_TRUE: info = glGetShaderInfoLog(shader_id) raise RuntimeError('Shader compilation failed: %s' % (info)) return shader_id except: glDeleteShader(shader_id) raise
def __init__(self, vertex, fragment): """ Parameters ---------- vertex : str String containing shader source code for the vertex shader fragment : str String containing shader source code for the fragment shader """ self.program_id = glCreateProgram() vs_id = self.add_shader(vertex, GL_VERTEX_SHADER) frag_id = self.add_shader(fragment, GL_FRAGMENT_SHADER) glAttachShader(self.program_id, vs_id) glAttachShader(self.program_id, frag_id) glLinkProgram(self.program_id) if glGetProgramiv(self.program_id, GL_LINK_STATUS) != GL_TRUE: info = glGetProgramInfoLog(self.program_id) glDeleteProgram(self.program_id) glDeleteShader(vs_id) glDeleteShader(frag_id) raise RuntimeError('Error linking program: %s' % (info)) glDeleteShader(vs_id) glDeleteShader(frag_id)
def _createShader(self, shadertype, source): try: shader = None shader = glCreateShader(shadertype) glShaderSource(shader, source) glCompileShader(shader) if glGetShaderiv(shader, GL_COMPILE_STATUS) != GL_TRUE: info = glGetShaderInfoLog(shader) raise Exception, "Unable to compile shader. Infolog:\n%s" % (info,) return shader except Exception: # Cleanup on exception if shader != None: glDeleteShader(shader) raise
def load_shader(shader_type, source): shader = glCreateShader(shader_type) if shader == 0: raise ShaderException() glShaderSource(shader, source) glCompileShader(shader) if glGetShaderiv(shader, GL_COMPILE_STATUS, None) == GL_FALSE: info_log = glGetShaderInfoLog(shader) glDeleteShader(shader) raise ShaderException(info_log) return shader
def __init__(self, shaderPaths=[]): self.shader_program = glCreateProgram() self.shader_objects = {} for (shader_type, path) in shaderPaths: self.shader_objects[shader_type] = self.loadAndCompileShaderObject( shader_type, path) glAttachShader(self.shader_program, self.shader_objects[shader_type]) glLinkProgram(self.shader_program) if glGetProgramiv(self.shader_program, GL_LINK_STATUS) != GL_TRUE: info = glGetProgramInfoLog(self.shader_program) glDeleteProgram(self.shader_program) for shader in self.shader_objects: glDeleteShader(shader) raise RuntimeError("Error in program linking: %s" % info)
def createProgram(self): vertexShader = self.createShader(self.vertexSource, GL_VERTEX_SHADER) fragmentShader = self.createShader(self.fragmentSource, GL_FRAGMENT_SHADER) program = glCreateProgram() glAttachShader(program, vertexShader) glAttachShader(program, fragmentShader) glLinkProgram(program) self.status[GL_LINK_STATUS] = glGetProgramiv(program, GL_LINK_STATUS) self.infoLog[GL_LINK_STATUS] = glGetProgramInfoLog(program) glDeleteShader(vertexShader) glDeleteShader(fragmentShader) return program
def _compile(self): logging.info('glShaderSource(%d, ...)', self._hnd) glShaderSource(self._hnd, self._source) logging.info('glCompileShader(%d)', self._hnd) glCompileShader(self._hnd) if not glGetShaderiv(self._hnd, GL_COMPILE_STATUS): logging.error('glCompileShader failed') compile_log = glGetShaderInfoLog(self._hnd).decode('utf-8') glDeleteShader(self._hnd) if self._path == '': print_source(self._source) pretty_print_log(compile_log, self._path) raise RuntimeError('shader failed to compile', compile_log)
def compileProgram(path, type): #Leo el codigo fuente desde el archivo sourceFile = open(path, "r") source = sourceFile.read() #Creo un shader vacio en memoria de video, del tipo indicado #En la variable shader queda almacenado un indice que nos va a permitir identificar este shader de ahora en mas shader = glCreateShader(type) #Le adjunto el codigo fuente leido desde el archivo glShaderSource(shader, source) #Intento compilarlo glCompileShader(shader) #Con la funcion glGelShaderiv puedo obtener el estado del compilador de shaders #En este caso le pido el stado de la ultima compilacion ejecutada if glGetShaderiv(shader, GL_COMPILE_STATUS) != GL_TRUE: #Si la compilacion falla, muestro el error y retorno 0 (shader nulo) print(path + ': ' + glGetShaderInfoLog(shader)) #Me aseguro de liberar los recursos que reserve en memoria de vide, ya que no los voy a usar glDeleteShader(shader) return 0 else: return shader
def __init__(self, vsource, fsource, gsource = None): self.uniformlocs = {} self.attributelocs = {} self.program = None try: shaders = [] shaders.append(self._createShader(GL_VERTEX_SHADER, vsource)) if gsource != None: shaders.append(self._createShader(GL_GEOMETRY_SHADER, gsource)) shaders.append(self._createShader(GL_FRAGMENT_SHADER, fsource)) self.program = self._createProgram(shaders) # Flag shader for deletion. except: if self.program != None: glDeleteProgram(self.program) raise finally: for shader in shaders: try: glDeleteShader(shader) except: pass
def __del__(self): if self.owned and self.valid(): glDeleteShader(self.sid)
def release(self, conn): if self._hnd is not None: conn.send_msg(lambda: glDeleteShader(self._hnd))
def dispose_shader(shader): if shader is not None: glDeleteShader(shader)
def destruir(self): """Elimina los shaders y el programa, y destruye referencias.""" glDeleteShader(self.fshader) glDeleteShader(self.vshader) glDeleteProgram(self.programa)