def on_draw(dt):
global phi, theta, time
time += dt
window.clear()
surface['data']
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
surface["color"] = 1, 1, 1, 1
surface.draw(gl.GL_TRIANGLES, s_indices)
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
surface["color"] = 0, 0, 0, 1
surface.draw(gl.GL_LINE_LOOP, b_indices)
gl.glDepthMask(gl.GL_TRUE)
model = surface['transform']['model'].reshape(4, 4)
view = surface['transform']['view'].reshape(4, 4)
surface['view'] = view
surface['model'] = model
surface['normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
def on_draw(dt):
window.clear(color=C0)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
# Pass 1: accumulation
quads["pass"] = 0
framebuffer.color = accumulation
framebuffer.activate()
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
window.clear(color=(0, 0, 0, 0))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Pass 2: revealage
quads["pass"] = 1
framebuffer.color = revealage
framebuffer.activate()
gl.glBlendFunc(gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_COLOR)
window.clear(color=(1, 1, 1, 1))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
global phi, theta, time
time += dt
window.clear()
surface['data']
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
surface["color"] = 1,1,1,1
surface.draw(gl.GL_TRIANGLES, s_indices)
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
surface["color"] = 0,0,0,1
surface.draw(gl.GL_LINE_LOOP, b_indices)
gl.glDepthMask(gl.GL_TRUE)
model = surface['transform']['model'].reshape(4,4)
view = surface['transform']['view'].reshape(4,4)
surface['view'] = view
surface['model'] = model
surface['normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
def on_draw(dt):
# index
global k
V["a_position"][:-8, :] = deforms[k]
program['u_model'] = mats[k]
k = (k + 1) % n_deforms
window.clear()
# mesh
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
program['u_color'] = 1, 1, 1, 1
program.draw(gl.GL_TRIANGLES, tri_idx)
# bb
if args.no_rigid:
program.draw(gl.GL_LINES, bb_idx)
# outlines
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
program['u_color'] = 0, 0, 0, 1
program.draw(gl.GL_LINES, edge_idx)
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
# Clear depth and color buffers
gl.glClearColor(*C0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Opaque objects rendering
gl.glDepthMask(gl.GL_TRUE)
gl.glDisable(gl.GL_BLEND)
# Transparent objects rendering
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
framebuffer.activate()
gl.glClearColor(0,0,0,1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
window.clear(color=(0,0,0,1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE,
gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_ALPHA)
scene.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
compose.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear(color=C0)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
# Pass 1: accumulation
quads["pass"] = 0
framebuffer.color = accumulation
framebuffer.activate()
gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE)
window.clear(color=(0,0,0,0))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Pass 2: revealage
quads["pass"] = 1
framebuffer.color = revealage
framebuffer.activate()
gl.glBlendFunc(gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_COLOR)
window.clear(color=(1,1,1,1))
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
global phi, theta, duration
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, I)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, O)
gl.glDepthMask(gl.GL_TRUE)
# Rotate cube
theta += 1.0 # degrees
phi += -1.0 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['u_model'] = model
def on_draw(dt):
# Clear depth and color buffers
gl.glClearColor(*C0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Opaque objects rendering
gl.glDepthMask(gl.GL_TRUE)
gl.glDisable(gl.GL_BLEND)
# Transparent objects rendering
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
framebuffer.activate()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
window.clear(color=(0, 0, 0, 1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE, gl.GL_ZERO,
gl.GL_ONE_MINUS_SRC_ALPHA)
scene.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
compose.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
global phi, theta
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
transform['model'] = model
def on_draw(dt):
global phi, theta, duration
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, I)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, O)
gl.glDepthMask(gl.GL_TRUE)
# Rotate cube
theta += 0.5 # degrees
phi += 0.5 # degrees
view = cube['u_view'].reshape(4,4)
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['u_model'] = model
cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
def on_draw(dt):
global phi, theta
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
def on_draw(dt):
global phi, theta, duration
window.clear()
gl.glDepthMask(gl.GL_FALSE)
spiral.draw(gl.GL_TRIANGLE_STRIP)
theta += 1 # degrees
phi += 2 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 1, 0)
glm.rotate(model, phi, 1, 0, 0)
spiral['model'] = model
def on_draw(dt):
window.clear()
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
global phi, theta
# Phi and Theta are the cube rotation paramters
window.clear()
lock.acquire()
try:
# Disable depth of OpenGL to update background tecture
gl.glDisable(gl.GL_DEPTH_TEST)
quad.draw(gl.GL_TRIANGLE_STRIP)
# R-enable depth
gl.glEnable(gl.GL_DEPTH_TEST)
# Color of path
path["u_color"] = 0, 1, 1
# Filled path
path.draw(gl.GL_TRIANGLE_STRIP)
# Mask depth
gl.glDepthMask(gl.GL_FALSE)
# Color of edge lines of path
path["u_color"] = 0, 0, 0
# Width of edge lines
gl.glLineWidth(10.0)
# Draw edge lines with index buffer bline_I
path.draw(gl.GL_LINES, bline_I)
# Reset line width
gl.glLineWidth(1.0)
gl.glDepthMask(gl.GL_TRUE)
# Define the model matrix with updated rotation
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
for obj in bag.values():
obj["u_color"] = 1, 0, 0
# Filled cube
obj.draw(gl.GL_TRIANGLES, I)
# Another method to disable depth, instead of disabling it, mask it
gl.glDepthMask(gl.GL_FALSE)
# Black color for edge lines of cube
obj["u_color"] = 0, 0, 0
# Draw the edge lines with the given index buffer
obj.draw(gl.GL_LINES, O)
# Unmask OpenGL depth aparamter
gl.glDepthMask(gl.GL_TRUE)
# Model matrix is used to define orientation ,in this case, used to rotate cube
obj["model"] = model
# Update cube rotations
theta += 2.0 # degrees
phi += 2.0 # degrees
finally:
lock.release()
def on_draw(dt):
window.clear()
gl.glDepthMask(gl.GL_FALSE)
curve["color"] = 0.75, 0.75, 0.75
curve["thickness"] = 64
curve.draw(gl.GL_TRIANGLE_STRIP)
curve["color"] = 0.0, 0.0, 0.0
curve["thickness"] = 1.5
curve.draw(gl.GL_TRIANGLE_STRIP)
points.draw(gl.GL_POINTS)
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
window.clear()
# Cells
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cells.draw()
# Cell outlines
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
outlines.draw()
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
window.clear()
# Cells
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cells.draw()
# Cell outlines
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
outlines.draw()
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
window.clear(color=C0)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
framebuffer.activate()
window.clear(color=(0, 0, 0, 1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE, gl.GL_ZERO,
gl.GL_ONE_MINUS_SRC_ALPHA)
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear(color=C0)
gl.glDepthMask(gl.GL_FALSE)
gl.glEnable(gl.GL_BLEND)
# Transparent surfaces
framebuffer.activate()
window.clear(color=(0,0,0,1))
gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ONE,
gl.GL_ZERO, gl.GL_ONE_MINUS_SRC_ALPHA)
quads.draw(gl.GL_TRIANGLES, indices)
framebuffer.deactivate()
# Compositing
gl.glBlendFunc(gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
post.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube["u_color"] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube["u_color"] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
def on_draw(dt):
window.clear()
demo_idx = 0
for program_object in self.programs:
program = program_object.program
model = matrix_model(np.copy(program_object.u_model))
#self.deg_x += dt*20
#self.deg_y += dt*40
self.demo_dt += dt/5
demo_idx += 1
'''
if self.demo_dt > 2:
if demo_idx == 1:
if self.demo_dt > 2.4:
if program['alpha'] <= 0.1:
continue
else:
program['alpha'] -= 0.01
elif demo_idx == 2:
if self.demo_dt > 2.8:
program['alpha'] += 0.01
'''
program['u_model'] = np.dot(model, self.u_model)
program['u_view'] = self.u_view
program['u_projection'] = self.u_projection
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.face)
elif program_object.draw_mode == gl.GL_LINES and program_object.name == 'ProgramSFM3DRegion':
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
program.draw(program_object.draw_mode, program_object.O)
gl.glDepthMask(gl.GL_TRUE)
else:
program.draw(program_object.draw_mode)
def on_draw(dt):
# GUI
imguiRenderer.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked, selected = imgui.menu_item("Quit", 'ESC', False, True)
if clicked:
exit(0)
imgui.end_menu()
imgui.end_main_menu_bar()
imgui.begin('Cube')
changed, zoom = imgui.slider_float('zoom', trackball.zoom, 15, 90)
if changed: trackball.zoom = zoom
imgui.end()
imgui.end_frame()
imgui.render()
window.clear()
# Filled cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, faces)
# Outlined cube
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
cube['u_color'] = 0, 0, 0, 1
cube.draw(gl.GL_LINES, outline)
gl.glDepthMask(gl.GL_TRUE)
imguiRenderer.render(imgui.get_draw_data())
def on_draw(dt):
window.clear()
demo_idx = 0
for program_object in self.programs:
program = program_object.program
model = matrix_model(np.copy(program_object.u_model))
#self.deg_x += dt*20
#self.deg_y += dt*40
self.demo_dt += dt/5
demo_idx += 1
'''
if self.demo_dt > 2:
if demo_idx == 1:
if self.demo_dt > 2.4:
if program['alpha'] <= 0.1:
continue
else:
program['alpha'] -= 0.01
elif demo_idx == 2:
if self.demo_dt > 2.8:
program['alpha'] += 0.01
'''
program['u_model'] = np.dot(model, self.u_model)
program['u_view'] = self.u_view
program['u_projection'] = self.u_projection
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.face)
elif program_object.draw_mode == gl.GL_LINES and program_object.name == 'ProgramSFM3DRegion':
gl.glDisable(gl.GL_POLYGON_OFFSET_FILL)
gl.glEnable(gl.GL_BLEND)
gl.glDepthMask(gl.GL_FALSE)
program.draw(program_object.draw_mode, program_object.O)
gl.glDepthMask(gl.GL_TRUE)
else:
program.draw(program_object.draw_mode)
def on_draw(dt):
window.clear()
# Disable color and depth writing
gl.glColorMask(gl.GL_FALSE, gl.GL_FALSE, gl.GL_FALSE, gl.GL_FALSE)
gl.glDepthMask(gl.GL_FALSE)
gl.glStencilFunc(gl.GL_ALWAYS, 0, 0)
# gl.glStencilOp(gl.GL_KEEP, gl.GL_INVERT, gl.GL_INVERT)
gl.glStencilOpSeparate(gl.GL_FRONT, gl.GL_KEEP, gl.GL_KEEP, gl.GL_INCR)
gl.glStencilOpSeparate(gl.GL_BACK, gl.GL_KEEP, gl.GL_KEEP, gl.GL_DECR)
polygon.draw(gl.GL_TRIANGLES, I)
# glStencilFunc(func, ref, mask):
# GL_NEVER: Always fails
# GL_LESS: Passes if ( ref & mask ) < ( stencil & mask )
# GL_LEQUAL: Passes if ( ref & mask ) <= ( stencil & mask )
# GL_GREATER: Passes if ( ref & mask ) > ( stencil & mask )
# GL_GEQUAL: Passes if ( ref & mask ) >= ( stencil & mask )
# GL_EQUAL: Passes if ( ref & mask ) = ( stencil & mask )
# GL_NOTEQUAL: Passes if ( ref & mask ) != ( stencil & mask )
# GL_ALWAYS: Always passes
# Enable color and depth writing
gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
gl.glDepthMask(gl.GL_TRUE)
# odd
gl.glStencilFunc(gl.GL_EQUAL, 0x01, 0x1)
# non zero
# gl.glStencilFunc(gl.GL_NOTEQUAL, 0x00, 0xff)
# positive
# gl.glStencilFunc(gl.GL_LESS, 0x0, 0xff)
gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_KEEP)
polygon.draw(gl.GL_TRIANGLES, I)
def on_draw(dt):
global phi, theta
window.clear()
lock.acquire()
try:
gl.glDisable(gl.GL_DEPTH_TEST)
# try:
# quad['texture'] = cam_img_texture
# except:
# quad['texture'] = cv.imread("/home/rahul/Pictures/GitKraken_001.png")[..., ::-1]
quad.draw(gl.GL_TRIANGLE_STRIP)
gl.glEnable(gl.GL_DEPTH_TEST)
# Filled cube
path["u_color"] = 0, 1, 1
path.draw(gl.GL_TRIANGLE_STRIP)
gl.glDepthMask(gl.GL_FALSE)
path["u_color"] = 0, 0, 0
gl.glLineWidth(7.5)
path.draw(gl.GL_LINES, bline_I)
gl.glLineWidth(1.0)
gl.glDepthMask(gl.GL_TRUE)
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
for obj in bag.values():
obj["u_color"] = 1, 0, 0
obj.draw(gl.GL_TRIANGLES, I)
gl.glDepthMask(gl.GL_FALSE)
obj["u_color"] = 0, 0, 0
obj.draw(gl.GL_LINES, O)
gl.glDepthMask(gl.GL_TRUE)
obj["model"] = model
# cube.draw(gl.GL_TRIANGLES, I)
# Make cube rotate
theta += 2.0 # degrees
phi += 2.0 # degrees
finally:
lock.release()
def draw(self, mode=gl.GL_TRIANGLES):
""" Draw collection """
gl.glDepthMask(gl.GL_FALSE)
Collection.draw(self, mode)
gl.glDepthMask(gl.GL_TRUE)
def draw(self, mode = gl.GL_TRIANGLE_STRIP):
""" Draw collection """
gl.glDepthMask(gl.GL_FALSE)
Collection.draw(self, mode)
gl.glDepthMask(gl.GL_TRUE)
