class BrepRenderer(Renderer):
__vrtx_vbo = meta.MetaVrtxBffr(attr_desc=np.dtype([
('coord', 'f4', 4),
]),
attr_locs=(0, ))
__pnt_vbo = meta.MetaVrtxBffr(attr_desc=np.dtype([('clr', 'f4', 4),
('dia', 'f4')]),
attr_locs=(1, 2))
__pnt_prgrm = meta.MetaPrgrm(
vrtx_path=get_shader_fullpath('shaders/pnts/pntCir_vrtx_shdr.glsl'),
frgm_path=get_shader_fullpath('shaders/pnts/pntCir_frgm_shdr.glsl'))
def __init__(self):
self.__pnt_ibo = meta.MetaIndxBffr(dtype='uint')
self.__pnt_vao = meta.MetaVrtxArry(self.__vrtx_vbo,
self.__pnt_vbo,
indx_bffr=self.__pnt_ibo)
@property
def vrtx_vbo(self):
return self.__vrtx_vbo
@property
def pnt_vbo(self):
return self.__pnt_vbo
@property
def pnt_ibo(self):
return self.__pnt_ibo
def render(self):
self.__vrtx_vbo.push_cache()
class PolylineRenderer(Renderer):
__sharp_prgrm = meta.MetaPrgrm(
vrtx_path=get_shader_fullpath('shaders/plinSharp_vrtx_shdr.glsl'),
geom_path=get_shader_fullpath('shaders/plinSharp_geom_shdr.glsl'),
frgm_path=get_shader_fullpath('shaders/plinSharp_frgm_shdr.glsl'))
def __init__(self):
super().__init__()
self.__vbo = self.__sharp_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__ibo = meta.MetaIndxBffr(dtype='uint')
self.__vao = meta.MetaVrtxArry(self.__vbo, indx_bffr=self.__ibo)
def create_dataset(self, size):
dataset = {
'vrtx': self.__vbo.cache.request_block(size),
'indx': self.__ibo.cache.request_block(size)
}
dataset['indx']['idx'] = dataset['vrtx'].indices
return dataset
def free_finalizer(self, dataset, *args, **kargs):
if dataset:
dataset['vrtx'].release()
dataset['indx'].release()
dataset.clear()
def update_cache(self, shape, arg_name, value):
self.datasets[shape]['vrtx'][arg_name] = value
def render(self):
self.__vbo.push_cache()
self.__ibo.push_cache()
self.__render_sharp()
def __render_sharp(self):
if not self.__ibo.cache.active_size:
return
with self.__vao:
with self.__sharp_prgrm:
# uniforms
camera = get_current_ogl(
).manager.window.devices.cameras.current
self.__sharp_prgrm.uniforms['VM'] = camera.tripod.VM
self.__sharp_prgrm.uniforms['PM'] = camera.body.PM
self.__sharp_prgrm.uniforms['MM'] = [[1, 0, 0,
0], [0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
self.__sharp_prgrm.push_uniforms()
gl.glDrawElements(gl.GL_LINE_STRIP,
self.__ibo.cache.active_size,
self.__ibo.cache.gldtype[0],
ctypes.c_void_p(0))
class AxisRenderer(Renderer):
"""
draw camera flat thickened axis
"""
__this_dir = os.path.dirname(__file__)
__prgrm = meta.MetaPrgrm(vrtx_path=os.path.join(__this_dir, 'axis_vrtx_shdr.glsl'),
geom_path=os.path.join(__this_dir, 'axis_geom_shdr.glsl'),
frgm_path=os.path.join(__this_dir, 'axis_frgm_shdr.glsl'))
def __init__(self):
self.__vbo = self.__prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__ibo = meta.MetaIndxBffr(dtype='uint')
self.__vao = meta.MetaVrtxArry(self.__vbo, indx_bffr=self.__ibo)
@property
def vbo(self):
return self.__vbo
@property
def ibo(self):
return self.__ibo
def render(self):
if not self.__ibo.cache.active_size:
return
devices = get_current_ogl().manager.window.devices
camera = devices.cameras.current
self.__prgrm.uniforms['PM'] = camera.body.PM
self.__prgrm.uniforms['VM'] = camera.tripod.VM
self.__prgrm.uniforms['pane_size'] = devices.panes.current.glyph.size
self.__prgrm.uniforms['LRBT'] = camera.body.dim[:4]
self.__prgrm.uniforms['cam_near'] = camera.body.near
self.__prgrm.uniforms['cam_ori'] = camera.tripod.plane.origin.T
self.__prgrm.uniforms['fn_coord'] = camera.near_clipping_face
self.__prgrm.uniforms['ff_coord'] = camera.far_clipping_face
self.__prgrm.push_uniforms()
self.__vbo.push_cache()
self.__ibo.push_cache()
with self.__prgrm:
with self.__vao:
gl.glDrawElements(gl.GL_POINTS,
self.__ibo.cache.active_size,
self.__ibo.cache.gldtype[0],
ctypes.c_void_p(0))
class _CursorRenderer:
__path = os.path.dirname(__file__)
__dot_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(__path, 'dot_vrtx_shdr.glsl'),
frgm_path=os.path.join(__path, 'dot_frgm_shdr.glsl'))
def __init__(self):
self.__dot_vbo = self.__dot_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__dot_vao = meta.MetaVrtxArry(self.__dot_vbo)
self.__block = self.__dot_vbo.cache.request_block(size=1)
self.__flag_push = True
self.__pos = None
self.__clr = None
self.__dim = None
self.set_pos(0, 0)
self.set_clr(1, 1, 1, 1)
self.set_dim(5)
def set_pos(self, x, y):
self.__pos = x, y
self.__block['pos'] = x, y
self.__flag_push = True
def set_clr(self, r, g, b, a):
self.__clr = r, g, b, a
self.__block['clr'] = r, g, b, a
self.__flag_push = True
def set_dim(self, v):
self.__dim = v
self.__block['dim'] = v
self.__flag_push = True
def render_dot(self):
if self.__flag_push:
self.__dot_vbo.push_cache()
self.__flag_push = False
with self.__dot_prgrm:
with self.__dot_vao:
gl.glDrawArrays(gl.GL_POINTS, 0, 1)
class GroundRenderer(Renderer):
"""
draw infinite ground
"""
__prgrm = meta.MetaPrgrm(
vrtx_path=get_shader_fullpath('shaders/ground_vrtx_shdr.glsl'),
frgm_path=get_shader_fullpath('shaders/ground_frgm_shdr.glsl'))
def __init__(self):
super().__init__()
self.__vbo = self.__prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__vao = meta.MetaVrtxArry(self.__vbo)
def create_dataset(self, size):
vb = self.__vbo.cache.request_block(size)
vb['pos'] = (-1, -1, 0), (1, -1, 0), (1, 1, 0), (-1, 1, 0)
return [vb]
def update_cache(self, shape, arg_name, value):
self.datasets[shape][0][arg_name] = value
def free_finalizer(self, dataset):
if dataset:
dataset[0].release()
dataset.clear()
def render(self):
camera = get_current_ogl().manager.window.devices.cameras.current
# update camera properties
for block in self.__vbo.cache.blocks:
block['near'] = camera.near_clipping_face[:3].T
block['far'] = camera.far_clipping_face[:3].T
self.__vbo.push_cache()
self.__prgrm.uniforms['PM'] = camera.body.PM
self.__prgrm.uniforms['VM'] = camera.tripod.VM
self.__prgrm.push_uniforms()
with self.__prgrm:
with self.__vao:
gl.glDrawArrays(gl.GL_QUADS, 0, 4)
class TriangleRenderer(Renderer):
"""
full spec schema of triangle object.
use this schema as programs are not obliged to implement all attributes
! programs should follow fixed attribute name and locations
layout(location = 0) in vtx;
layout(location = 1) in edge_thk;
layout(location = 2) in edge_clr;
layout(location = 3) in fill_clr;
... add more to expand render possibility
:param self.__fill_prgrm: for drawing triangle fill
:param self.__edge_prgrm: for drawing triangle thick edge
:param self.__trnsf_ufrm_cache: buffer cache of transformation matrices
"""
__prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(os.path.dirname(__file__),
'shaders/tgls/tglSharpEdge_vrtx_shdr.glsl'),
geom_path=os.path.join(os.path.dirname(__file__),
'shaders/tgls/tglSharpEdge_geom_shdr.glsl'),
frgm_path=os.path.join(os.path.dirname(__file__),
'shaders/tgls/tglSharpEdge_frgm_shdr.glsl'))
def __init__(self):
super().__init__()
self.__vbo = self.__prgrm.vrtx_attr_schema.union(
self.__prgrm.vrtx_attr_schema).create_vrtx_bffr()
self.__ibo = meta.MetaIndxBffr('uint')
self.__vao = meta.MetaVrtxArry(self.__vbo, indx_bffr=self.__ibo)
def create_dataset(self, size):
vb = self.__vbo.cache.request_block(size)
ib = self.__ibo.cache.request_block(size)
ib['idx'] = vb.indices
return {'vrtx': vb, 'indx': ib}
def free_finalizer(self, dataset):
if dataset:
for block in dataset.values():
block.release()
dataset.clear()
def update_cache(self, shape, arg_name, value):
self.datasets[shape]['vrtx'][arg_name] = value
def __update_global_ufrm(self, prgrm):
"""
update transformation uniforms
:return:
"""
camera = get_current_ogl().manager.window.devices.cameras.current
prgrm.uniforms['PM'] = camera.body.PM
prgrm.uniforms['VM'] = camera.tripod.VM
prgrm.uniforms['MM'] = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]]
prgrm.push_uniforms()
def render(self, is_render_edge=True):
"""
:param is_render_edge: bool, do render edge?
:return:
"""
self.__vbo.push_cache()
self.__ibo.push_cache()
with self.__vao:
if not self.__ibo.cache.active_size:
return
with self.__prgrm:
self.__update_global_ufrm(self.__prgrm)
gl.glDrawElements(gl.GL_TRIANGLES,
self.__ibo.cache.active_size,
self.__ibo.cache.gldtype[0],
ctypes.c_void_p(0))
class PointRenderer(Renderer):
"""
this is not an expandable, simple functionality wrapper
prgrm parameter layout:
! follow fixed attribute location
layout (location = 0) in vec4 vtx;
layout (location = 1) in vec4 clr;
layout (location = 2) in float dia;
... add more to expand render possibility
:return:
:param self.__~_prgrm: program drawing sized square points
:param self.__~_indx_bffr: index buffer storing drawing index of its type
:param self.__~_ufrm_cache: buffer cache of transformation matrices
"""
__square_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntSqr_vrtx_shdr.glsl'),
geom_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntSqr_geom_shdr.glsl'),
frgm_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntSqr_frgm_shdr.glsl'))
__circle_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntCir_vrtx_shdr.glsl'),
frgm_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntCir_frgm_shdr.glsl'))
__triangle_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntTgl_vrtx_shdr.glsl'),
geom_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntTgl_geom_shdr.glsl'),
frgm_path=os.path.join(os.path.dirname(__file__),
'shaders/pnts/pntTgl_frgm_shdr.glsl'))
def __init__(self):
super().__init__()
self.__vbo = self.__square_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__circle_ibo = meta.MetaIndxBffr('uint')
self.__circle_vao = meta.MetaVrtxArry(self.__vbo,
indx_bffr=self.__circle_ibo)
self.__square_ibo = meta.MetaIndxBffr('uint')
self.__square_vao = meta.MetaVrtxArry(self.__vbo,
indx_bffr=self.__square_ibo)
self.__triangle_ibo = meta.MetaIndxBffr('uint')
self.__triangle_vao = meta.MetaVrtxArry(self.__vbo,
indx_bffr=self.__triangle_ibo)
self.__ibos = {
's': self.__square_ibo,
't': self.__triangle_ibo,
'c': self.__circle_ibo
}
def update_cache(self, shape, arg_name, val):
if arg_name == 'frm':
if val not in self.__ibos:
raise ValueError(
"form value has to be one of 's'quare, 't'riangle, 'c'ircle"
)
# swap ibo
ibo = self.datasets[shape]['ibo']
new_ibo = self.__ibos[val]
if ibo == new_ibo:
return
if ibo:
self.datasets[shape]['indx'].release()
self.datasets[shape]['ibo'] = new_ibo
indx_block = new_ibo.cache.request_block(size=1)
self.datasets[shape]['indx'] = indx_block
# put index value
indx_block['idx'] = self.datasets[shape]['vrtx'].indices
else:
self.datasets[shape]['vrtx'][arg_name] = val
def create_dataset(self, size):
dataset = {
'vrtx': self.__vbo.cache.request_block(size),
'indx': self.__square_ibo.cache.request_block(size),
'ibo': self.__square_ibo
}
dataset['indx']['idx'] = dataset['vrtx'].indices
return dataset
def free_finalizer(self, dataset: dict):
"""
automatically release blocks when blocks dict looses shape
:param dataset:
:return:
"""
# for gc being late
if dataset:
if dataset['vrtx']:
dataset['vrtx'].release()
if dataset['indx']:
dataset['indx'].release()
dataset.clear()
def render(self):
self.__vbo.push_cache()
self.__render_square()
self.__render_triangle()
self.__render_circle()
def __render_square(self):
if not self.__square_ibo.cache.active_size:
return
with self.__square_vao:
with self.__square_prgrm:
# update uniforms
camera = get_current_ogl(
).manager.window.devices.cameras.current
self.__square_prgrm.uniforms['PM'] = camera.body.PM
self.__square_prgrm.uniforms['VM'] = camera.tripod.VM
self.__square_prgrm.uniforms['MM'] = [[1, 0, 0,
0], [0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
self.__square_prgrm.push_uniforms()
self.__square_ibo.push_cache()
# mode, count, type, indices
gl.glDrawElements(gl.GL_POINTS,
self.__square_ibo.cache.active_size,
self.__square_ibo.cache.gldtype[0],
ctypes.c_void_p(0))
def __render_circle(self):
if not self.__circle_ibo.cache.active_size:
return
with self.__circle_vao:
with self.__circle_prgrm:
# update uniforms
camera = get_current_ogl(
).manager.window.devices.cameras.current
self.__circle_prgrm.uniforms['PM'] = camera.body.PM
self.__circle_prgrm.uniforms['VM'] = camera.tripod.VM
self.__circle_prgrm.uniforms['MM'] = [[1, 0, 0,
0], [0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
pane = get_current_ogl().manager.window.devices.panes.current
self.__circle_prgrm.uniforms[
'VPP'] = *pane.pos.xy, *pane.size.xy
self.__circle_prgrm.push_uniforms()
self.__circle_ibo.push_cache()
gl.glDrawElements(gl.GL_POINTS,
self.__circle_ibo.cache.active_size,
self.__circle_ibo.cache.gldtype[0],
ctypes.c_void_p(0))
def __render_triangle(self):
if not self.__triangle_ibo.cache.active_size:
return
with self.__triangle_vao:
with self.__triangle_prgrm:
# update uniforms
camera = get_current_ogl(
).manager.window.devices.cameras.current
self.__triangle_prgrm.uniforms['PM'] = camera.body.PM
self.__triangle_prgrm.uniforms['VM'] = camera.tripod.VM
self.__triangle_prgrm.uniforms['MM'] = [[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
self.__triangle_prgrm.push_uniforms()
self.__triangle_ibo.push_cache()
gl.glDrawElements(gl.GL_POINTS,
self.__triangle_ibo.cache.active_size,
self.__triangle_ibo.cache.gldtype[0],
ctypes.c_void_p(0))
class LineRenderer(Renderer):
"""
prgrm parameter layout:
! programs should follow fixed attribute locations
layout (location = 0) in vec4 vtx;
layout (location = 1) in float thk;
layout (location = 2) in vec4 clr;
... add more to expand render possibility
:param self.__sharp_prgrm: program drawing thick sharp line
:param self.__trnsf_ufrm_cache: buffer cache of transformation matrices
"""
__sharp_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(os.path.dirname(__file__),
'shaders/linSharp_vrtx_shdr.glsl'),
geom_path=os.path.join(os.path.dirname(__file__),
'shaders/linSharp_geom_shdr.glsl'),
frgm_path=os.path.join(os.path.dirname(__file__),
'shaders/linSharp_frgm_shdr.glsl'))
def __init__(self):
super().__init__()
self.__vbo = self.__sharp_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__ibo = meta.MetaIndxBffr(dtype='uint')
self.__vao = meta.MetaVrtxArry(self.__vbo, indx_bffr=self.__ibo)
def create_dataset(self, size):
dataset = {
'vrtx': self.__vbo.cache.request_block(size),
'indx': self.__ibo.cache.request_block(size)
}
dataset['indx']['idx'] = dataset['vrtx'].indices
return dataset
def free_finalizer(self, dataset):
if dataset:
for v in dataset.values():
v.release()
dataset.clear()
def update_cache(self, shape, arg_name, value):
self.datasets[shape]['vrtx'][arg_name] = value
def render(self):
self.__vbo.push_cache()
self.__render_sharp()
def __render_sharp(self):
if not self.__ibo.cache.active_size:
return
with self.__vao:
with self.__sharp_prgrm:
camera = get_current_ogl(
).manager.window.devices.cameras.current
self.__sharp_prgrm.uniforms['VM'] = camera.tripod.VM
self.__sharp_prgrm.uniforms['PM'] = camera.body.PM
self.__sharp_prgrm.uniforms['MM'] = [[1, 0, 0,
0], [0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
self.__sharp_prgrm.push_uniforms()
self.__ibo.push_cache()
gl.glDrawElements(gl.GL_LINES, self.__ibo.cache.active_size,
self.__ibo.cache.gldtype[0],
ctypes.c_void_p(0))
class FrameRenderer:
# program for drawing quad
__THIS_PATH = os.path.dirname(__file__)
__quad_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(__THIS_PATH, 'quad_vrtx_shdr.glsl'),
frgm_path=os.path.join(__THIS_PATH, 'quad_frgm_shdr.glsl'))
__pane_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(__THIS_PATH, 'pane_vrtx_shdr.glsl'),
frgm_path=os.path.join(__THIS_PATH, 'pane_frgm_shdr.glsl'))
__pane_depth_prgrm = meta.MetaPrgrm(
vrtx_path=os.path.join(__THIS_PATH, 'pane_vrtx_shdr.glsl'),
frgm_path=os.path.join(__THIS_PATH, 'pane_depth_frgm_shdr.glsl'))
def __init__(self):
# quad set
self.__quad_vbo = self.__quad_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__quad_block = self.__quad_vbo.cache.request_block(size=4)
self.__quad_block['tex_coord'] = (0, 0), (1, 0), (1, 1), (0, 1)
self.__quad_vao = meta.MetaVrtxArry(self.__quad_vbo)
# pane set
self.__pane_vbo = self.__pane_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__pane_block = self.__pane_vbo.cache.request_block(size=4)
self.__pane_block['tex_coord'] = (0, 0), (1, 0), (1, 1), (0, 1)
self.__pane_vao = meta.MetaVrtxArry(self.__pane_vbo)
# pane depth set
self.__pane_depth_vbo = self.__pane_depth_prgrm.vrtx_attr_schema.create_vrtx_bffr(
)
self.__pane_depth_block = self.__pane_depth_vbo.cache.request_block(
size=4)
self.__pane_depth_block['tex_coord'] = (0, 0), (1, 0), (1, 1), (0, 1)
self.__pane_depth_vao = meta.MetaVrtxArry(self.__pane_depth_vbo)
def render_pane_space(self, texture, txtr_domain, pane_domain, pane_z):
"""
render frame's given attachment on pane space
:param texture: render source
:param pdomain_x: (-1.~1., -1.~1.), pane space x domain
:param pdomain_y: (-1.~1., -1.~1.), pane space y domain
:param pane_z: -1.~1., pane space z value, -1 closest
:param tdomain_x: (float, float), texture space x domain
:param tdomain_y: (float, float), texture space y domain
:return:
"""
# update
xs, xe, ys, ye = txtr_domain
self.__pane_block['tex_coord'] = (xs, ys), (xe, ys), (xe, ye), (xs, ye)
xs, xe, ys, ye = pane_domain
self.__pane_block['coord'] = (xs, ys,
pane_z), (xe, ys,
pane_z), (xe, ye,
pane_z), (xs, ye,
pane_z)
self.__pane_vbo.push_cache()
# render
with texture:
with self.__pane_vao:
with self.__pane_prgrm:
gl.glDrawArrays(gl.GL_QUADS, 0, 4)
def render_pane_space_depth(self, color_txtr, depth_txtr, txtr_domain,
pane_domain):
# update
xs, xe, ys, ye = txtr_domain
self.__pane_depth_block['tex_coord'] = (xs, ys), (xe, ys), (xe,
ye), (xs,
ye)
xs, xe, ys, ye = pane_domain
self.__pane_depth_block['coord'] = (xs, ys, 0), (xe, ys,
0), (xe, ye,
0), (xs, ye, 0)
self.__pane_depth_vbo.push_cache()
with color_txtr.as_unit(0), depth_txtr.as_unit(
1): # using texture as unit 0, 1
with self.__pane_depth_vao:
with self.__pane_depth_prgrm:
# update uniforms
self.__pane_depth_prgrm.uniforms['myTexture'] = 0
self.__pane_depth_prgrm.uniforms['myDepth'] = 1
self.__pane_depth_prgrm.push_uniforms()
gl.glDrawArrays(gl.GL_QUADS, 0, 4)
def render_world_space(self, texture, quad_pos, domain_x, domain_y):
# update vrtx attributes
(xs, xe), (ys, ye) = domain_x, domain_y
self.__quad_block['tex_coord'] = (xs, ys), (xe, ys), (xe, ye), (xs, ye)
self.__quad_block['coord'] = quad_pos
self.__quad_vbo.push_cache()
# render
with texture:
with self.__quad_vao:
with self.__quad_prgrm:
# update uniforms
camera = get_current_ogl(
).manager.window.devices.cameras.current
self.__quad_prgrm.uniforms['PM'] = camera.body.PM
self.__quad_prgrm.uniforms['VM'] = camera.tripod.VM
self.__quad_prgrm.uniforms['MM'] = [[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
self.__quad_prgrm.push_uniforms()
gl.glDrawArrays(gl.GL_QUADS, 0, 4)
class PolygonRenderer(Renderer):
__fill_prgrm = meta.MetaPrgrm(
vrtx_path=get_shader_fullpath('shaders/pgon/pgonFill_vrtx_shdr.glsl'),
frgm_path=get_shader_fullpath('shaders/pgon/pgonFill_frgm_shdr.glsl'))
__edge_prgrm = meta.MetaPrgrm(
vrtx_path=get_shader_fullpath(
'shaders/pgon/pgonSharpEdge_vrtx_shdr.glsl'),
geom_path=get_shader_fullpath(
'shaders/pgon/pgonSharpEdge_geom_shdr.glsl'),
frgm_path=get_shader_fullpath(
'shaders/pgon/pgonSharpEdge_frgm_shdr.glsl'))
def __init__(self):
super().__init__()
self.__vbo = self.__fill_prgrm.vrtx_attr_schema.create_vrtx_bffr()
self.__fill_ibo = meta.MetaIndxBffr(dtype='uint')
self.__fill_vao = meta.MetaVrtxArry(self.__vbo,
indx_bffr=self.__fill_ibo)
self.__edge_ibo = meta.MetaIndxBffr(dtype='uint')
self.__edge_vao = meta.MetaVrtxArry(self.__vbo,
indx_bffr=self.__edge_ibo)
def create_dataset(self, size):
return {
'vrtx': self.__vbo.cache.request_block(size),
'fill_indxs': None,
'edge_indxs': None
}
def free_finalizer(self, dataset):
if dataset:
for block in dataset.values():
block.release()
dataset.clear()
def update_cache(self, shape, arg_name, value):
dataset = self.datasets[shape]
if arg_name == 'fill_indxs':
offset = dataset['vrtx'].indices[0]
ib = self.__fill_ibo.cache.request_block(size=len(value) + 1)
ib['idx', :-1] = [offset + i if i != PRV else PRV for i in value]
ib['idx', -1] = PRV
dataset[arg_name] = ib
elif arg_name == 'edge_indxs':
offset = dataset['vrtx'].indices[0]
ib = self.__edge_ibo.cache.request_block(size=len(value) + 1)
ib['idx', :-1] = [offset + i for i in value]
ib['idx', -1] = PRV
dataset[arg_name] = ib
else:
print(arg_name, value)
self.datasets[shape]['vrtx'][arg_name] = value
def render(self):
self.__vbo.push_cache()
self.__render_fill()
self.__render_edge()
def __update_umiforms(self, prgrm):
camera = get_current_ogl().manager.window.devices.cameras.current
prgrm.uniforms['PM'] = camera.body.PM
prgrm.uniforms['VM'] = camera.tripod.VM
prgrm.uniforms['MM'] = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]]
prgrm.push_uniforms()
def __render_fill(self):
self.__fill_ibo.push_cache()
with self.__fill_vao:
with self.__fill_prgrm as prgrm:
self.__update_umiforms(prgrm)
gl.glDrawElements(gl.GL_QUAD_STRIP,
self.__fill_ibo.cache.active_size,
self.__fill_ibo.cache.gldtype[0],
ct.c_void_p(0))
def __render_edge(self):
self.__edge_ibo.push_cache()
with self.__edge_vao:
with self.__edge_prgrm as prgrm:
self.__update_umiforms(prgrm)
gl.glDrawElements(gl.GL_LINE_STRIP_ADJACENCY,
self.__edge_ibo.cache.active_size,
self.__edge_ibo.cache.gldtype[0],
ct.c_void_p(0))
