def _link(self, shader, *shaderkeys):
prog = gl.glCreateProgram()
for name in shaderkeys:
gl.glAttachShader(prog, shader[name])
if 'geometry' in shaderkeys:
extgs4.glProgramParameteriEXT(
prog, extgs4.GL_GEOMETRY_INPUT_TYPE_EXT,
gl.GL_LINES_ADJACENCY)
extgs4.glProgramParameteriEXT(
prog, extgs4.GL_GEOMETRY_OUTPUT_TYPE_EXT,
gl.GL_LINE_STRIP)
extgs4.glProgramParameteriEXT(
prog, extgs4.GL_GEOMETRY_VERTICES_OUT_EXT,
200)
gl.glLinkProgram(prog)
log.info(
'linked program %s: %s',
shaderkeys,
gl.glGetProgramInfoLog(prog) or 'success')
return prog
def setup(self, shader_sources):
"""Setup shaders."""
if not shader_sources:
return
shader_ids = {}
for shader_type, source in shader_sources.items():
shader = GL.glCreateShader(shader_type)
GL.glShaderSource(shader, source)
GL.glCompileShader(shader)
if GL.glGetShaderiv(shader, GL.GL_COMPILE_STATUS) != GL.GL_TRUE:
raise RuntimeError(GL.glGetShaderInfoLog(shader).decode())
shader_ids[shader_type] = shader
self.shader_sources = shader_sources
self.shader_ids = shader_ids
self.program_id = GL.glCreateProgram()
for shader in shader_ids.values():
GL.glAttachShader(self.program_id, shader)
GL.glLinkProgram(self.program_id)
if GL.glGetProgramiv(self.program_id, GL.GL_LINK_STATUS) != GL.GL_TRUE:
raise RuntimeError(GL.glGetProgramInfoLog(self.program_id).decode())
GL.glUseProgram(self.program_id)
def init(self):
shaders = {
gl.GL_VERTEX_SHADER: self._vertSource,
gl.GL_FRAGMENT_SHADER: self._fragSource
}
self.program_id = gl.glCreateProgram()
shader_ids = []
for shader_type, shader_src in shaders.items():
shader_id = gl.glCreateShader(shader_type)
gl.glShaderSource(shader_id, shader_src)
gl.glCompileShader(shader_id)
# check if compilation was successful
result = gl.glGetShaderiv(shader_id, gl.GL_COMPILE_STATUS)
info_log_len = gl.glGetShaderiv(shader_id, gl.GL_INFO_LOG_LENGTH)
if info_log_len:
logmsg = gl.glGetShaderInfoLog(shader_id)
print("ERROR: ", logmsg)
sys.exit(10)
gl.glAttachShader(self.program_id, shader_id)
shader_ids.append(shader_id)
gl.glLinkProgram(self.program_id)
# check if linking was successful
result = gl.glGetProgramiv(self.program_id, gl.GL_LINK_STATUS)
info_log_len = gl.glGetProgramiv(self.program_id,
gl.GL_INFO_LOG_LENGTH)
if info_log_len:
logmsg = gl.glGetProgramInfoLog(self.program_id)
logging.error(logmsg)
sys.exit(11)
def init_gl(self, force=False):
if force:
Program._current = None
if self.program_id is not None:
if not force: return
vs = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vs, self.vs_src)
gl.glCompileShader(vs)
if not gl.glGetShaderiv(vs, gl.GL_COMPILE_STATUS):
raise Exception('failed to compile vertex shader:\n%s' %
gl.glGetShaderInfoLog(vs).decode())
fs = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fs, self.fs_src)
gl.glCompileShader(fs)
if not gl.glGetShaderiv(fs, gl.GL_COMPILE_STATUS):
raise Exception('failed to compile fragment shader:\n%s' %
gl.glGetShaderInfoLog(fs).decode())
program_id = gl.glCreateProgram()
gl.glAttachShader(program_id, vs)
gl.glAttachShader(program_id, fs)
gl.glLinkProgram(program_id)
if not gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS):
raise Exception('failed to link program')
gl.glDetachShader(program_id, vs)
gl.glDetachShader(program_id, fs)
self.program_id = program_id
_logger.info('%s.init_gl: OK', self.__class__.__name__)
def program(*shaders):
p = GL.glCreateProgram()
for s in shaders:
GL.glAttachShader(p, s)
GL.glBindFragDataLocation(p, 0, 'color')
GL.glLinkProgram(p)
return check_shader_or_program_status(p)
def _create_programs(programs_data):
"""Create the OpenGL programs."""
programs = {}
for program_data in programs_data:
program = gl.glCreateProgram()
shaders = []
shaders_data = program_data['shaders']
for shader_data in shaders_data:
shader = _create_shader_from_file(shader_data['filepath'],
shader_data['type'])
gl.glAttachShader(program, shader)
shaders.append(shader)
gl.glLinkProgram(program)
if gl.glGetProgramiv(program, gl.GL_LINK_STATUS) != gl.GL_TRUE:
raise RuntimeError(gl.glGetProgramInfoLog(program).decode())
for shader in shaders:
gl.glDeleteShader(shader)
program_name = program_data['name']
programs[program_name] = program
struct = collections.namedtuple('_Programs', programs.keys())
return struct(**programs)
def _build_shader(self, strings, stype):
''' Actual building of the shader '''
count = len(strings)
# if we have no source code, ignore this shader
if count < 1:
return
# create the shader handle
shader = gl.glCreateShader(stype)
# Upload shader code
gl.glShaderSource(shader, strings)
# compile the shader
gl.glCompileShader(shader)
# retrieve the compile status
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
# if compilation failed, print the log
if not status:
# display the log
print gl.glGetShaderInfoLog(shader)
else:
# all is well, so attach the shader to the program
gl.glAttachShader(self.handle, shader)
def __init__(self, vertex, fragment):
'''
:vertex String containing shader source code for the vertex shader
:fragment String containing shader source code for the fragment shader
'''
if False:
# method 1
self.program_id = GL.glCreateProgram()
vs_id = self.add_shader(vertex, GL.GL_VERTEX_SHADER)
frag_id = self.add_shader(fragment, GL.GL_FRAGMENT_SHADER)
GL.glAttachShader(self.program_id, vs_id)
GL.glAttachShader(self.program_id, frag_id)
GL.glLinkProgram(self.program_id)
if GL.glGetProgramiv(self.program_id,
GL.GL_LINK_STATUS) != GL.GL_TRUE:
info = GL.glGetProgramInfoLog(self.program_id)
GL.glDeleteProgram(self.program_id)
GL.glDeleteShader(vs_id)
GL.glDeleteShader(frag_id)
raise RuntimeError('Error linking program: %s' % (info))
GL.glDeleteShader(vs_id)
GL.glDeleteShader(frag_id)
else:
# method 2
vertex_shader = shaders.compileShader(vertex, GL.GL_VERTEX_SHADER)
fragment_shader = shaders.compileShader(fragment,
GL.GL_FRAGMENT_SHADER)
self.program_id = shaders.compileProgram(vertex_shader,
fragment_shader)
def loadShaderProgram(self):
# Request a program and shader slots from GPU
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
# Set shaders source
gl.glShaderSource(vertex, self.vertex_code)
gl.glShaderSource(fragment, self.fragment_code)
# Compile shaders
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
print 'Vertex shader'
print gl.glGetShaderInfoLog(vertex)
print 'Fragment shader'
print gl.glGetShaderInfoLog(fragment)
# Attach shader objects to the program
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
# Build program
gl.glLinkProgram(program)
# Get rid of shaders (no more needed)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
return program
def load_shaders():
shaders = {
gl.GL_VERTEX_SHADER: '''\
#version 330 core
layout(location = 0) in vec3 vertexPosition_modelspace;
uniform mat4 MVP;
void main() {
gl_Position = MVP * vec4(vertexPosition_modelspace, 1);
}
''',
gl.GL_FRAGMENT_SHADER: '''\
#version 330 core
out vec3 color;
void main() {
color = vec3(1,0,0);
}
'''}
log.debug('creating the shader program')
program_id = gl.glCreateProgram()
shader_ids = []
try:
for shader_type, shader_src in shaders.items():
shader_id = gl.glCreateShader(shader_type)
gl.glShaderSource(shader_id, shader_src)
log.debug(f'compiling the {shader_type} shader')
gl.glCompileShader(shader_id)
# check if compilation was successful
result = gl.glGetShaderiv(shader_id, gl.GL_COMPILE_STATUS)
nlog = gl.glGetShaderiv(shader_id, gl.GL_INFO_LOG_LENGTH)
if nlog:
log_msg = gl.glGetShaderInfoLog(shader_id)
log.error(log_msg)
sys.exit(10)
gl.glAttachShader(program_id, shader_id)
shader_ids.append(shader_id)
log.debug('linking shader program')
gl.glLinkProgram(program_id)
# check if linking was successful
result = gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS)
nlog = gl.glGetProgramiv(program_id, gl.GL_INFO_LOG_LENGTH)
if nlog:
log_msg = gl.glGetProgramInfoLog(program_id)
log.error(log_msg)
sys.exit(11)
log.debug('installing shader program into rendering state')
gl.glUseProgram(program_id)
yield program_id
finally:
log.debug('cleaning up shader program')
for shader_id in shader_ids:
gl.glDetachShader(program_id, shader_id)
gl.glDeleteShader(shader_id)
gl.glUseProgram(0)
gl.glDeleteProgram(program_id)
def getProgramForShadow() -> int:
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
with open("glsl\\shadow_vs.glsl") as file:
gl.glShaderSource(vertexShader, file.read())
gl.glCompileShader(vertexShader)
log_s = gl.glGetShaderInfoLog(vertexShader)
if log_s:
raise TypeError(log_s)
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
with open("glsl\\shadow_fs.glsl") as file:
gl.glShaderSource(fragmentShader, file.read())
gl.glCompileShader(fragmentShader)
log_s = gl.glGetShaderInfoLog(fragmentShader)
if log_s:
raise TypeError(log_s)
program = gl.glCreateProgram()
gl.glAttachShader(program, vertexShader)
gl.glAttachShader(program, fragmentShader)
gl.glLinkProgram(program)
print("Linking Log in Shadow:", gl.glGetProgramiv(program, gl.GL_LINK_STATUS))
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
gl.glUseProgram(program)
return program
def getProgram() -> int:
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
with open("glsl\\renderer_vs.glsl") as file:
gl.glShaderSource(vertexShader, file.read())
gl.glCompileShader(vertexShader)
log_s = gl.glGetShaderInfoLog(vertexShader)
if log_s:
raise TypeError(log_s)
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
with open("glsl\\renderer_fs.glsl") as file:
gl.glShaderSource(fragmentShader, file.read())
gl.glCompileShader(fragmentShader)
log_s = gl.glGetShaderInfoLog(fragmentShader)
if log_s:
raise TypeError(log_s)
program = gl.glCreateProgram()
gl.glAttachShader(program, vertexShader)
gl.glAttachShader(program, fragmentShader)
gl.glLinkProgram(program)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
gl.glUseProgram(program)
return int( program )
def _build_shader(self, strings, shader_type):
''' Actual building of the shader '''
count = len(strings)
# if we have no source code, ignore this shader
if count < 1:
return
# create the shader handle
shader = gl.glCreateShader(shader_type)
# Upload shader code
gl.glShaderSource(shader, strings)
# compile the shader
gl.glCompileShader(shader)
# retrieve the compile status
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
# if compilation failed, raise exception and print the log
if not status:
if shader_type == gl.GL_VERTEX_SHADER:
raise ShaderException, \
'Vertex compilation: ' + gl.glGetShaderInfoLog(shader)
elif shader_type == gl.GL_FRAGMENT_SHADER:
raise ShaderException, \
'Fragment compilation:' + gl.glGetShaderInfoLog(shader)
else:
raise ShaderException, \
gl.glGetShaderInfoLog(shader)
else:
# all is well, so attach the shader to the program
gl.glAttachShader(self.handle, shader)
def _build_shader(self, strings, shader_type):
count = len(strings)
if count < 1:
return
shader = gl.glCreateShader(shader_type)
gl.glShaderSource(shader, strings)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
error = gl.glGetShaderInfoLog(shader)
if shader_type == gl.GL_VERTEX_SHADER:
err_line, err_desc = parse_shader_error(error)
print_shader_error(err_desc, err_line, self.vertex_code)
sys.exit()
raise (ShaderException, 'Vertex compilation error')
elif shader_type == gl.GL_FRAGMENT_SHADER:
print error
sys.exit()
raise (ShaderException, 'Fragment compilation error')
else:
print error
sys.exit()
raise (ShaderException)
else:
gl.glAttachShader(self.handle, shader)
def _compile_shaders(self, shaders):
for shader_type, shader_src in shaders.items():
shader_id = gl.glCreateShader(shader_type)
gl.glShaderSource(shader_id, shader_src)
gl.glCompileShader(shader_id)
# check if compilation was successful
gl.glGetShaderiv(shader_id, gl.GL_COMPILE_STATUS)
info_log_len = gl.glGetShaderiv(shader_id, gl.GL_INFO_LOG_LENGTH)
if info_log_len:
logmsg = gl.glGetShaderInfoLog(shader_id)
print(logmsg)
sys.exit(10)
gl.glAttachShader(self.program_id, shader_id)
self.shader_ids.append(shader_id)
gl.glLinkProgram(self.program_id)
# check if linking was successful
gl.glGetProgramiv(self.program_id, gl.GL_LINK_STATUS)
info_log_len = gl.glGetProgramiv(self.program_id,
gl.GL_INFO_LOG_LENGTH)
if info_log_len:
logmsg = gl.glGetProgramInfoLog(self.program_id)
print(logmsg)
sys.exit(11)
def setup_programs(gltf, shader_ids):
"""
Creates and links OpenGL programs for the input gltf dict, given the mapping
from GLTF shader to OpenGL handle of the compiled vertex / fragment shaders.
"""
for program_name, program in gltf['programs'].items():
program_id = gl.glCreateProgram()
gl.glAttachShader(program_id, shader_ids[program['vertexShader']])
gl.glAttachShader(program_id, shader_ids[program['fragmentShader']])
gl.glLinkProgram(program_id)
gl.glDetachShader(program_id, shader_ids[program['vertexShader']])
gl.glDetachShader(program_id, shader_ids[program['fragmentShader']])
if not gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS):
raise Exception('failed to link program "%s"' % program_name)
program['id'] = program_id
program['attribute_locations'] = {
attribute_name: gl.glGetAttribLocation(program_id, attribute_name)
for attribute_name in program['attributes']
}
if 'uniforms' in program:
program['uniform_locations'] = {
uniform_name: gl.glGetUniformLocation(program_id, uniform_name)
for uniform_name in program['uniforms']
}
else:
program['uniform_locations'] = {}
_logger.debug(
'linked program "%s"\n attribute locations: %s\n uniform locations: %s',
program_name, program['attribute_locations'],
program['uniform_locations'])
def initialize_program(vertex_shader_code, fragment_shader_code):
# compile shaders and store references
vertex_shader_ref = OpenGLUtils.initialize_shader(
vertex_shader_code, GL.GL_VERTEX_SHADER)
fragment_shader_ref = OpenGLUtils.initialize_shader(
fragment_shader_code, GL.GL_FRAGMENT_SHADER)
# create empty program object
program_ref = GL.glCreateProgram()
# attach previously compiled shaders
GL.glAttachShader(program_ref, vertex_shader_ref)
GL.glAttachShader(program_ref, fragment_shader_ref)
# link the shaders together
GL.glLinkProgram(program_ref)
# query if linking was successful
link_sucess = GL.glGetProgramiv(program_ref, GL.GL_LINK_STATUS)
if not link_sucess:
# retrieve error message
error_message = GL.glGetProgramInfoLog(program_ref)
# free memory
GL.glDeleteProgram(program_ref)
# convert byte string to char string
error_message = "\n" + error_message.decode("utf-8")
# raise error
raise Exception(error_message)
return program_ref
def _getProgram() -> int:
with open("shader_source\\2nd_vs_box.glsl") as file:
vertexShader = shaders.compileShader(file.read(),
gl.GL_VERTEX_SHADER)
log = glf.get_shader_log(vertexShader)
if log:
raise TypeError(log)
with open("shader_source\\2nd_fs_box.glsl") as file:
fragmentShader = shaders.compileShader(file.read(),
gl.GL_FRAGMENT_SHADER)
log = glf.get_shader_log(fragmentShader)
if log:
raise TypeError(log)
program = gl.glCreateProgram()
gl.glAttachShader(program, vertexShader)
gl.glAttachShader(program, fragmentShader)
gl.glLinkProgram(program)
print("Linking Log in Box:",
gl.glGetProgramiv(program, gl.GL_LINK_STATUS))
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
gl.glUseProgram(program)
return program
def setup(self, shader_sources):
"""Setup shaders."""
if not shader_sources:
return
shader_ids = {}
for shader_type, source in shader_sources.items():
shader = GL.glCreateShader(shader_type)
GL.glShaderSource(shader, source)
GL.glCompileShader(shader)
if GL.glGetShaderiv(shader, GL.GL_COMPILE_STATUS) != GL.GL_TRUE:
raise RuntimeError(GL.glGetShaderInfoLog(shader).decode())
shader_ids[shader_type] = shader
self.shader_sources = shader_sources
self.shader_ids = shader_ids
self.program_id = GL.glCreateProgram()
for shader in shader_ids.values():
GL.glAttachShader(self.program_id, shader)
GL.glLinkProgram(self.program_id)
if GL.glGetProgramiv(self.program_id, GL.GL_LINK_STATUS) != GL.GL_TRUE:
raise RuntimeError(
GL.glGetProgramInfoLog(self.program_id).decode())
#GL.glUseProgram(self.program_id)
return
def initShaders(self):
# build vertex shader object
self.vertexShader = GL.glCreateShader(GL.GL_VERTEX_SHADER)
GL.glShaderSource(self.vertexShader, texture_phong_vsrc)
GL.glCompileShader(self.vertexShader)
result = GL.glGetShaderiv(self.vertexShader, GL.GL_COMPILE_STATUS)
if result != 1:
print(GL.glGetShaderInfoLog(self.vertexShader))
raise Exception("Error compiling vertex shader")
# build fragment shader object
self.fragmentShader = GL.glCreateShader(GL.GL_FRAGMENT_SHADER)
GL.glShaderSource(self.fragmentShader, texture_phong_fsrc)
GL.glCompileShader(self.fragmentShader)
result = GL.glGetShaderiv(self.fragmentShader, GL.GL_COMPILE_STATUS)
if result != 1:
print(GL.glGetShaderInfoLog(self.fragmentShader))
raise Exception("Error compiling fragment shader")
# build shader program and attach shader objects
self.shaderProgram = GL.glCreateProgram()
GL.glAttachShader(self.shaderProgram, self.vertexShader)
GL.glAttachShader(self.shaderProgram, self.fragmentShader)
GL.glLinkProgram(self.shaderProgram)
def _build_shader(self, strings, shader_type):
count = len(strings)
if count < 1:
return
shader = gl.glCreateShader(shader_type)
gl.glShaderSource(shader, strings)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
error = gl.glGetShaderInfoLog(shader)
if shader_type == gl.GL_VERTEX_SHADER:
err_line, err_desc = parse_shader_error(error)
print_shader_error(err_desc, err_line, self.vertex_code)
sys.exit()
raise (ShaderException, 'Vertex compilation error')
elif shader_type == gl.GL_FRAGMENT_SHADER:
print error
sys.exit()
raise (ShaderException, 'Fragment compilation error')
else:
print error
sys.exit()
raise (ShaderException)
else:
gl.glAttachShader(self.handle, shader)
def init_gl(self, force=False):
if force:
Program._current = None
if self.program_id is not None:
if not force: return
vs = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vs, self.vs_src)
gl.glCompileShader(vs)
if not gl.glGetShaderiv(vs, gl.GL_COMPILE_STATUS):
raise Exception('failed to compile vertex shader:\n%s' % gl.glGetShaderInfoLog(vs).decode())
fs = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fs, self.fs_src)
gl.glCompileShader(fs)
if not gl.glGetShaderiv(fs, gl.GL_COMPILE_STATUS):
raise Exception('failed to compile fragment shader:\n%s' % gl.glGetShaderInfoLog(fs).decode())
program_id = gl.glCreateProgram()
gl.glAttachShader(program_id, vs)
gl.glAttachShader(program_id, fs)
gl.glLinkProgram(program_id)
if not gl.glGetProgramiv(program_id, gl.GL_LINK_STATUS):
raise Exception('failed to link program')
gl.glDetachShader(program_id, vs)
gl.glDetachShader(program_id, fs)
self.program_id = program_id
_logger.info('%s.init_gl: OK', self.__class__.__name__)
def initialise(self):
def compileShader(handle, shader_source):
gl.glShaderSource(handle, shader_source)
gl.glCompileShader(handle)
if not gl.glGetShaderiv(handle, gl.GL_COMPILE_STATUS):
print(gl.glGetShaderInfoLog(handle))
self.program = gl.glCreateProgram()
vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
compileShader(vertex_shader, self.vertex_str())
compileShader(fragment_shader, self.fragment_str())
gl.glAttachShader(self.program, vertex_shader)
gl.glAttachShader(self.program, fragment_shader)
gl.glLinkProgram(self.program)
if not gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS):
print(gl.glGetProgramInfoLog(self.program))
gl.glDetachShader(self.program, vertex_shader)
gl.glDetachShader(self.program, fragment_shader)
# Request a buffer slot from GPU
self.buffer = gl.glGenBuffers(1)
self.VAO = gl.glGenVertexArrays(1)
def _build_shader(self, strings, shader_type):
''' Actual building of the shader '''
count = len(strings)
# if we have no source code, ignore this shader
if count < 1:
return
# create the shader handle
shader = gl.glCreateShader(shader_type)
# Upload shader code
gl.glShaderSource(shader, strings)
# compile the shader
gl.glCompileShader(shader)
# retrieve the compile status
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
# if compilation failed, raise exception and print the log
if not status:
if shader_type == gl.GL_VERTEX_SHADER:
raise ShaderException, \
'Vertex compilation: ' + gl.glGetShaderInfoLog(shader)
elif shader_type == gl.GL_FRAGMENT_SHADER:
raise ShaderException, \
'Fragment compilation:' + gl.glGetShaderInfoLog(shader)
else:
raise ShaderException, \
gl.glGetShaderInfoLog(shader)
else:
# all is well, so attach the shader to the program
gl.glAttachShader(self.handle, shader)
def LoadShaders(vertex_file_path, fragment_file_path):
vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
with open(vertex_file_path, "r") as f:
vertex_shader_code = f.read()
with open(fragment_file_path, "r") as f:
fragment_shader_code = f.read()
gl.glShaderSource(vertex_shader, vertex_shader_code)
gl.glCompileShader(vertex_shader)
result = gl.glGetShaderiv(vertex_shader, gl.GL_COMPILE_STATUS)
info_log = gl.glGetShaderInfoLog(vertex_shader)
print result, info_log
gl.glShaderSource(fragment_shader, fragment_shader_code)
gl.glCompileShader(fragment_shader)
result = gl.glGetShaderiv(fragment_shader, gl.GL_COMPILE_STATUS)
info_log = gl.glGetShaderInfoLog(fragment_shader)
print result, info_log
program = gl.glCreateProgram()
gl.glAttachShader(program, vertex_shader)
gl.glAttachShader(program, fragment_shader)
gl.glLinkProgram(program)
result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
info_log = gl.glGetProgramInfoLog(program)
print result, info_log
gl.glDeleteShader(vertex_shader)
gl.glDeleteShader(fragment_shader)
return program
def link(self):
"""Initialize the program for use."""
program = gl.glCreateProgram()
# compile all the shaders
for name, code in self.SHADER_TYPES.items():
source = getattr(self, name)()
if source is not None:
shader = gl.glCreateShader(code)
gl.glShaderSource(shader, source)
gl.glCompileShader(shader)
success = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if success != gl.GL_TRUE:
raise RuntimeError(gl.glGetShaderInfoLog(shader))
gl.glAttachShader(program, shader)
# link them into a program
gl.glLinkProgram(program)
success = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
if success != gl.GL_TRUE:
raise RuntimeError(gl.glGetProgramInfoLog(program))
self.program = program
# initialize everything else as needed
self.initialize_uniforms()
self.initialize()
def getProgram(vertexShaderDir_s:str, fragmentShaderDir_s:str) -> int:
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
with open(vertexShaderDir_s) as file:
gl.glShaderSource(vertexShader, file.read())
gl.glCompileShader(vertexShader)
log_s = gl.glGetShaderInfoLog(vertexShader)
if log_s:
raise CompileErrorGLSL(log_s)
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
with open(fragmentShaderDir_s) as file:
gl.glShaderSource(fragmentShader, file.read())
gl.glCompileShader(fragmentShader)
log_s = gl.glGetShaderInfoLog(fragmentShader)
if log_s:
raise CompileErrorGLSL(log_s)
program = gl.glCreateProgram()
gl.glAttachShader(program, vertexShader)
gl.glAttachShader(program, fragmentShader)
gl.glLinkProgram(program)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
gl.glUseProgram(program)
return int(program)
def __init__(
self,
shaders,
vertex_attributes=None,
uniform_blocks=None,
xfb_varyings=None,
xfb_mode=GL.GL_INTERLEAVED_ATTRIBS,
):
self.handle = GL.glCreateProgram()
if self.handle == 0:
raise RuntimeError("Failed to create OpenGL program.")
for shader in shaders:
GL.glAttachShader(self.handle, shader.handle)
self.xfb_varyings = xfb_varyings
if xfb_varyings is not None:
varyings = (c.c_char_p * len(xfb_varyings))(*(v.name.encode() for v in self.xfb_varyings))
varyings = c.cast(varyings, c.POINTER(c.POINTER(c.c_char)))
GL.glTransformFeedbackVaryings(self.handle, len(xfb_varyings), varyings, xfb_mode)
self._xfb_mode = xfb_mode
GL.glLinkProgram(self.handle)
if GL.glGetProgramiv(self.handle, GL.GL_LINK_STATUS) == GL.GL_FALSE:
log = GL.glGetProgramInfoLog(self.handle).decode()
GL.glDeleteProgram(self.handle)
raise RuntimeError("Failed to link program: \n\n{}".format(log))
self.uniform_blocks = {ub.name: ProgramUniformBlock.fromUniformBlock(self, ub) for ub in uniform_blocks or []}
self.vertex_attributes = {
v.name: ProgramVertexAttribute.fromVertexAttribute(self, v) for v in vertex_attributes or []
}
def shader(vs_src, frag_src):
# build and compile shader program
# vertex shader
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertexShader, vs_src)
gl.glCompileShader(vertexShader)
if not gl.glGetShaderiv(vertexShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(vertexShader).decode()
raise Exception("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" +
infoLog)
# fragment shader
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragmentShader, frag_src)
gl.glCompileShader(fragmentShader)
if not gl.glGetShaderiv(fragmentShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(fragmentShader).decode()
raise Exception("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" +
infoLog)
# link shaders
shaderProgram = gl.glCreateProgram()
gl.glAttachShader(shaderProgram, vertexShader)
gl.glAttachShader(shaderProgram, fragmentShader)
gl.glLinkProgram(shaderProgram)
if not gl.glGetProgramiv(shaderProgram, gl.GL_LINK_STATUS):
infoLog = gl.glGetProgramInfoLog(shaderProgram).decode()
raise Exception("ERROR::SHADER::PROGRAM::LINKING_FAILED\n" + infoLog)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
return shaderProgram
def AddStage(self, stage: int, filepath: str) -> None:
if self.__compiled:
Debug.Log("Tried to add shader stage to already compiled shader.",
LogLevel.Warning)
return
try:
with open(filepath, "r") as f:
source = f.read()
except FileNotFoundError as e:
raise SpykeException(
f"Cannot find shader file named '{e.filename}'")
shader = GL.glCreateShader(stage)
self.__stages.append(shader)
GL.glShaderSource(shader, source)
GL.glCompileShader(shader)
infoLog = GL.glGetShaderInfoLog(shader)
if len(infoLog) != 0:
raise GraphicsException(
f"Shader (file: '{filepath}') compilation error:\n{EnsureString(infoLog)}."
)
GL.glAttachShader(self._id, shader)
def loadShaders(strVS, strFS):
"""load vertex and fragment shaders from strings"""
# compile vertex shader
shaderV = compileShader([strVS], gl.GL_VERTEX_SHADER)
# compiler fragment shader
shaderF = compileShader([strFS], gl.GL_FRAGMENT_SHADER)
# create the program object
program = gl.glCreateProgram()
if not program:
raise RunTimeError('glCreateProgram faled!')
# attach shaders
gl.glAttachShader(program, shaderV)
gl.glAttachShader(program, shaderF)
# Link the program
gl.glLinkProgram(program)
# Check the link status
linked = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
if not linked:
infoLen = gl.glGetProgramiv(program, gl.GL_INFO_LOG_LENGTH)
infoLog = ""
if infoLen > 1:
infoLog = gl.glGetProgramInfoLog(program, infoLen, None);
gl.glDeleteProgram(program)
raise RunTimeError("Error linking program:\n%s\n", infoLog);
return program
def on_initialize(self):
gl.glClearColor(1,1,1,1)
gl.glEnable(gl.GL_DEPTH_TEST)
# Create shader program
self._prog_handle = gl.glCreateProgram()
# Create vertex shader
shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(shader, VERT_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Vertex shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Create fragment shader
shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(shader, FRAG_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Fragment shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Link
gl.glLinkProgram(self._prog_handle)
status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Program did not link.')
# Create texture
im = io.cat()
self._tex_handle = gl.glGenTextures(1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB,
im.shape[1], im.shape[0], 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
if use_buffers:
# Create vertex buffer
self._positions_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._positions_handle)
gl.glBufferData(gl.GL_ARRAY_BUFFER, positions.nbytes, positions, gl.GL_DYNAMIC_DRAW)
#
self._texcoords_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._texcoords_handle)
gl.glBufferData(gl.GL_ARRAY_BUFFER, texcoords.nbytes, texcoords, gl.GL_DYNAMIC_DRAW)
# Create buffer for faces
self._faces_handle = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, self._faces_handle)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, faces.nbytes, faces, gl.GL_DYNAMIC_DRAW)
def getProgram() -> int:
with open("shader_source\\2nd_vs.txt") as file:
vertexShader = shaders.compileShader(file.read(), gl.GL_VERTEX_SHADER)
log_s = gl.glGetShaderInfoLog(vertexShader).decode()
if log_s:
raise TypeError(log_s)
with open("shader_source\\2nd_fs.txt") as file:
fragmentShader = shaders.compileShader(file.read(), gl.GL_FRAGMENT_SHADER)
log_s = gl.glGetShaderInfoLog(fragmentShader).decode()
if log_s:
raise TypeError(log_s)
program = gl.glCreateProgram()
gl.glAttachShader(program, vertexShader)
gl.glAttachShader(program, fragmentShader)
gl.glLinkProgram(program)
print("Linking Log:", gl.glGetProgramiv(program, gl.GL_LINK_STATUS))
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
gl.glUseProgram(program)
return program
def create(cls, *shaders):
with contextlib.ExitStack() as ctx_mgr:
# Create the shader program
obj = int(gl.glCreateProgram())
if obj == 0:
raise OpenGLError("Failed to create a shader program.")
ctx_mgr.callback(cls._delete_program, obj)
# Attach the shaders
for shader in shaders:
gl.glAttachShader(obj, shader.obj)
# Link the shader program
gl.glLinkProgram(obj)
# Detach the shaders
for shader in shaders:
gl.glDetachShader(obj, shader.obj)
# Determine the link status
if not gl.glGetProgramiv(obj, gl.GL_LINK_STATUS):
log_string = gl.glGetProgramInfoLog(obj)
raise OpenGLError(log_string.decode("utf-8"))
log = logging.getLogger("{}.{}".format(__name__, cls.__name__))
ctx_exit = ctx_mgr.pop_all()
return cls(obj, log, ctx_exit)
def initialise(self):
def compileShader(handle, shader_source):
gl.glShaderSource(handle, shader_source)
gl.glCompileShader(handle)
if not gl.glGetShaderiv(handle, gl.GL_COMPILE_STATUS):
print(gl.glGetShaderInfoLog(handle))
self.program = gl.glCreateProgram()
vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
compileShader(vertex_shader, self.vertex_str())
compileShader(fragment_shader, self.fragment_str())
gl.glAttachShader(self.program, vertex_shader)
gl.glAttachShader(self.program, fragment_shader)
gl.glLinkProgram(self.program)
if not gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS):
print(gl.glGetProgramInfoLog(self.program))
gl.glDetachShader(self.program, vertex_shader)
gl.glDetachShader(self.program, fragment_shader)
# Request a buffer slot from GPU
self.buffer = gl.glGenBuffers(1)
self.VAO = gl.glGenVertexArrays(1)
def load_shaders(vertex_file_path, fragment_file_path):
vertex_shader_id = GL.glCreateShader(GL.GL_VERTEX_SHADER)
fragment_shader_id = GL.glCreateShader(GL.GL_FRAGMENT_SHADER)
vertex_shader_file = open(vertex_file_path, 'r')
vertex_shader_code = vertex_shader_file.read()
vertex_shader_file.close()
fragment_shader_file = open(fragment_file_path, 'r')
fragment_shader_code = fragment_shader_file.read()
fragment_shader_file.close()
GL.glShaderSource(vertex_shader_id, vertex_shader_code)
GL.glCompileShader(vertex_shader_id)
if not GL.glGetShaderiv(vertex_shader_id, GL.GL_COMPILE_STATUS):
raise Exception('failed to compile shader "{0}":\n'
'{1}'.format(vertex_shader_id, GL.glGetShaderInfoLog(vertex_shader_id).decode()))
GL.glShaderSource(fragment_shader_id, fragment_shader_code)
GL.glCompileShader(fragment_shader_id)
if not GL.glGetShaderiv(fragment_shader_id, GL.GL_COMPILE_STATUS):
raise Exception('failed to compile shader "{0}":\n'
'{1}'.format(fragment_shader_id, GL.glGetShaderInfoLog(fragment_shader_id).decode()))
program_id = GL.glCreateProgram()
GL.glAttachShader(program_id, vertex_shader_id)
GL.glAttachShader(program_id, fragment_shader_id)
GL.glLinkProgram(program_id)
if not GL.glGetProgramiv(program_id, GL.GL_LINK_STATUS):
raise Exception('failed to link program:\n{}'.format(GL.glGetProgramInfoLog(program_id).decode()))
GL.glDeleteShader(vertex_shader_id)
GL.glDeleteShader(fragment_shader_id)
return program_id
def compile(cls, vertex_source, fragment_source):
self = cls()
self._vars = {}
self._attrs = []
self._locs = {}
self._vertices = []
self._shader = shaders.ShaderProgram(G.glCreateProgram())
vertex_shader = Shader.compile_shader(
vertex_source, G.GL_VERTEX_SHADER)
fragment_shader = Shader.compile_shader(
fragment_source, G.GL_FRAGMENT_SHADER)
G.glAttachShader(self._shader, vertex_shader)
G.glAttachShader(self._shader, fragment_shader)
all_source = '%s\n%s' % (vertex_source, fragment_source)
for line in all_source.splitlines():
o = DECL.match(line.strip())
if o is not None:
v = ShaderVar(o.group('name'), o.group('qual'),
TYPES[o.group('type')])
self._vars[v.name] = v
if v.qual == 'attribute':
self._attrs.append(v)
self.init_attribute_locs()
G.glLinkProgram(self._shader)
self._shader.check_validate()
self._shader.check_linked()
G.glDeleteShader(vertex_shader)
G.glDeleteShader(fragment_shader)
self.init_uniform_locs()
return self
def __init__(self, vertexShaderStr, fragmentShaderStr):
## Constructor
# Compile and attach the shaders.
# @param self
# @param vertexShaderStr String either containing the filepath to the shader
# @param fragmentShaderStr String either containing the filepath to the shader
# Compile the shaders
vertShader = self._compileShader(vertexShaderStr, GL.GL_VERTEX_SHADER)
fragShader = self._compileShader(fragmentShaderStr,
GL.GL_FRAGMENT_SHADER)
# Attach
self.glId = GL.glCreateProgram()
GL.glAttachShader(self.glId, vertShader)
GL.glAttachShader(self.glId, fragShader)
# Link
GL.glLinkProgram(self.glId)
# Release
GL.glDeleteShader(vertShader)
GL.glDeleteShader(fragShader)
# Check
status = GL.glGetProgramiv(self.glId, GL.GL_LINK_STATUS)
if not status:
log = GL.glGetProgramInfoLog(self.glId).decode('ascii')
GL.glDeleteProgram(self.glId)
self.glId = None
strError = "Shader - Shader program initialization failed : \n" + str(
log)
raise Exception(strError)
def build_program(vertex_code, fragment_code):
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glCompileShader(vertex)
gl.glAttachShader(program, vertex)
fragment = None
if fragment_code is not None:
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(fragment)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
success = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
if success == gl.GL_FALSE:
log = glGetProgramInfoLog(program)
print "Linking failed!\nLog:\n'" + log + "'"
raise
gl.glDetachShader(program, vertex)
if fragment is not None:
gl.glDetachShader(program, fragment)
return program
def __init__(self, vertex_code, fragment_code):
super().__init__(gl.glCreateProgram())
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
if not gl.glGetShaderiv(vertex, gl.GL_COMPILE_STATUS):
error = gl.glGetShaderInfoLog(vertex).decode()
print(error)
raise RuntimeError('Vertex shader compilation error')
gl.glCompileShader(fragment)
if not gl.glGetShaderiv(fragment, gl.GL_COMPILE_STATUS):
error = gl.glGetShaderInfoLog(fragment).decode()
print(error)
raise RuntimeError('Fragment shader compilation error')
# Link individual shaders to create a shader program.
gl.glAttachShader(self._handle, vertex)
gl.glAttachShader(self._handle, fragment)
gl.glLinkProgram(self._handle)
if not gl.glGetProgramiv(self._handle, gl.GL_LINK_STATUS):
print(gl.glGetProgramInfoLog(self._handle))
raise RuntimeError('Linking error')
# Free shader source and unlinked object code.
gl.glDetachShader(self._handle, vertex)
gl.glDetachShader(self._handle, fragment)
gl.glDeleteShader(vertex)
gl.glDeleteShader(fragment)
def _get_shader(path, file, shader_type, program):
"""
Create the shader and link shader source code
:param path: Shader code path
:param file: Shader code file
:param shader_type: GL_VERTEX_SHADER or GL_FRAGMENT_SHADER
:return: glShader
"""
with open(abspath(join(path, file)), mode='r') as f:
shader_code = f.read()
if not shader_code:
raise ValueError
shader = gl.glCreateShader(shader_type)
info(gl.glGetError())
# Link
gl.glShaderSource(shader, shader_code)
info(gl.glGetError())
# Compile
gl.glCompileShader(shader)
info(gl.glGetError())
# Attach
gl.glAttachShader(program, shader)
info(gl.glGetError())
return shader
def _build_shader(self, strings, stype):
''' Actual building of the shader '''
count = len(strings)
# if we have no source code, ignore this shader
if count < 1:
return
# create the shader handle
shader = gl.glCreateShader(stype)
# Upload shader code
gl.glShaderSource(shader, strings)
# compile the shader
gl.glCompileShader(shader)
# retrieve the compile status
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
# if compilation failed, print the log
if not status:
# display the log
print (gl.glGetShaderInfoLog(shader))
else:
# all is well, so attach the shader to the program
gl.glAttachShader(self.handle, shader)
def initShader(self, vertex_shader_source_list,
fragment_shader_source_list):
# create program
self.program = gl.glCreateProgram() # pylint: disable=E1111
#print('create program ',self.program)
printOpenGLError()
# vertex shader
#print('compile vertex shader...')
self.vs = gl.glCreateShader(gl.GL_VERTEX_SHADER) # pylint: disable=E1111
gl.glShaderSource(self.vs, vertex_shader_source_list)
gl.glCompileShader(self.vs)
if (gl.GL_TRUE != gl.glGetShaderiv(self.vs, gl.GL_COMPILE_STATUS)):
err = gl.glGetShaderInfoLog(self.vs)
raise Exception(err)
gl.glAttachShader(self.program, self.vs)
printOpenGLError()
# fragment shader
#print('compile fragment shader...')
self.fs = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) # pylint: disable=E1111
gl.glShaderSource(self.fs, fragment_shader_source_list)
gl.glCompileShader(self.fs)
if (gl.GL_TRUE != gl.glGetShaderiv(self.fs, gl.GL_COMPILE_STATUS)):
err = gl.glGetShaderInfoLog(self.fs)
raise Exception(err)
gl.glAttachShader(self.program, self.fs)
printOpenGLError()
#print('link...')
gl.glLinkProgram(self.program)
if (gl.GL_TRUE != gl.glGetProgramiv(self.program, gl.GL_LINK_STATUS)):
err = gl.glGetShaderInfoLog(self.vs)
raise Exception(err)
printOpenGLError()
def createShaderGL():
global program
# create program
program = GL.glCreateProgram()
#print('create program')
printOpenGLError()
# vertex shader
#print('compile vertex shader...')
vs = GL.glCreateShader(GL.GL_VERTEX_SHADER)
GL.glShaderSource(vs, [_vertex_shader_source])
GL.glCompileShader(vs)
GL.glAttachShader(program, vs)
printOpenGLError()
# fragment shader
#print('compile fragment shader...')
fs = GL.glCreateShader(GL.GL_FRAGMENT_SHADER)
GL.glShaderSource(fs, [_fragment_shader_source])
GL.glCompileShader(fs)
GL.glAttachShader(program, fs)
printOpenGLError()
#print('link...')
GL.glLinkProgram(program)
printOpenGLError()
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(WIN_WIDTH, WIN_HEIGHT, "Hello OpenGL", None,
None)
if window == 0:
print("failed to create window")
glfw.glfwTerminate()
glfw.make_context_current(window)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertexShader, vertexShaderSource)
gl.glCompileShader(vertexShader)
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragmentShader, fragmentShaderSource)
gl.glCompileShader(fragmentShader)
shaderProgram = gl.glCreateProgram()
gl.glAttachShader(shaderProgram, vertexShader)
gl.glAttachShader(shaderProgram, fragmentShader)
gl.glLinkProgram(shaderProgram)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
VAO = gl.glGenVertexArrays(1)
VBO = gl.glGenBuffers(1)
gl.glBindVertexArray(VAO)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, VBO)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sys.getsizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(gl.glGetAttribLocation(shaderProgram, 'aPos'), 3,
gl.GL_FLOAT, gl.GL_FALSE, 12, None)
gl.glEnableVertexAttribArray(0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindVertexArray(0)
while not glfw.window_should_close(window):
processInput(window)
gl.glClearColor(0.2, 0.3, 0.3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glUseProgram(shaderProgram)
gl.glBindVertexArray(VAO)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
gl.glBindVertexArray(0)
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def __init__(self, geos, vertex_code, fragment_code):
self.time = time.time()
num_vertices = np.sum([len(g) for g in geos])
data = np.zeros(num_vertices, [("position", np.float32, 2),
("color", np.float32, 4)])
cs = []
vs = []
for g in geos:
for c in g.colors:
cs.append(c)
for v in g.vertices:
vs.append(v)
data["color"] = cs
data["position"] = vs
data["position"] = 0.5 * data["position"]
self.data = data
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow("Hello world!")
glut.glutReshapeWindow(512,512)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutIdleFunc(self.idle)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.mouse)
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
gl.glUseProgram(program)
self.buffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data, gl.GL_DYNAMIC_DRAW)
stride = self.data.strides[0]
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["position"].itemsize)
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)
def attach_shaders(self):
shade_list = []
shade_list.append(self.compile(GL.GL_VERTEX_SHADER,VERT))
shade_list.append(self.compile(GL.GL_FRAGMENT_SHADER,FRAG))
for shade in shade_list:
GL.glAttachShader(self.shader,shade)
self.link()
for shade in shade_list:
GL.glDetachShader(self.shader,shade)
GL.glDeleteShader(shade)
def link_shader_program(vertex_shader):
"""Create a shader program with from compiled shaders."""
program = gl.glCreateProgram()
gl.glAttachShader(program, vertex_shader)
gl.glLinkProgram(program)
# check linking error
result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
if not(result):
raise RuntimeError(gl.glGetProgramInfoLog(program))
return program
def _create(self):
"""
Build (link) the program and checks everything's ok.
A GL context must be available to be able to build (link)
"""
# Check if we have something to link
if not self._verts:
raise ValueError("No vertex shader has been given")
if not self._frags:
raise ValueError("No fragment shader has been given")
# Check if program has been created
if self._handle <= 0:
self._handle = gl.glCreateProgram()
if not self._handle:
raise ShaderException("Cannot create program object")
# Detach any attached shaders
attached = gl.glGetAttachedShaders(self._handle)
for handle in attached:
gl.glDetachShader(self._handle, handle)
# Attach vertex and fragment shaders
for shader in self._verts:
shader.activate()
gl.glAttachShader(self._handle, shader.handle)
for shader in self._frags:
shader.activate()
gl.glAttachShader(self._handle, shader.handle)
log("GPU: Creating program")
# Link the program
gl.glLinkProgram(self._handle)
if not gl.glGetProgramiv(self._handle, gl.GL_LINK_STATUS):
print(gl.glGetProgramInfoLog(self._handle))
raise ShaderException('Linking error')
# Activate uniforms
active_uniforms = [name for (name,gtype) in self.active_uniforms]
for uniform in self._uniforms.values():
if uniform.name in active_uniforms:
uniform.active = True
else:
uniform.active = False
# Activate attributes
active_attributes = [name for (name,gtype) in self.active_attributes]
for attribute in self._attributes.values():
if attribute.name in active_attributes:
attribute.active = True
else:
attribute.active = False
def link_shaders(*shaders):
"""Link an arbitrary number of shaders."""
program = gl.glCreateProgram()
for shader in shaders:
gl.glAttachShader(program, shader)
gl.glLinkProgram(program)
# check linking error
result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
if not(result):
raise RuntimeError(gl.glGetProgramInfoLog(program))
return program
def compileProgram(*shaders):
program = gl.glCreateProgram()
for shader in shaders:
gl.glAttachShader(program, shader)
gl.glLinkProgram(program)
for shader in shaders:
gl.glDeleteShader(shader)
return program
def on_initialize(self, event):
# Build & activate program
self.program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(self.program, vertex)
gl.glAttachShader(self.program, fragment)
gl.glLinkProgram(self.program)
gl.glDetachShader(self.program, vertex)
gl.glDetachShader(self.program, fragment)
gl.glUseProgram(self.program)
# Build vertex buffer
n = 10000
self.data = np.zeros(n, dtype=[('lifetime', np.float32, 1),
('start', np.float32, 3),
('end', np.float32, 3)])
vbuffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbuffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data,
gl.GL_DYNAMIC_DRAW)
# Bind buffer attributes
stride = self.data.strides[0]
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(self.program, "lifetime")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 1, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["lifetime"].itemsize)
loc = gl.glGetAttribLocation(self.program, "start")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["start"].itemsize)
loc = gl.glGetAttribLocation(self.program, "end")
gl.glEnableVertexAttribArray(loc)
gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, stride, offset)
# OpenGL initalization
self.elapsed_time = 0
gl.glClearColor(0, 0, 0, 1)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
gl.glEnable(gl.GL_VERTEX_PROGRAM_POINT_SIZE)
gl.glEnable(gl.GL_POINT_SPRITE)
self.new_explosion()
self.timer.start()
def attach_shaders(self,vert_file,frag_file):
vert,frag = self.load_shader_files(vert_file,frag_file)
shade_list = []
shade_list.append(self.compile(GL.GL_VERTEX_SHADER,vert))
shade_list.append(self.compile(GL.GL_FRAGMENT_SHADER,frag))
for shade in shade_list:
GL.glAttachShader(self.shader,shade)
self.link()
for shade in shade_list:
GL.glDetachShader(self.shader,shade)
GL.glDeleteShader(shade)
def link_shader(vertex_shader, fragment_shader):
"""Create a shader program with from compiled shaders."""
# from http://cyrille.rossant.net/shaders-opengl/
program = gl.glCreateProgram()
gl.glAttachShader(program, vertex_shader)
gl.glAttachShader(program, fragment_shader)
gl.glLinkProgram(program)
# check linking error
result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
if not(result):
raise RuntimeError(gl.glGetProgramInfoLog(program))
return program
def _add_program(self, text, type):
shader = gl.glCreateShader(type)
if shader == 0:
raise ShaderCreateError("Could not find valid memory location when adding shader")
gl.glShaderSource(shader, text)
gl.glCompileShader(shader)
if gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS) == 0:
raise ShaderCreateError(gl.glGetShaderInfoLog(shader))
gl.glAttachShader(self.program, shader)
def initializeGL( self ) : # Default background color gl.glClearColor( 1, 1, 1, 1 ) # Enable depth test gl.glEnable( gl.GL_DEPTH_TEST ) # Enable face culling gl.glEnable( gl.GL_CULL_FACE ) # Enable blending function gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) # Enable multisampling (antialiasing) gl.glEnable( gl.GL_MULTISAMPLE ) # Change point size gl.glPointSize( 5.0 ) # Compile the shaders vertex_shader = gl.glCreateShader( gl.GL_VERTEX_SHADER ) gl.glShaderSource( vertex_shader, self.vertex_shader_source ) gl.glCompileShader( vertex_shader ) fragment_shader = gl.glCreateShader( gl.GL_FRAGMENT_SHADER ) gl.glShaderSource( fragment_shader, self.fragment_shader_source ) gl.glCompileShader( fragment_shader ) # Load the shaders self.shader = gl.glCreateProgram() gl.glAttachShader( self.shader, vertex_shader ) gl.glAttachShader( self.shader, fragment_shader ) gl.glLinkProgram( self.shader ) gl.glUseProgram( self.shader ) gl.glDetachShader( self.shader, vertex_shader ) gl.glDetachShader( self.shader, fragment_shader ) gl.glDeleteShader( vertex_shader ) gl.glDeleteShader( fragment_shader ) # Initialise the projection transformation matrix self.SetProjectionMatrix() # Initialise Model-View transformation matrix self.modelview_matrix = np.identity( 4, dtype=np.float32 ) # Position the scene (camera) self.modelview_matrix[3,2] = -30.0 # Initialise viewing parameters self.point_cloud_loaded = False # Vertex array object self.vertex_array_id = gl.glGenVertexArrays( 1 ) gl.glBindVertexArray( self.vertex_array_id ) # Vertex buffer object self.vertex_buffer_id = gl.glGenBuffers( 1 ) # gl.glBindBuffer( gl.GL_ARRAY_BUFFER, self.vertex_buffer_id ) # gl.glBufferData( gl.GL_ARRAY_BUFFER, 921600, None, gl.GL_STATIC_DRAW ) # gl.glEnableVertexAttribArray( 0 ) # gl.glVertexAttribPointer( 0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, None ) # Color buffer object self.color_buffer_id = gl.glGenBuffers( 1 )
def __init__ (self, *shaders): self.testShaders = shaders self.programGl = gl.glCreateProgram () for shader in shaders: gl.glAttachShader (self.programGl, shader.shaderGl) gl.glLinkProgram (self.programGl) for shader in shaders: gl.glDetachShader (self.programGl, shader.shaderGl) gl.glUseProgram (self.programGl)
def link(self, *shader_objs):
prog = gl.glCreateProgram()
for shader in shader_objs:
gl.glAttachShader(prog, shader)
gl.glLinkProgram(prog)
link_status = gl.glGetProgramiv(prog, gl.GL_LINK_STATUS)
if link_status == gl.GL_FALSE:
raise RuntimeError(
"""Link failure (%s): %s"""%(
link_status,
gl.glGetProgramInfoLog(prog),
))
for shader in shader_objs:
gl.glDeleteShader(shader)
return prog
def on_initialize(self):
gl.glClearColor(0,0,0,1);
# Enable blending
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
# Note: normal GL requires these lines, ES 2.0 does not
from OpenGL import GL
gl.glEnable(GL.GL_VERTEX_PROGRAM_POINT_SIZE)
gl.glEnable(GL.GL_POINT_SPRITE)
# Create shader program
self._prog_handle = gl.glCreateProgram()
# Create vertex shader
shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(shader, VERT_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Vertex shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Create fragment shader
shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(shader, FRAG_CODE)
gl.glCompileShader(shader)
status = gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Fragment shader did not compile.')
else:
gl.glAttachShader(self._prog_handle, shader)
# Link
gl.glLinkProgram(self._prog_handle)
status = gl.glGetProgramiv(self._prog_handle, gl.GL_LINK_STATUS)
if not status:
# We could show more useful info here, but that takes a few lines
raise RuntimeError('Program did not link.')
# Create texture
self._tex_handle = gl.glGenTextures(1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl.glBindTexture(gl.GL_TEXTURE_2D, self._tex_handle)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE,
im1.shape[1], im1.shape[0], 0, gl.GL_LUMINANCE, gl.GL_FLOAT,
im1.astype(np.float32))
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
# Create vertex buffer
self._vbo_handle = gl.glGenBuffers(1)
