def createProgram(vertexShader, fragmentShader):
program = bgl.glCreateProgram()
bgl.glAttachShader(program, vertexShader)
bgl.glAttachShader(program, fragmentShader)
bgl.glLinkProgram(program)
success = bgl.Buffer(bgl.GL_INT, [1])
bgl.glGetProgramiv(program, bgl.GL_LINK_STATUS, success)
#var success = gl.getProgramParameter(program, gl.LINK_STATUS);
if (success[0] == bgl.GL_TRUE):
print("shader link success")
return program
print("shader program linking failed")
bgl.glGetProgramiv(program, bgl.GL_INFO_LOG_LENGTH, success)
start = bgl.Buffer(bgl.GL_INT, [1])
start[0] =0
log = bgl.Buffer(bgl.GL_BYTE, [success[0]])
bgl.glGetProgramInfoLog(program, success[0], start, log)
py_log = log[:]
py_log_str = ""
for c in py_log:
py_log_str += str(chr(c))
print(str(py_log_str))
bgl.glDeleteProgram(program)
def __init__(self, name, srcVertex, srcFragment, funcStart=None, funcEnd=None, checkErrors=True, bindTo0=None):
self.drawing = Drawing.get_instance()
self.name = name
self.shaderProg = bgl.glCreateProgram()
self.shaderVert = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
self.shaderFrag = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
self.checkErrors = checkErrors
srcVertex = '\n'.join(l.strip() for l in srcVertex.split('\n'))
srcFragment = '\n'.join(l.strip() for l in srcFragment.split('\n'))
bgl.glShaderSource(self.shaderVert, srcVertex)
bgl.glShaderSource(self.shaderFrag, srcFragment)
dprint('RetopoFlow Shader Info: %s (%d)' % (self.name,self.shaderProg))
logv = self.shader_compile(name, self.shaderVert)
logf = self.shader_compile(name, self.shaderFrag)
if len(logv.strip()):
dprint(' vert log:\n' + '\n'.join((' '+l) for l in logv.splitlines()))
if len(logf.strip()):
dprint(' frag log:\n' + '\n'.join((' '+l) for l in logf.splitlines()))
bgl.glAttachShader(self.shaderProg, self.shaderVert)
bgl.glAttachShader(self.shaderProg, self.shaderFrag)
if bindTo0:
bgl.glBindAttribLocation(self.shaderProg, 0, bindTo0)
bgl.glLinkProgram(self.shaderProg)
self.shaderVars = {}
lvars = [l for l in srcVertex.splitlines() if l.startswith('in ')]
lvars += [l for l in srcVertex.splitlines() if l.startswith('attribute ')]
lvars += [l for l in srcVertex.splitlines() if l.startswith('uniform ')]
lvars += [l for l in srcFragment.splitlines() if l.startswith('uniform ')]
for l in lvars:
m = re.match('^(?P<qualifier>[^ ]+) +(?P<type>[^ ]+) +(?P<name>[^ ;]+)', l)
assert m
m = m.groupdict()
q,t,n = m['qualifier'],m['type'],m['name']
locate = bgl.glGetAttribLocation if q in {'in','attribute'} else bgl.glGetUniformLocation
if n in self.shaderVars: continue
self.shaderVars[n] = {
'qualifier': q,
'type': t,
'location': locate(self.shaderProg, n),
'reported': False,
}
dprint(' attribs: ' + ', '.join((k + ' (%d)'%self.shaderVars[k]['location']) for k in self.shaderVars if self.shaderVars[k]['qualifier'] in {'in','attribute'}))
dprint(' uniforms: ' + ', '.join((k + ' (%d)'%self.shaderVars[k]['location']) for k in self.shaderVars if self.shaderVars[k]['qualifier'] in {'uniform'}))
self.funcStart = funcStart
self.funcEnd = funcEnd
self.mvpmatrix_buffer = bgl.Buffer(bgl.GL_FLOAT, [4,4])
def create_program(*shaders):
program = bgl.glCreateProgram()
for shader in shaders:
bgl.glAttachShader(program, shader)
bgl.glLinkProgram(program)
status = bgl.Buffer(bgl.GL_INT, 1)
bgl.glGetProgramiv(program, bgl.GL_LINK_STATUS, status)
if status[0] != bgl.GL_TRUE:
infoLog = bgl.Buffer(bgl.GL_BYTE, 1024)
length = bgl.Buffer(bgl.GL_INT, 1)
bgl.glGetProgramInfoLog(program, 1024, length, infoLog)
raise RuntimeError(''.join(chr(infoLog[i]) for i in range(length[0])))
return program
def compile_program(vshader,fshader,gshader, program_name):
"""
Compile and link OpenGL shaders into a program.
It prints any errors along with the sourcecode on the console
After a successful linking it also shows a list of active
attributes and uniforms.
vshader, fshader and gshader are strings containing the GLSL
source code for vertex, fragment and geometry shader respectively.
Any of those might be None
Returns an int (an OpenGL program name)
program_name is arbitray human readable string
"""
program = bgl.glCreateProgram()
error = False
if vshader is not None:
vertex_shader = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
bgl.glShaderSource(vertex_shader,vshader)
bgl.glCompileShader(vertex_shader)
if not gl_compile_error(program_name, "vertexshader", vertex_shader):
bgl.glAttachShader(program, vertex_shader)
else:
dump_source(vshader)
error = True
if fshader is not None:
fragment_shader = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
bgl.glShaderSource(fragment_shader,fshader)
bgl.glCompileShader(fragment_shader)
if not gl_compile_error(program_name, "fragmentshader", fragment_shader):
bgl.glAttachShader(program, fragment_shader)
else:
dump_source(fshader)
error = True
if gshader is not None:
geometry_shader = bgl.glCreateShader(bgl.GL_GEOMETRY_SHADER)
bgl.glShaderSource(geometry_shader,gshader)
bgl.glCompileShader(geometry_shader)
if not gl_compile_error(program_name, "geometryshader", geometry_shader):
bgl.glAttachShader(program, geometry_shader)
else:
dump_source(gshader)
error = True
if not error:
bgl.glLinkProgram(program)
gl_link_error(program_name, program)
dump_attributes_and_uniforms(program)
return program
def __init__(self, vertexcode, geomcode, fragcode):
success = bgl.Buffer(bgl.GL_INT, 1)
program = bgl.glCreateProgram()
shader1 = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
bgl.glShaderSource(shader1, vertexcode)
check_error("glShaderSource")
bgl.glCompileShader(shader1)
check_error("glCompileShader")
bgl.glGetShaderiv(shader1, bgl.GL_COMPILE_STATUS, success)
if success[0] != bgl.GL_TRUE:
print("shader vertexcode compile error")
shader2 = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
bgl.glShaderSource(shader2, fragcode)
check_error("glShaderSource")
bgl.glCompileShader(shader2)
check_error("glCompileShader")
bgl.glGetShaderiv(shader2, bgl.GL_COMPILE_STATUS, success)
check_error("glGetShaderiv")
if success[0] != bgl.GL_TRUE:
print("shader fragcode compile error")
bgl.glAttachShader(program, shader1)
check_error("glAttachShader")
bgl.glAttachShader(program, shader2)
check_error("glAttachShader")
bgl.glLinkProgram(program)
check_error("glLinkProgram")
bgl.glGetProgramiv(program, bgl.GL_LINK_STATUS, success)
check_error("glGetProgramiv")
if success[0] != bgl.GL_TRUE:
print("Program link error")
bgl.glValidateProgram(program)
check_error("glValidateProgram")
bgl.glGetProgramiv(program, bgl.GL_VALIDATE_STATUS, success)
check_error("glGetProgramiv")
if success[0] != bgl.GL_TRUE:
print("Program invalid")
self.program = program
def __init__(self, vertexcode, geomcode, fragcode):
self.program = bgl.glCreateProgram()
self.shaders = []
if vertexcode:
self.shaders.append(create_shader(vertexcode, bgl.GL_VERTEX_SHADER))
if geomcode:
self.shaders.append(create_shader(geomcode, bgl.GL_GEOMETRY_SHADER))
if fragcode:
self.shaders.append(create_shader(fragcode, bgl.GL_FRAGMENT_SHADER))
for shad in self.shaders:
bgl.glAttachShader(self.program, shad)
bgl.glLinkProgram(self.program)
check_shaderError(self.program, bgl.GL_LINK_STATUS, True, "Error: Program linking failed:")
bgl.glValidateProgram(self.program)
check_shaderError(self.program, bgl.GL_VALIDATE_STATUS, True, "Error: Program is invalid:")
def __init__(self):
#vertex_shader = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
fragment_shader = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
program = bgl.glCreateProgram()
#bgl.glShaderSource(vertex_shader,vs)
bgl.glShaderSource(fragment_shader, fs)
#bgl.glCompileShader(vertex_shader)
bgl.glCompileShader(fragment_shader)
#utils.attachShader(program, vertex_shader)
utils.attachShader(program, fragment_shader)
bgl.glLinkProgram(program)
self.program = program
def __init__(self, vertexcode, geomcode, fragcode):
self.program = bgl.glCreateProgram()
self.shaders = []
if vertexcode:
self.shaders.append(create_shader(vertexcode, bgl.GL_VERTEX_SHADER))
if geomcode:
self.shaders.append(create_shader(geomcode, bgl.GL_GEOMETRY_SHADER))
if fragcode:
self.shaders.append(create_shader(fragcode, bgl.GL_FRAGMENT_SHADER))
for shad in self.shaders:
bgl.glAttachShader(self.program, shad)
bgl.glLinkProgram(self.program)
check_shaderError(self.program, bgl.GL_LINK_STATUS, True, "Error: Program linking failed:")
bgl.glValidateProgram(self.program)
check_shaderError(self.program, bgl.GL_VALIDATE_STATUS, True, "Error: Program is invalid:")
def __init__(self, srcVertex, srcFragment, funcStart=None):
self.shaderProg = bgl.glCreateProgram()
self.shaderVert = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
self.shaderFrag = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
bgl.glShaderSource(self.shaderVert, srcVertex)
bgl.glShaderSource(self.shaderFrag, srcFragment)
print('RetopoFlow Shader Info')
logv = self.shader_compile(self.shaderVert)
logf = self.shader_compile(self.shaderFrag)
if len(logv.strip()):
print(' vert log:\n' + '\n'.join((' '+l) for l in logv.splitlines()))
if len(logf.strip()):
print(' frag log:\n' + '\n'.join((' '+l) for l in logf.splitlines()))
bgl.glAttachShader(self.shaderProg, self.shaderVert)
bgl.glAttachShader(self.shaderProg, self.shaderFrag)
bgl.glLinkProgram(self.shaderProg)
self.shaderVars = {}
lvars = [l for l in srcVertex.splitlines() if l.startswith('in ')]
lvars += [l for l in srcVertex.splitlines() if l.startswith('attribute ')]
lvars += [l for l in srcVertex.splitlines() if l.startswith('uniform ')]
lvars += [l for l in srcFragment.splitlines() if l.startswith('uniform ')]
for l in lvars:
m = re.match('^(?P<qualifier>[^ ]+) +(?P<type>[^ ]+) +(?P<name>[^ ;]+)', l)
assert m
m = m.groupdict()
q,t,n = m['qualifier'],m['type'],m['name']
locate = bgl.glGetAttribLocation if q in {'in','attribute'} else bgl.glGetUniformLocation
if n in self.shaderVars: continue
self.shaderVars[n] = {
'qualifier': q,
'type': t,
'location': locate(self.shaderProg, n),
}
print(' attribs: ' + ', '.join(k for k in self.shaderVars if self.shaderVars[k]['qualifier'] in {'in','attribute'}))
print(' uniforms: ' + ', '.join(k for k in self.shaderVars if self.shaderVars[k]['qualifier'] in {'uniform'}))
self.funcStart = funcStart
def compile_shader():
global program
program = bgl.glCreateProgram()
shaderVert = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
shaderFrag = bgl.glCreateShader(bgl.GL_FRAGMENT_SHADER)
bgl.glShaderSource(shaderVert, shaderVertString)
bgl.glShaderSource(shaderFrag, shaderFragString)
bgl.glCompileShader(shaderVert)
bgl.glCompileShader(shaderFrag)
bgl.glAttachShader(program, shaderVert)
bgl.glAttachShader(program, shaderFrag)
bgl.glLinkProgram(program)
bgl.glDeleteShader(shaderVert)
bgl.glDeleteShader(shaderFrag)
def execute(self, context):
namespace['projection_matrix'] = bgl.Buffer(bgl.GL_FLOAT, (4, 4))
namespace['points'] = (-0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0)
namespace['colors'] = (0.0, 1.0, 0.0, 0.5, 1.0, 1.0, 0.0, 0.5, 1.0,
0.0, 1.0, 0.5)
namespace['data_point'] = bgl.Buffer(bgl.GL_FLOAT,
len(namespace['points']),
namespace['points'])
namespace['data_color'] = bgl.Buffer(bgl.GL_FLOAT,
len(namespace['colors']),
namespace['colors'])
namespace['vertex_shader_info'] = bgl.Buffer(bgl.GL_INT, 1)
namespace['fragment_shader_info'] = bgl.Buffer(bgl.GL_INT, 1)
namespace['shader_program_info'] = bgl.Buffer(bgl.GL_INT, 1)
namespace['vao'] = bgl.Buffer(bgl.GL_INT, 1)
namespace['vbo_point'] = bgl.Buffer(bgl.GL_INT, 1)
namespace['vbo_color'] = bgl.Buffer(bgl.GL_INT, 1)
bgl.glGenBuffers(1, namespace['vbo_point'])
bgl.glGenBuffers(1, namespace['vbo_color'])
# Shaders
namespace['shader_program'] = bgl.glCreateProgram()
namespace['vertex_shader'] = bgl.glCreateShader(bgl.GL_VERTEX_SHADER)
namespace['fragment_shader'] = bgl.glCreateShader(
bgl.GL_FRAGMENT_SHADER)
bgl.glShaderSource(namespace['vertex_shader'], vertex_shader_source)
bgl.glShaderSource(namespace['fragment_shader'],
fragment_shader_source)
bgl.glCompileShader(namespace['vertex_shader'])
bgl.glCompileShader(namespace['fragment_shader'])
bgl.glGetShaderiv(namespace['vertex_shader'], bgl.GL_COMPILE_STATUS,
namespace['vertex_shader_info'])
bgl.glGetShaderiv(namespace['fragment_shader'], bgl.GL_COMPILE_STATUS,
namespace['fragment_shader_info'])
if namespace['vertex_shader_info'][0] == bgl.GL_TRUE:
print("Vertex shader compiled successfully.")
elif namespace['vertex_shader_info'][0] == bgl.GL_FALSE:
print("Vertex shader failed to compile.")
if namespace['fragment_shader_info'][0] == bgl.GL_TRUE:
print("Fragment shader compiled successfully.")
elif namespace['fragment_shader_info'][0] == bgl.GL_FALSE:
print("Fragment shader failed to compile.")
bgl.glAttachShader(namespace['shader_program'],
namespace['vertex_shader'])
bgl.glAttachShader(namespace['shader_program'],
namespace['fragment_shader'])
bgl.glLinkProgram(namespace['shader_program'])
bgl.glGetProgramiv(namespace['shader_program'], bgl.GL_LINK_STATUS,
namespace['shader_program_info'])
if namespace['shader_program_info'][0] == bgl.GL_TRUE:
print("Shader program linked successfully.")
elif namespace['shader_program_info'][0] == bgl.GL_FALSE:
print("Shader program failed to link.")
# glGetUniformLocation can only be used after the shader program is linked, as stated in the OpenGL Specification.
namespace['perspective_uniform_location'] = bgl.glGetUniformLocation(
namespace['shader_program'], "perspective")
bgl.glValidateProgram(namespace['shader_program'])
bgl.glGetProgramiv(namespace['shader_program'], bgl.GL_VALIDATE_STATUS,
namespace['shader_program_info'])
if namespace['shader_program_info'][0] == bgl.GL_TRUE:
print("Shader program validated successfully.")
elif namespace['shader_program_info'][0] == bgl.GL_FALSE:
print("Shader program failed to validate.")
draw_handler_add()
namespace['timer'] = context.window_manager.event_timer_add(
time_step=0.01, window=context.window)
namespace['data_timer'] = bgl.Buffer(bgl.GL_FLOAT, 2, [
math.sin(namespace['timer'].time_duration),
math.sin(namespace['timer'].time_duration) * 2
])
context.window_manager.modal_handler_add(self)
return {'RUNNING_MODAL'}