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 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 __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 _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)
def release(self, conn):
if self._hnd is not None:
conn.send_msg(lambda: glDeleteShader(self._hnd))
