def useAdditiveBlending(self, enable):
if enable:
gloo.set_blend_func('one', 'one')
gloo.set_blend_equation('func_add')
gloo.set_state(depth_test=False, blend=True)
else:
gloo.set_state(depth_test=True, blend=False)
def on_draw(self, event):
""" canvas update callback """
# config
gloo.clear(color=C0)
gloo.set_state(preset=None,
depth_test=True,
blend=True,
depth_mask=False)
# draw framebuffers
# pass 0
self.quads['u_pass'] = 0.0
self.framebuffer.color_buffer = self.accum
self.framebuffer.activate()
gloo.clear(color=(0, 0, 0, 0))
gloo.set_blend_func('one', 'one')
self.quads.draw('triangles', self.indices)
self.framebuffer.deactivate()
# pass 1
self.quads['u_pass'] = 1.0
self.framebuffer.color_buffer = self.reveal
self.framebuffer.activate()
gloo.clear(color=(1, 1, 1, 1))
gloo.set_blend_func('zero', 'one_minus_src_color')
self.quads.draw('triangles', self.indices)
self.framebuffer.deactivate()
# render
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
self.post.draw('triangles', self.indices)
def __init__(self, mesh, vertexShader, fragShader):
app.Canvas.__init__(self, keys='interactive', size=(1600, 900))
self.mesh = mesh
self.data = mesh.buildBuffer()
self.program = gloo.Program(vertexShader, fragShader)
self.model = np.eye(4, dtype=np.float32)
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
1.0, 1000.0)
gloo.set_viewport(0, 0, self.size[0], self.size[1])
self.camera = camera.Camera(np.array([0, 0, -5], dtype=np.float32),
np.array([0, 0, 0], dtype=np.float32),
45.0, self.size)
self.view = self.camera.view
self.program.bind(gloo.VertexBuffer(mesh.buildBuffer()))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.program['u_projection'] = self.projection
self.program['u_lightPos'] = np.array([20, 20, -20], dtype=np.float32)
self.program['u_lightColor'] = np.array([1, 1, 1], dtype=np.float32)
gloo.set_depth_mask(True)
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
gloo.set_blend_equation('func_add')
gloo.set_cull_face('back')
gloo.set_front_face('cw')
gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)
self.show()
self.theta = 0
self.phi = 0
def __init__(self, mesh, vertexShader, fragShader):
app.Canvas.__init__(self, keys='interactive', size=(1600,900))
self.mesh = mesh
self.data = mesh.buildBuffer()
self.program = gloo.Program(vertexShader, fragShader)
self.model = np.eye(4, dtype=np.float32)
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 1.0, 1000.0)
gloo.set_viewport(0, 0, self.size[0], self.size[1])
self.camera = camera.Camera(np.array([0,0,-5], dtype = np.float32), np.array([0,0,0], dtype = np.float32), 45.0, self.size)
self.view = self.camera.view
self.program.bind(gloo.VertexBuffer(mesh.buildBuffer()))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.program['u_projection'] = self.projection
self.program['u_lightPos'] = np.array([20, 20, -20], dtype = np.float32);
self.program['u_lightColor'] = np.array([1, 1, 1], dtype = np.float32);
gloo.set_depth_mask(True)
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
gloo.set_blend_equation('func_add')
gloo.set_cull_face('back')
gloo.set_front_face('cw')
gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)
self.show()
self.theta = 0
self.phi = 0
def on_draw(self, *args, **kwargs):
self.set_current()
clear_color = (1, 1, 1, 1)
gloo.set_depth_func('lequal')
if 'additive_rendering' in self._scene.enabled_features:
config = self._scene.get_feature_config('additive_rendering')
if config.get('invert', False):
clear_color = (1, 1, 1, 1)
gloo.set_state(preset='additive',
depth_test=False,
blend=True,
depth_mask=False)
gloo.set_blend_func('one', 'one', 'zero', 'one')
gloo.set_blend_equation('func_reverse_subtract')
else:
clear_color = (0, 0, 0, 1)
gloo.set_state(preset='additive',
depth_test=False,
blend=True,
depth_mask=False)
gloo.set_blend_func('one', 'one')
gloo.set_blend_equation('func_add')
else:
gloo.set_state(preset='opaque',
depth_test=True,
blend=True,
depth_mask=True)
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
gloo.clear(color=clear_color, depth=True)
if 'translucency' in self._scene.enabled_features:
with self._fbos['translucency_opaque']:
gloo.clear(color=clear_color)
for prim in self._scene._primitives:
prim.render_translucency(pass_=-1)
with self._fbos['translucency_accum']:
gloo.clear(color=(0, 0, 0, 0), depth=False)
gloo.set_state(preset=None,
depth_test=True,
blend=True,
depth_mask=False)
gloo.set_blend_func('one', 'one')
# Pass 1
for prim in self._scene._primitives:
prim.render_translucency(pass_=1)
with self._fbos['translucency_reveal']:
gloo.clear(color=(1, 1, 1, 1), depth=False)
gloo.set_blend_func('zero', 'one_minus_src_alpha')
# Pass 2
for prim in self._scene._primitives:
prim.render_translucency(pass_=2)
# Final compositing
gloo.set_state(preset='opaque',
depth_test=False,
blend=False,
depth_mask=False)
with self._final_render_target:
self._programs['translucency_post'].draw('triangle_strip')
elif 'outlines' in self._scene.enabled_features:
gloo.set_state(preset='opaque',
depth_test=True,
blend=False,
depth_mask=True)
with self._fbos['outlines_color']:
gloo.clear(color=True, depth=True)
for prim in self._scene._primitives:
prim.render_color()
with self._fbos['outlines_plane']:
gloo.clear(color=True, depth=True)
for prim in self._scene._primitives:
prim.render_planes()
with self._final_render_target:
gloo.clear(color=True, depth=True)
self._programs['outlines_post']['camera'] = prim.camera
self._programs['outlines_post'].draw('triangle_strip')
elif 'render_normals' in self._scene.enabled_features:
with self._final_render_target:
gloo.clear(color=True, depth=True)
for prim in self._scene._primitives:
prim.render_normals()
else:
with self._final_render_target:
gloo.clear(color=clear_color, depth=True)
for prim in self._scene._primitives:
prim.render_color()
if 'ssao' in self._scene.enabled_features:
with self._fbos['ssao_plane']:
gloo.set_state(preset='opaque',
depth_test=True,
blend=False,
depth_mask=True)
gloo.clear(color=True, depth=True)
for prim in self._scene._primitives:
prim.render_positions()
gloo.set_state(preset='opaque',
depth_test=False,
blend=False,
depth_mask=False)
if 'fxaa' in self._scene.enabled_features:
with self._fbos['fxaa_target']:
self._programs['ssao_post'].draw('triangle_strip')
else:
self._programs['ssao_post'].draw('triangle_strip')
if 'fxaa' in self._scene.enabled_features:
gloo.set_state(preset='opaque',
depth_test=False,
blend=False,
depth_mask=False)
self._programs['fxaa_post'].draw('triangle_strip')
def render_with_gloo(draw_data):
"""draw ImGui's drawlists with vispy's gloo interface
Parameters
----------
draw_data: ImDrawData
"""
global device_objects
# adapted from imgui_impl_ios.cpp in imgui, to target the minimal GLES API
d = pymgui.ImDrawData(draw_data)
io = pymgui.get_io()
fb_scale = io.display_framebuffer_scale
fb_width, fb_height = io.display_size
if fb_width == 0 or fb_height == 0:
return
conf = gloo.get_gl_configuration()
# backup GL state
last_program = gl.glGetParameter(gl.GL_CURRENT_PROGRAM)
last_texture = gl.glGetParameter(gl.GL_TEXTURE_BINDING_2D)
last_array_buffer = gl.glGetParameter(gl.GL_ARRAY_BUFFER_BINDING)
last_element_array_buffer = gl.glGetParameter(gl.GL_ELEMENT_ARRAY_BUFFER_BINDING)
last_viewport = gl.glGetParameter(gl.GL_VIEWPORT)
last_enable_blend = gl.glIsEnabled(gl.GL_BLEND),
last_blend_equation = gl.glGetParameter(gl.GL_BLEND_EQUATION_RGB),
last_blend_func = dict(
last_blend_equation_alpha=gl.glGetParameter(gl.GL_BLEND_EQUATION_ALPHA),
)
last_gl_states = dict(
cull_face = gl.glIsEnabled(gl.GL_CULL_FACE),
depth_test = gl.glIsEnabled(gl.GL_DEPTH_TEST),
scissor_test = gl.glIsEnabled(gl.GL_SCISSOR_TEST))
gloo.set_state(blend=True)
gloo.set_blend_equation('func_add')
gloo.set_blend_func(salpha='src_alpha', dalpha='one_minus_src_alpha')
gloo.set_state(cull_face=False, depth_test=False, scissor_test=True)
gl.glActiveTexture(gl.GL_TEXTURE0)
# Setup viewport, orthographic projection matrix
gloo.set_viewport(0, 0, int(fb_width), int(fb_height))
p = device_objects['program'] # type: gloo.Program
ortho_projection = np.array([
[2./fb_width, 0, 0, 0],
[0., 2./-fb_height, 0, 0],
[0., 0., -1., 0],
[-1., 1., 0, 0]
])
vtype = [('a_position', np.float32, 2),
('a_uv', np.float32, 2),
# ('a_color', np.uint8, 4)]
('a_color', np.uint32, 1)]
# pos_dtype = [('a_position', np.float32, 2)]
# uv_dtype = [('a_uv', np.float32, 2)]
# color_dtype = [('a_color', np.uint8, 4)]
itype = np.uint16
display_scale = 1.0
p['u_mvp'] = ortho_projection
# print("draw {} cmd_list".format(len(d.cmd_lists)))
for cmd_list in d.cmd_lists:
vertex_count =C.ImDrawList_GetVertexBufferSize(cmd_list)
index_count = C.ImDrawList_GetIndexBufferSize(cmd_list)
vertex_buffer_ptr = C.ImDrawList_GetVertexPtr(cmd_list, 0)
index_buffer_ptr = C.ImDrawList_GetIndexPtr(cmd_list, 0)
def to_nparray(ptr, item_count, dtype):
byte_count = item_count * dtype.itemsize
as_bytes = ffi.buffer(ptr, byte_count)
return np.frombuffer(as_bytes, dtype=dtype)
ig_vertices = to_nparray(vertex_buffer_ptr, vertex_count, np.dtype(vtype))
ig_indices = to_nparray(index_buffer_ptr, index_count, np.dtype(itype))
# print("{} vertices to draw".format(len(ig_vertices)))
#
p['a_position'] = ig_vertices[:]
# p['a_uv'] = ig_vertices['a_uv']
# p['a_color'] = ig_vertices['a_color']
# device_objects['geometry'] = ig_vertices
#
# gl.glBufferData(gl.GL_ARRAY_BUFFER, ig_vertices, gl.GL_STREAM_DRAW)
# gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indices, gl.GL_STREAM_DRAW)
#
# index_buffer_offset = 0
# cmd_size = C.ImDrawList_GetCmdSize(cmd_list)
# for cmd_index in range(cmd_size):
# draw_cmd_ptr = C.ImDrawList_GetCmdPtr(cmd_list, cmd_index)
# draw_cmd = pymgui.ImDrawCmd(draw_cmd_ptr)
#
# if draw_cmd.texture_id:
# gl.glBindTexture(gl.GL_TEXTURE_2D, draw_cmd.texture_id)
# x1, y1, x2, y2 = draw_cmd.clip_rect
#
# gl.glScissor(
# x=int(x1 * display_scale),
# y=int(y1 * display_scale),
# width=int((x2 - x1) * display_scale),
# height=int((y2 - y1) * display_scale)
# )
#
# start, stop = index_buffer_offset, draw_cmd.elem_count
# # gl.glDrawElements(gl.GL_TRIANGLES, draw_cmd.elem_count, gl.GL_UNSIGNED_SHORT, indices[index_buffer_offset:])
# p.draw('triangles', gloo.IndexBuffer(ig_indices[start:stop]))
# index_buffer_offset += draw_cmd.elem_count
#
# # Restore modified state
gloo.set_state(**last_gl_states)
gloo.set_state(blend=last_enable_blend)
# gloo.set_blend_equation(last_blend_equation)
# # gl.glBindVertexArray(0)
# gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glUseProgram(last_program)
[0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]])
# Create a canvas with a 3D viewport
canvas = scene.SceneCanvas(keys='interactive', bgcolor=(1, 1, 1))
view = canvas.central_widget.add_view()
## Define a scalar field from which we will generate an isosurface
print("Generating scalar field..")
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
surface1 = scene.visuals.Isosurface(c2, level=c.max() / 4., color=(0.5, 0.5, 1),
shading='smooth',
parent=view.scene)
surface1.transform = scene.transforms.STTransform(translate=(-2, -2, -2))
surface2 = scene.visuals.Mesh(None, mode='lines')
# Add a 3D axis to keep us oriented
axis = scene.visuals.XYZAxis(parent=view.scene)
# Use a 3D camera
# Manual bounds; Mesh visual does not provide bounds yet
# Note how you can set bounds before assigning the camera to the viewbox
def render_with_gloo(draw_data):
"""draw ImGui's drawlists with vispy's gloo interface
Parameters
----------
draw_data: ImDrawData
"""
global device_objects
# adapted from imgui_impl_ios.cpp in imgui, to target the minimal GLES API
d = pymgui.ImDrawData(draw_data)
io = pymgui.get_io()
fb_scale = io.display_framebuffer_scale
fb_width, fb_height = io.display_size
if fb_width == 0 or fb_height == 0:
return
conf = gloo.get_gl_configuration()
# backup GL state
last_program = gl.glGetParameter(gl.GL_CURRENT_PROGRAM)
last_texture = gl.glGetParameter(gl.GL_TEXTURE_BINDING_2D)
last_array_buffer = gl.glGetParameter(gl.GL_ARRAY_BUFFER_BINDING)
last_element_array_buffer = gl.glGetParameter(
gl.GL_ELEMENT_ARRAY_BUFFER_BINDING)
last_viewport = gl.glGetParameter(gl.GL_VIEWPORT)
last_enable_blend = gl.glIsEnabled(gl.GL_BLEND),
last_blend_equation = gl.glGetParameter(gl.GL_BLEND_EQUATION_RGB),
last_blend_func = dict(last_blend_equation_alpha=gl.glGetParameter(
gl.GL_BLEND_EQUATION_ALPHA), )
last_gl_states = dict(cull_face=gl.glIsEnabled(gl.GL_CULL_FACE),
depth_test=gl.glIsEnabled(gl.GL_DEPTH_TEST),
scissor_test=gl.glIsEnabled(gl.GL_SCISSOR_TEST))
gloo.set_state(blend=True)
gloo.set_blend_equation('func_add')
gloo.set_blend_func(salpha='src_alpha', dalpha='one_minus_src_alpha')
gloo.set_state(cull_face=False, depth_test=False, scissor_test=True)
gl.glActiveTexture(gl.GL_TEXTURE0)
# Setup viewport, orthographic projection matrix
gloo.set_viewport(0, 0, int(fb_width), int(fb_height))
p = device_objects['program'] # type: gloo.Program
ortho_projection = np.array([[2. / fb_width, 0, 0, 0],
[0., 2. / -fb_height, 0, 0], [0., 0., -1., 0],
[-1., 1., 0, 0]])
vtype = [
('a_position', np.float32, 2),
('a_uv', np.float32, 2),
# ('a_color', np.uint8, 4)]
('a_color', np.uint32, 1)
]
# pos_dtype = [('a_position', np.float32, 2)]
# uv_dtype = [('a_uv', np.float32, 2)]
# color_dtype = [('a_color', np.uint8, 4)]
itype = np.uint16
display_scale = 1.0
p['u_mvp'] = ortho_projection
# print("draw {} cmd_list".format(len(d.cmd_lists)))
for cmd_list in d.cmd_lists:
vertex_count = C.ImDrawList_GetVertexBufferSize(cmd_list)
index_count = C.ImDrawList_GetIndexBufferSize(cmd_list)
vertex_buffer_ptr = C.ImDrawList_GetVertexPtr(cmd_list, 0)
index_buffer_ptr = C.ImDrawList_GetIndexPtr(cmd_list, 0)
def to_nparray(ptr, item_count, dtype):
byte_count = item_count * dtype.itemsize
as_bytes = ffi.buffer(ptr, byte_count)
return np.frombuffer(as_bytes, dtype=dtype)
ig_vertices = to_nparray(vertex_buffer_ptr, vertex_count,
np.dtype(vtype))
ig_indices = to_nparray(index_buffer_ptr, index_count, np.dtype(itype))
# print("{} vertices to draw".format(len(ig_vertices)))
#
p['a_position'] = ig_vertices[:]
# p['a_uv'] = ig_vertices['a_uv']
# p['a_color'] = ig_vertices['a_color']
# device_objects['geometry'] = ig_vertices
#
# gl.glBufferData(gl.GL_ARRAY_BUFFER, ig_vertices, gl.GL_STREAM_DRAW)
# gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indices, gl.GL_STREAM_DRAW)
#
# index_buffer_offset = 0
# cmd_size = C.ImDrawList_GetCmdSize(cmd_list)
# for cmd_index in range(cmd_size):
# draw_cmd_ptr = C.ImDrawList_GetCmdPtr(cmd_list, cmd_index)
# draw_cmd = pymgui.ImDrawCmd(draw_cmd_ptr)
#
# if draw_cmd.texture_id:
# gl.glBindTexture(gl.GL_TEXTURE_2D, draw_cmd.texture_id)
# x1, y1, x2, y2 = draw_cmd.clip_rect
#
# gl.glScissor(
# x=int(x1 * display_scale),
# y=int(y1 * display_scale),
# width=int((x2 - x1) * display_scale),
# height=int((y2 - y1) * display_scale)
# )
#
# start, stop = index_buffer_offset, draw_cmd.elem_count
# # gl.glDrawElements(gl.GL_TRIANGLES, draw_cmd.elem_count, gl.GL_UNSIGNED_SHORT, indices[index_buffer_offset:])
# p.draw('triangles', gloo.IndexBuffer(ig_indices[start:stop]))
# index_buffer_offset += draw_cmd.elem_count
#
# # Restore modified state
gloo.set_state(**last_gl_states)
gloo.set_state(blend=last_enable_blend)
# gloo.set_blend_equation(last_blend_equation)
# # gl.glBindVertexArray(0)
# gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glUseProgram(last_program)
