def init(self):
glEnable( GL_MULTISAMPLE )
"""
initializes shader program, framebuffer and plane vao/vbo
"""
# default shader program
if self.program is None:
program = Program()
vertex_shader = Shader(GL_VERTEX_SHADER, load_lib_file('glsl/framewindow.vert.glsl'))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/framewindow.frag.glsl'))
program.shaders.append(vertex_shader)
program.shaders.append(fragment_shader)
program.link()
self.program = program
# default complex record shader program
if self.record_mode == Framebuffer.RECORD_TRACK_COMPLEX and self.record_program is None:
program = Program()
vertex_shader = Shader(GL_VERTEX_SHADER, load_lib_file('glsl/framewindow_record.vert.glsl'))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/framewindow_record.frag.glsl'))
program.shaders.append(vertex_shader)
program.shaders.append(fragment_shader)
program.link()
self.record_program = program
self.init_capturing()
self.init_screen()
self.update_camera(self.camera)
self.update_modelview()
def init_shader(self):
self.program = Program()
self.program.shaders.append(Shader(GL_VERTEX_SHADER, load_lib_file('glsl/plot2d/axis/marker_y.vert.glsl')))
self.program.shaders.append(Shader(GL_GEOMETRY_SHADER, load_lib_file('glsl/plot2d/axis/marker_y.geom.glsl')))
self.program.shaders.append(Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/plot2d/axis/marker.frag.glsl')))
self.program.link()
self.program.uniform('color', self.linecolor)
self.vao = VertexArray({
'vertex_position': VertexBuffer.from_numpy(self.measurements)
}, self.program.attributes)
def init(self):
"""
prepares shaders and vao/vbo
"""
# init gl
program = Program()
vertex_shader = Shader(GL_VERTEX_SHADER, load_lib_file('glsl/font/font.vert.glsl'))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/font/font.frag.glsl'))
program.shaders.append(vertex_shader)
program.shaders.append(fragment_shader)
program.link()
self.program = program
self.camera.on_change_matrix.append(self.camera_updated)
def gl_init(self):
program = Program()
program.shaders.append(Shader(GL_VERTEX_SHADER, load_lib_file('glsl/shaperenderer/vert.glsl')))
program.shaders.append(Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/shaperenderer/frag.glsl')))
program.link()
program.uniform('mat_camera', self.camera.get_matrix())
self.program = program
border_program = Program()
border_program.shaders.append(Shader(GL_VERTEX_SHADER, load_lib_file('glsl/shaperenderer/vert.glsl')))
border_program.shaders.append(Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/shaperenderer/border.frag.glsl')))
border_program.link()
border_program.uniform('mat_camera', self.camera.get_matrix())
self.border_program = border_program
self._borderframe = Framebuffer(self.camera, self.camera.screensize, clear_color=[0,0,0,0], blit_texture=True)
self._borderframe.init()
def init_shader(self):
"""
initializes shader
"""
axis_program = Program()
vertex_shader = Shader(GL_VERTEX_SHADER, load_lib_file('glsl/plot2d/axis/marker_{}.vert.glsl'.format('x' if self._axis == 0 else 'y')))
geometry_shader = Shader(GL_GEOMETRY_SHADER, load_lib_file('glsl/plot2d/axis/marker_{}.geom.glsl'.format('x' if self._axis == 0 else 'y')))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/plot2d/axis/marker.frag.glsl'))
axis_program.shaders.append(vertex_shader)
axis_program.shaders.append(geometry_shader)
axis_program.shaders.append(fragment_shader)
axis_program.link()
self.axis_program = axis_program
self.axis_program.use()
#self.axis_program.uniform('mat_modelview', numpy.array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1], dtype=numpy.float32))
self.axis_program.uniform('color', self.linecolor)
self.axis_program.unuse()
def gl_init(self):
"""
initializes shader program and plane vao
"""
glsl_functions = ""
if hasattr(self.color_scheme, "glsl_functions"):
glsl_functions += "\n/*COLOR_SCHEME FUNCTIONS*/\n"
glsl_functions += self.color_scheme.glsl_functions
if hasattr(self.data_kernel, "glsl_functions"):
glsl_functions += "\n/*DATA_KERNEL FUNCTIONS*/\n"
glsl_functions += self.data_kernel.glsl_functions
glsl_uniforms = []
if hasattr(self.color_scheme, "glsl_uniforms"):
glsl_uniforms.append("/*COLOR_SCHEME UNIFORMS*/")
glsl_uniforms += ["uniform {} {};".format(t, n) for t, n in self.color_scheme.glsl_uniforms]
if hasattr(self.data_kernel, "glsl_uniforms"):
glsl_uniforms.append("/*DATA_KERNEL UNIFORMS*/")
glsl_uniforms += ["uniform {} {};".format(t, n) for t, n in self.data_kernel.glsl_uniforms]
frag_src = pystache.render(
load_lib_file("glsl/plot2d/field.frag.glsl"),
{
"UNIFORMS": "\n".join(glsl_uniforms),
"FUNCTIONS": glsl_functions,
"DATA_KERNEL": str(self.data_kernel),
"COLOR_KERNEL": str(self.color_scheme),
},
)
self.program = Program()
self.program.shaders.append(Shader(GL_VERTEX_SHADER, load_lib_file("glsl/plot2d/field.vert.glsl")))
self.program.shaders.append(Shader(GL_FRAGMENT_SHADER, frag_src))
self.program.link()
if hasattr(self.color_scheme, "get_uniform_data"):
for uniform in self.color_scheme.get_uniform_data().items():
self.program.uniform(*uniform)
if hasattr(self.data_kernel, "get_uniform_data"):
for uniform in self.data_kernel.get_uniform_data().items():
self.program.uniform(*uniform)
self.initialized = True
def _compile_glsl_programs(self, vertex_source):
"""
compiles glsl programs
"""
vertex_shader = Shader(GL_VERTEX_SHADER, vertex_source, substitutions={
'KERNEL' : self._kernel+';', #user friendly semicolon :)
})
geometry_shader = Shader(GL_GEOMETRY_SHADER, load_lib_file('glsl/plot2d/line.geom.glsl'))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/plot2d/line.frag.glsl'))
try:
vertex_shader.compile()
except ShaderError as e:
# try to compile shader without kernel to see whether
# it is an error by user kernel oder by shader itsel
try:
Shader(GL_VERTEX_SHADER, vertex_source).compile()
raise Error('invalid syntax in user defined kernel "{}"'.format(self._kernel))
except ShaderError as e2:
raise e
program = Program()
program.shaders.append(vertex_shader)
program.shaders.append(geometry_shader)
program.shaders.append(fragment_shader)
program.link()
self.program = program
geometry_shader = Shader(GL_GEOMETRY_SHADER, load_lib_file('glsl/plot2d/dot.geom.glsl'))
fragment_shader = Shader(GL_FRAGMENT_SHADER, load_lib_file('glsl/plot2d/dot.frag.glsl'))
program = Program()
program.shaders.append(vertex_shader)
program.shaders.append(geometry_shader)
program.shaders.append(fragment_shader)
program.link()
self.dot_program = program
def init(self):
"""
creates shader and vao
"""
if not type(self.domains) is list:
self.domains = [self.domains]
vertex_array = {}
shader_pre_compile_vbo = ''
shader_pre_compile_transformations = ''
shader_pre_compile_uniforms = ''
uniforms_transformation_matricies = {}
# loop thru all domains to prepare vertex array buffers
# and glsl pre compiled code
for i, domain in enumerate(self.domains):
if hasattr(domain, 'gl_init'):
domain.gl_init()
if hasattr(domain, 'transform'):
domain.transform()
if not hasattr(domain, 'gl_vbo_id'):
raise TypeError('any domain passed to graph must have gl_vbo_id attribute')
vec_d = ('vec'+str(domain.dimension)) if domain.dimension > 1 else 'float'
vertex_array['in_d{}'.format(i)] = VertexBuffer(dimension=domain.dimension, gl_vbo_id=domain.gl_vbo_id)
shader_pre_compile_vbo += 'in {} in_d{};\n'.format(vec_d, i)
if hasattr(domain, 'get_transformation_matrix'):
shader_pre_compile_uniforms += 'uniform mat{} trans_d{};\n'.format(min(4,domain.dimension+1), i)
shader_pre_compile_transformations += '{vec} d{i}; d{i} = (trans_d{i} * {vecext}).{coords};\n'.format(
coords = 'x' if domain.dimension == 1 else ('xy' if domain.dimension==2 else ('xyz' if domain.dimension==3 else 'xyzw')),
vec=vec_d,
i=i,
vecext='vec{d1}(in_d{i},1)'.format(d1=domain.dimension+1,i=i) if domain.dimension < 4 else 'in_d{i}'.format(i=i),
)
uniforms_transformation_matricies['trans_d{}'.format(i)] = 'mat{}'.format(min(4,domain.dimension+1))
else:
shader_pre_compile_transformations += '{vec} d{i}; d{i} = in_d{i};\n'.format(vec=vec_d, i=i)
self._calc_length_offset()
# get glsl_functions if there are some available.
color_functions = ''
if hasattr(self.color_scheme, 'glsl_functions'):
color_functions = self.color_scheme.glsl_functions
vertex_source = pystache.render(load_lib_file('glsl/plot2d/line.vert.glsl'),{
'VBO_IN' : shader_pre_compile_vbo,
'UNIFORMS' : shader_pre_compile_uniforms,
'TRANSFORMATIONS': shader_pre_compile_transformations,
'DATA_LAYOUT' : self._pre_compile_data_layout(),
'COLOR_SCHEME' : self.color_scheme,
'COLOR_FUNCTIONS': color_functions
})
self._compile_glsl_programs(vertex_source)
self._init_program_uniforms()
self.register_domains(vertex_array)
self.initialized = True
def glsl_functions(self): return load_lib_file('../vendor/glsl-colormap/shaders/{}.frag'.format(self.filename))
def __str__(self): return ColorMap.COLOR_KERNEL.format(self.source)
