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 __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 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 __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__(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_shader: Union[str, None] = None, fragment_shader: Union[str, None] = None,
geometry_shader: Union[str, None] = None, view_matrix_name: str = 'view_matrix',
projection_matrix_name: str = 'projection_matrix', model_matrix_name: str = 'model_matrix',
instanced_attribs=(), obj=None):
super().__init__('Material', obj)
self.__vertex_shader = vertex_shader
self.__fragment_shader = fragment_shader
self.__geometry_shader = geometry_shader
self.__attributes: Dict[str, int] = {}
self.__uniforms: Dict[str, int] = {}
self.view_matrix_name = view_matrix_name
self.projection_matrix_name = projection_matrix_name
self.model_matrix_name = model_matrix_name
self.__instanced_attribs = set(instanced_attribs)
self.__attributes_values: Union[Dict[str, np.ndarray]] = {}
self.__uniforms_values: Union[Dict[str, np.ndarray]] = {}
self.__attributes_types = {}
self.__uniforms_types = {}
if self.__vertex_shader and self.__fragment_shader:
program = compileProgram(
*[compileShader(shader, const) for shader, const in [(self.__vertex_shader, GL_VERTEX_SHADER),
(self.__fragment_shader, GL_FRAGMENT_SHADER),
(self.__geometry_shader, GL_GEOMETRY_SHADER)] if shader]
)
self.__program = program
num_active_attribs = glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES)
for u in range(num_active_attribs):
name, size, type_ = glGetActiveAttrib(program, u)
location = glGetAttribLocation(program, name)
name = name.decode("utf-8")
self.__attributes_types[name] = type_
self.__attributes[name] = location
self.__attributes_values[name] = np.array([])
num_active_uniforms = glGetProgramiv(program, GL_ACTIVE_UNIFORMS)
for u in range(num_active_uniforms):
name, size, type_ = glGetActiveUniform(program, u)
location = glGetUniformLocation(program, name)
name = name.decode("utf-8")
self.__uniforms_types[name] = type_
self.__uniforms[name] = location
self.__uniforms_values[name] = np.array([])
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 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 change_shader(self, vertex=None, fragment=None):
"""Change vertex and fragment shader of current program.
Needs indices of shaders from the list.
"""
changed = False
if vertex is not None:
changed |= self.__attach_shader(
self.__shaders[GL_VERTEX_SHADER][vertex], GL_VERTEX_SHADER)
if fragment is not None:
changed |= self.__attach_shader(
self.__shaders[GL_FRAGMENT_SHADER][fragment],
GL_FRAGMENT_SHADER)
if not changed:
return
glLinkProgram(self.__program)
assert glGetProgramiv(self.__program, GL_LINK_STATUS) == GL_TRUE
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 change_shader(self, vertex=None, fragment=None):
"""Change vertex and fragment shader of current program.
Needs indices of shaders from the list.
"""
changed = False
if vertex is not None:
changed |= self.__attach_shader(
self.__shaders[GL_VERTEX_SHADER][vertex], GL_VERTEX_SHADER)
if fragment is not None:
changed |= self.__attach_shader(
self.__shaders[GL_FRAGMENT_SHADER][fragment],
GL_FRAGMENT_SHADER)
if not changed:
return
glLinkProgram(self.__program)
assert glGetProgramiv(self.__program, GL_LINK_STATUS) == GL_TRUE
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 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 __init__(self, vertex, fragment, number_of_buffers=0,
number_of_textures=0):
"""Initialize program with shaders."""
self.__program = glCreateProgram()
self.__current_shaders = {}
self.__shaders = {
GL_VERTEX_SHADER: [],
GL_FRAGMENT_SHADER: []
}
self.__depth_map_fbo = None
self.__attributes = []
self.__initiate_shaders(vertex, fragment)
self.change_shader(0, 0)
glLinkProgram(self.__program)
assert glGetProgramiv(self.__program, GL_LINK_STATUS) == GL_TRUE
self.__initiate_buffers(number_of_buffers)
self.__initiate_textures(number_of_textures)
def __init__(self,
vertex,
fragment,
number_of_buffers=0,
number_of_textures=0):
"""Initialize program with shaders."""
self.__program = glCreateProgram()
self.__current_shaders = {}
self.__shaders = {GL_VERTEX_SHADER: [], GL_FRAGMENT_SHADER: []}
self.__depth_map_fbo = None
self.__attributes = []
if not isinstance(vertex, list):
vertex = [vertex]
for v in vertex:
self.__load_shader(get_shader_path(v), GL_VERTEX_SHADER)
if not isinstance(fragment, list):
fragment = [fragment]
for f in fragment:
self.__load_shader(get_shader_path(f), GL_FRAGMENT_SHADER)
self.change_shader(0, 0)
glLinkProgram(self.__program)
assert glGetProgramiv(self.__program, GL_LINK_STATUS) == GL_TRUE
self.__vao_id = glGenVertexArrays(1)
glBindVertexArray(self.__vao_id)
if number_of_buffers == 1:
self.__vbo_id = [glGenBuffers(number_of_buffers)]
elif number_of_buffers > 1:
self.__vbo_id = glGenBuffers(number_of_buffers)
if number_of_textures == 1:
self.__textures_ids = [glGenTextures(1)]
elif number_of_textures > 1:
self.__textures_ids = glGenTextures(number_of_textures)
self.__textures = []
def __get__(self, instance, cls):
glGetProgramiv(instance.pid, self.pname, byref(self.buffer))
return self.buffer.value
