def create(self):
if not (self.status & Resource.LOADED):
return
vs = glCreateShader(GL_VERTEX_SHADER)
glShaderSource(vs, self.vs_str)
glCompileShader(vs)
if glGetShaderiv(vs, GL_COMPILE_STATUS) != GL_TRUE:
raise RuntimeError(glGetShaderInfoLog(vs))
fs = glCreateShader(GL_FRAGMENT_SHADER)
glShaderSource(fs, self.fs_str)
glCompileShader(fs)
if glGetShaderiv(fs, GL_COMPILE_STATUS) != GL_TRUE:
raise RuntimeError(glGetShaderInfoLog(fs))
program = glCreateProgram()
glAttachShader(program, vs)
glAttachShader(program, fs)
glLinkProgram(program)
if glGetProgramiv(program, GL_LINK_STATUS) != GL_TRUE:
raise RuntimeError(glGetProgramInfoLog(program))
glValidateProgram(program)
validation = glGetProgramiv(program, GL_VALIDATE_STATUS)
if validation == GL_FALSE:
raise RuntimeError(glGetProgramInfoLog(program))
# todo: check for errrors before setting status
self.program = program
self.status |= Resource.CREATED
def make_program(vertex_shader, fragment_shader):
program = glCreateProgram()
glAttachShader(program, vertex_shader)
glAttachShader(program, fragment_shader)
glLinkProgram(program)
retval = ctypes.c_int()
glGetProgramiv(program, GL_LINK_STATUS, retval)
if not retval:
print >> sys.stderr, "Failed to link shader program."
print glGetProgramInfoLog(program)
glDeleteProgram(program)
raise Exception("Failed to link shader program.")
return program
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 __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(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_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 __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 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 initialize_program(*shaders):
program = glCreateProgram()
for shader in shaders:
glAttachShader(program, shader)
glLinkProgram(program)
for shader in shaders:
dispose_shader(shader)
result = glGetProgramiv(program, GL_LINK_STATUS)
if result == 0:
raise RuntimeError(glGetProgramInfoLog(program))
return program
def load_program():
vertex_shader_source = read_file("shader02.vert")
vertex_shader = compileShader(vertex_shader_source, GL_VERTEX_SHADER)
program = compileProgram(vertex_shader)
print("program info log", glGetProgramInfoLog(program))
glUseProgram(program)
return program
def link(self):
self.__programId = glCreateProgram()
for shader in self.shaders:
shader.compile()
glAttachShader(self.__programId, shader.getId())
glLinkProgram(self.__programId)
for shader in self.shaders:
shader.delete()
self.shaders.clear()
if glGetProgramiv(self.__programId, GL_LINK_STATUS) != GL_TRUE:
info = glGetProgramInfoLog(self.__programId)
self.delete()
raise RuntimeError(f'Error in program linking: {info}')
def _createProgram(self, shaders):
prog = None
try:
prog = glCreateProgram()
for shader in shaders:
glAttachShader(prog, shader)
glLinkProgram(prog)
if glGetProgramiv(prog, GL_LINK_STATUS) != GL_TRUE:
info = glGetProgramInfoLog(prog)
raise Exception, "Unable to link program. Info log:\n%s" % (info)
return prog
except Exception:
if prog != None:
glDeleteProgram(prog)
raise
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_shader(vertex_shader_source, fragment_shader_source):
vertex_shader = load_shader(GL_VERTEX_SHADER, vertex_shader_source)
fragment_shader = load_shader(GL_FRAGMENT_SHADER, fragment_shader_source)
program = glCreateProgram()
if program == 0:
raise ShaderException()
glAttachShader(program, vertex_shader)
glAttachShader(program, fragment_shader)
glLinkProgram(program)
if glGetProgramiv(program, GL_LINK_STATUS, None) == GL_FALSE:
info_log = glGetProgramInfoLog(program)
glDeleteProgram(program)
raise ShaderException(info_log)
return program
def update(self, *shaders):
# TODO: for now this is actually create, not update
self._shaders += shaders
for shader in self._shaders:
glAttachShader(self._hnd, shader.hnd)
logging.info('glLinkProgram(%d)', self._hnd)
glLinkProgram(self._hnd)
logging.info('glGetProgramInfoLog(%d) -> %s', self._hnd,
glGetProgramInfoLog(self._hnd).decode().strip())
self._uniforms = {}
self._attributes = bidict()
for shader in self._shaders:
for name in shader.uniforms():
self._uniforms[name] = glGetUniformLocation(self._hnd, name)
for name, location in shader.attributes():
if location in self._attributes.inv:
raise KeyError('duplication attribute location', location,
name)
self._attributes[name] = location
def update(self, *shaders):
# TODO: for now this is actually create, not update
self._shaders += shaders
for shader in self._shaders:
glAttachShader(self._hnd, shader.hnd)
logging.info('glLinkProgram(%d)', self._hnd)
glLinkProgram(self._hnd)
logging.info('glGetProgramInfoLog(%d) -> %s', self._hnd,
glGetProgramInfoLog(self._hnd).decode().strip())
self._uniforms = {}
self._attributes = bidict()
for shader in self._shaders:
for name in shader.uniforms():
self._uniforms[name] = glGetUniformLocation(self._hnd, name)
for name, location in shader.attributes():
if location in self._attributes.inv:
raise KeyError('duplication attribute location', location,
name)
self._attributes[name] = location
