def rotate(self, ang, rx, ry, rz):
glPushMatrix()
glLoadIdentity()
glRotatef(ang, rx, ry, rz)
glMultMatrixf(self.matrix)
self.matrix = get_model_matrix()
glPopMatrix()
def translate(self, dx, dy, dz):
glPushMatrix()
glLoadIdentity()
glTranslatef(dx, dy, dz)
glMultMatrixf(self.matrix)
self.matrix = get_model_matrix()
glPopMatrix()
def chain(self):
gl.glPushMatrix()
p = self.position
r = self.rotation
gl.glMultMatrixf(
raw(
r[0][0],
r[1][0],
r[2][0],
0.0,
r[0][1],
r[1][1],
r[2][1],
0.0,
r[0][2],
r[1][2],
r[2][2],
0.0,
p[0],
p[1],
p[2],
1.0,
)
)
self.material.apply()
self.render()
self.material.unapply()
for c in self.children:
c.chain()
gl.glPopMatrix()
def set_state(self):
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(self.transform))
if self.texture:
gl.glEnable(self.texture.target)
gl.glBindTexture(self.texture.target, self.texture.id)
def set_state(self):
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(self.transform))
if self.texture:
gl.glEnable(self.texture.target)
gl.glBindTexture(self.texture.target, self.texture.id)
def show_drone(self, position, rotation):
"""
Show the drone 3D model with corresponding translation and rotation.
"""
# Get the transform matrix for drone 3D model
x, z, y = position
transform = np.eye(4)
transform[:3, 3] = [x, y, z]
# NOTE: change the view size of drone 3D model
transform[0, 0] = 2.5
transform[1, 1] = 2.5
transform[2, 2] = 2.5
yaw, pitch, roll = rotation
transform = np.dot(transform, rotation_transform_mat(yaw, 'yaw'))
transform = np.dot(transform, rotation_transform_mat(pitch, 'pitch'))
transform = np.dot(transform, rotation_transform_mat(roll, 'roll'))
# Add a new matrix to the model stack to transform the model
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
# Enable the target texture
if self.drone_texture is not None:
gl.glEnable(self.drone_texture.target)
gl.glBindTexture(self.drone_texture.target, self.drone_texture.id)
# Draw the mesh with its transform applied
self.drone_drawer.draw(mode=self.drone_vertex_list_mode)
gl.glPopMatrix()
# Disable texture after using
if self.drone_texture is not None:
gl.glDisable(self.drone_texture.target)
def draw_world_items(self, glyphs):
'''
Draw all passed glyphs
'''
shader = None
for position, orientation, glyph in glyphs:
gl.glPushMatrix()
gl.glTranslatef(*position)
if orientation and orientation != Orientation.Identity:
gl.glMultMatrixf(orientation.matrix)
if glyph.shader is not shader:
shader = glyph.shader
shader.use()
gl_wrap.glBindVertexArray(glyph.vao)
gl.glDrawElements(
gl.GL_TRIANGLES,
len(glyph.glindices),
glyph.index_type,
glyph.glindices
)
gl.glPopMatrix()
gl_wrap.glBindVertexArray(0)
Shader.unuse()
def translate(self,dx,dy,dz):
glPushMatrix()
glLoadIdentity()
glTranslatef(dx,dy,dz)
glMultMatrixf(self.matrix)
self.matrix=get_model_matrix()
glPopMatrix()
def rotate(self,ang,rx,ry,rz):
glPushMatrix()
glLoadIdentity()
glRotatef(ang,rx,ry,rz)
glMultMatrixf(self.matrix)
self.matrix=get_model_matrix()
glPopMatrix()
def ApplyCameraTransform(self, bRotOnly = False):
m = self.GetCameraOrientation()
# Camera Transform
glMultMatrixf(m)
# If Rotation only, then do not do the translation
if not bRotOnly:
glTranslatef(-self.vOrigin[0], -self.vOrigin[1], -self.vOrigin[2])
def ApplyCameraTransform(self, bRotOnly=False):
m = self.GetCameraOrientation()
# Camera Transform
glMultMatrixf(m)
# If Rotation only, then do not do the translation
if not bRotOnly:
glTranslatef(-self.vOrigin[0], -self.vOrigin[1], -self.vOrigin[2])
def draw(self):
T = self.body.T
mT = T.flatten('F').tolist()[0]
mT = (gl.GLfloat * len(mT))(*mT) # FIXME there is prob a better way...
gl.glMultMatrixf(mT)
if self.collides:
gl.glColor3f(*red)
else:
gl.glColor3f(*self.color)
self.cube.draw()
def draw(self):
T = self.body.T
mT = T.flatten('F').tolist()[0]
mT = (gl.GLfloat * len(mT))(*mT) # FIXME there is prob a better way...
gl.glMultMatrixf(mT)
if self.collides:
gl.glColor3f(*red)
else:
gl.glColor3f(*self.color)
self.cube.draw()
def set_state(self):
self._set_view()
SceneViewer._gl_set_background(self._background)
SceneViewer._gl_enable_depth()
SceneViewer._gl_enable_color_material()
SceneViewer._gl_enable_blending()
SceneViewer._gl_enable_smooth_lines()
SceneViewer._gl_enable_lighting(self.scene)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glPushMatrix()
gl.glLoadIdentity()
gl.glMultMatrixf(
rendering.matrix_to_gl(np.linalg.inv(self.scene.camera.transform)))
def set_state(self):
self._set_view()
SceneViewer._gl_set_background(self._background)
SceneViewer._gl_enable_depth()
SceneViewer._gl_enable_color_material()
SceneViewer._gl_enable_blending()
SceneViewer._gl_enable_smooth_lines()
SceneViewer._gl_enable_lighting(self.scene)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glPushMatrix()
gl.glLoadIdentity()
gl.glMultMatrixf(
rendering.matrix_to_gl(np.linalg.inv(self.scene.camera.transform)))
def show_drone(self, position, rotation):
"""
Show the drone 3D model with corresponding translation and rotation.
"""
# Get the transform matrix for drone 3D model
x, z, y = position
transform = np.eye(4)
transform[:3, 3] = [x, y, z]
# NOTE: change the view size of drone 3D model
transform[0, 0] = 2.5
transform[1, 1] = 2.5
transform[2, 2] = 2.5
# Match drone model space x-y-z to openGL x-z-y
# TODO: read the config.json and match the propeller positions
model_space_transform = rotation_transform_mat(-np.pi / 2, 'roll')
transform = np.dot(transform, model_space_transform)
yaw, pitch, roll = rotation
if self.debug_mode:
# NOTE: manually set values to debug rotation,
# it's useful when input act is in form [c, c, c, c].
yaw = np.pi / 2
# pitch = np.pi / 2
# roll = np.pi / 2
transform = np.dot(transform, rotation_transform_mat(yaw, 'yaw'))
transform = np.dot(transform, rotation_transform_mat(pitch, 'pitch'))
transform = np.dot(transform, rotation_transform_mat(roll, 'roll'))
# Add a new matrix to the model stack to transform the model
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
# Enable the target texture
if self.drone_texture is not None:
gl.glEnable(self.drone_texture.target)
gl.glBindTexture(self.drone_texture.target, self.drone_texture.id)
# Draw the mesh with its transform applied
self.drone_drawer.draw(mode=self.drone_vertex_list_mode)
gl.glPopMatrix()
# Disable texture after using
if self.drone_texture is not None:
gl.glDisable(self.drone_texture.target)
def on_draw(self):
if self._profile:
profiler = self.Profiler()
profiler.start()
self._update_vertex_list()
transform_camera = np.linalg.inv(self._scene.camera_transform)
transform_camera = np.asanyarray(transform_camera, dtype=np.float32)
gl.glMultMatrixf((gl.GLfloat * 16)(*transform_camera.T.ravel()))
node_names = collections.deque(self._scene.graph.nodes_geometry)
while len(node_names) > 0:
current_node = node_names.popleft()
transform, geometry_name = self._scene.graph.get(current_node)
if geometry_name is None:
continue
mesh = self._scene.geometry[geometry_name]
if mesh.is_empty:
continue
mode = self._vertex_list_mode[geometry_name]
if mode == gl.GL_LINES:
# apply the offset in camera space
arrays = [
transform,
np.linalg.inv(transform_camera), self._line_offset,
transform_camera
]
transform = np.linalg.multi_dot(arrays)
gl.glPushMatrix()
transform = np.asanyarray(transform, dtype=np.float32)
transform = (gl.GLfloat * 16)(*transform.T.ravel())
gl.glMultMatrixf(transform)
# draw the mesh with its transform applied
self._vertex_list[geometry_name].draw(mode=mode)
gl.glPopMatrix()
if self._profile:
profiler.stop()
print(profiler.output_text(unicode=True, color=True))
def show_velocity(self, position, velocity, expected_velocity=None):
"""
Show velocity vector as a thin cylinder arrow.
"""
if not hasattr(self, 'drone_velocity_drawer'):
return
transform = self._get_velocity_transform(velocity, position)
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
self.drone_velocity_drawer.draw(mode=self.drone_vertex_list_mode)
gl.glPopMatrix()
if expected_velocity is not None and \
hasattr(self, 'drone_expected_velocity_drawer'):
transform = self._get_velocity_transform(expected_velocity,
position)
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
self.drone_expected_velocity_drawer.draw(
mode=self.drone_vertex_list_mode)
gl.glPopMatrix()
def on_draw(self):
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera, _junk = self.scene.graph['camera']
# apply the camera transform to the matrix stack
gl.glMultMatrixf(_gl_matrix(transform_camera))
# dragging the mouse moves the view transform (but doesn't alter the
# scene)
transform_view = _view_transform(self.view)
gl.glMultMatrixf(_gl_matrix(transform_view))
# we want to render fully opaque objects first,
# followed by objects which have transparency
node_names = collections.deque(self.scene.graph.nodes_geometry)
count_original = len(node_names)
count = -1
while len(node_names) > 0:
count += 1
current_node = node_names.popleft()
# if the flag isn't defined, this will be None
# by checking False explicitly, it makes the default
# behaviour to render meshes with no flag defined.
# if self.node_flag(name_node, 'visible') is False:
# continue
transform, geometry_name = self.scene.graph[current_node]
if geometry_name is None:
continue
mesh = self.scene.geometry[geometry_name]
if (hasattr(mesh, 'visual') and
mesh.visual.transparency):
# put the current item onto the back of the queue
if count < count_original:
node_names.append(current_node)
continue
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(_gl_matrix(transform))
# get the mode of the current geometry
mode = self.vertex_list_mode[geometry_name]
# draw the mesh with its transform applied
self.vertex_list[geometry_name].draw(mode=mode)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
def on_draw(self):
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera = self.scene.transforms['camera']
# apply the camera transform to the matrix stack
gl.glMultMatrixf(_gl_matrix(transform_camera))
# dragging the mouse moves the view transform (but doesn't alter the scene)
transform_view = _view_transform(self.view)
gl.glMultMatrixf(_gl_matrix(transform_view))
# we want to render fully opaque objects first,
# followed by objects which have transparency
items = deque(self.scene.nodes.items())
count_original = len(items)
count = -1
while len(items) > 0:
count += 1
item = items.popleft()
name_node, name_mesh = item
# if the flag isn't defined, this will be None
# by checking False explicitly, it makes the default
# behaviour to render meshes with no flag defined.
if self.node_flag(name_node, 'visible') == False:
continue
if self.scene.meshes[name_mesh].visual.transparency:
# put the current item onto the back of the queue
if count < count_original:
items.append(item)
continue
transform = self.scene.transforms[name_node]
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(_gl_matrix(transform))
# draw the mesh with its transform applied
self.vertex_list[name_mesh].draw(mode=gl.GL_TRIANGLES)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
def on_draw(self):
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera = self.scene.transforms['camera']
# apply the camera transform to the matrix stack
gl.glMultMatrixf(_gl_matrix(transform_camera))
# dragging the mouse moves the view transform (but doesn't alter the scene)
transform_view = _view_transform(self.view)
gl.glMultMatrixf(_gl_matrix(transform_view))
# we want to render fully opaque objects first,
# followed by objects which have transparency
items = deque(self.scene.nodes.items())
count_original = len(items)
count = -1
while len(items) > 0:
count += 1
item = items.popleft()
name_node, name_mesh = item
# if the flag isn't defined, this will be None
# by checking False explicitly, it makes the default
# behaviour to render meshes with no flag defined.
if self.node_flag(name_node, 'visible') == False:
continue
if self.scene.meshes[name_mesh].visual.transparency:
# put the current item onto the back of the queue
if count < count_original:
items.append(item)
continue
transform = self.scene.transforms[name_node]
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(_gl_matrix(transform))
# draw the mesh with its transform applied
self.vertex_list[name_mesh].draw(mode=gl.GL_TRIANGLES)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
x = hmd.headPose.translation.x
y = hmd.headPose.translation.y
z = hmd.headPose.translation.z
# print(x, y, z)
# use OpenGL rendering commands here...
# Just draw a triangle 2 meters away. Let's use the ovrMatrix4f type to
# handle the translation. You can do whatever you like to the position
# every frame.
#
triangle_origin = ovrVector3f(0.0, 0.0, -2.0)
M = ovrMatrix4f.translation(triangle_origin)
GL.glPushMatrix()
GL.glMultMatrixf(M.ctypes) # multiply the scene by the matrix
GL.glBegin(GL.GL_TRIANGLES)
GL.glColor3f(1, 0, 0)
GL.glVertex3f(-1.0, -1.0, 0.0)
GL.glColor3f(0, 1, 0)
GL.glVertex3f(1.0, -1.0, 0.0)
GL.glColor3f(0, 0, 1)
GL.glVertex3f(0.0, 1.0, 0.0)
GL.glEnd()
GL.glPopMatrix()
# send the rendered buffer to the HMD
hmd.flip()
# check if the application should exit
if event.getKeys('q') or hmd.shouldQuit:
def draw(self):
eyex,eyey,eyez,centx,centy,centz,upx,upy,upz=self.lookat
gluLookAt(eyex,eyey,eyez,centx,centy,centz,upx,upy,upz)
glMultMatrixf(self.cam_trans.matrix)
glMultMatrixf(self.cam_rot.matrix)
def glmult(l):
return glMultMatrixf( (GLfloat * len(l))(*l) )
def apply(self, mat):
gl.glMultMatrixf(mat)
def draw(self):
eyex, eyey, eyez, centx, centy, centz, upx, upy, upz = self.lookat
gluLookAt(eyex, eyey, eyez, centx, centy, centz, upx, upy, upz)
glMultMatrixf(self.cam_trans.matrix)
glMultMatrixf(self.cam_rot.matrix)
def premultiply(self, values):
gl.glMultMatrixf(*values)
def ApplyActorTransform(self, bRotationOnly=False):
rotMat = self.GetMatrix(bRotationOnly)
# Apply rotation to the current matrix
glMultMatrixf(rotMat)
def ApplyActorTransform(self, bRotationOnly = False):
rotMat = self.GetMatrix(bRotationOnly)
# Apply rotation to the current matrix
glMultMatrixf(rotMat)
def set_up_matrix(self):
glPushMatrix()
glMultMatrixf(self._model_view_matrix)
def mult_rot_matrix(self, rot):
pgl.glPushMatrix()
pgl.glLoadMatrixf(rot)
pgl.glMultMatrixf(self._rot)
self._rot = get_model_matrix()
pgl.glPopMatrix()
def apply_transformation(self):
pgl.glLoadIdentity()
pgl.glTranslatef(self._x, self._y, -self._dist)
if self._rot is not None:
pgl.glMultMatrixf(self._rot)
pgl.glScalef(*self._get_scale())
def mult_rot_matrix(self, rot):
pgl.glPushMatrix()
pgl.glLoadMatrixf(rot)
pgl.glMultMatrixf(self._rot)
self._rot = get_model_matrix()
pgl.glPopMatrix()
def apply_transformation(self):
pgl.glLoadIdentity()
pgl.glTranslatef(self._x, self._y, -self._dist)
if self._rot is not None:
pgl.glMultMatrixf(self._rot)
pgl.glScalef(*self._get_scale())
def on_draw(self):
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera, _junk = self.scene.graph['camera']
# apply the camera transform to the matrix stack
gl.glMultMatrixf(rendering.matrix_to_gl(transform_camera))
# dragging the mouse moves the view transform
# but doesn't alter the scene
transform_view = view_to_transform(self.view)
gl.glMultMatrixf(rendering.matrix_to_gl(transform_view))
# we want to render fully opaque objects first,
# followed by objects which have transparency
node_names = collections.deque(self.scene.graph.nodes_geometry)
count_original = len(node_names)
count = -1
# if we are rendering an axis marker at the world
if self._axis:
# we stored it as a vertex list
self._axis.draw(mode=gl.GL_TRIANGLES)
while len(node_names) > 0:
count += 1
current_node = node_names.popleft()
# get the transform from world to geometry and mesh name
transform, geometry_name = self.scene.graph[current_node]
# if no geometry at this frame continue without rendering
if geometry_name is None:
continue
# get a reference to the mesh so we can check transparency
mesh = self.scene.geometry[geometry_name]
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
# draw an axis marker for each mesh frame
if self.view['axis'] == 'all':
self._axis.draw(mode=gl.GL_TRIANGLES)
# transparent things must be drawn last
if (hasattr(mesh, 'visual')
and hasattr(mesh.visual, 'transparency')
and mesh.visual.transparency):
# put the current item onto the back of the queue
if count < count_original:
# add the node to be drawn last
node_names.append(current_node)
# pop the matrix stack for now
gl.glPopMatrix()
# come back to this mesh later
continue
#
texture = None
if geometry_name in self.textures:
texture = self.textures[geometry_name]
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
# get the mode of the current geometry
mode = self.vertex_list_mode[geometry_name]
# draw the mesh with its transform applied
self.vertex_list[geometry_name].draw(mode=mode)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
if texture is not None:
gl.glDisable(texture.target)
def render(self):
glPushMatrix()
glMultMatrixf(self.m)
self.model.render()
glPopMatrix()
def glmult(l):
return glMultMatrixf( l )
def on_draw(self):
"""
Run the actual draw calls.
"""
if self._profile:
profiler = self.Profiler()
profiler.start()
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera = np.linalg.inv(self.scene.camera_transform)
# apply the camera transform to the matrix stack
gl.glMultMatrixf(rendering.matrix_to_gl(transform_camera))
# we want to render fully opaque objects first,
# followed by objects which have transparency
node_names = collections.deque(self.scene.graph.nodes_geometry)
# how many nodes did we start with
count_original = len(node_names)
count = -1
# if we are rendering an axis marker at the world
if self._axis:
# we stored it as a vertex list
self._axis.draw(mode=gl.GL_TRIANGLES)
if self._grid:
self._grid.draw(mode=gl.GL_LINES)
while len(node_names) > 0:
count += 1
current_node = node_names.popleft()
if current_node in self._nodes_hidden:
continue
# get the transform from world to geometry and mesh name
transform, geometry_name = self.scene.graph.get(current_node)
# if no geometry at this frame continue without rendering
if geometry_name is None:
continue
# if a geometry is marked as fixed apply the inverse view transform
if self.fixed is not None and geometry_name in self.fixed:
# remove altered camera transform from fixed geometry
transform_fix = np.linalg.inv(
np.dot(self._initial_camera_transform, transform_camera))
# apply the transform so the fixed geometry doesn't move
transform = np.dot(transform, transform_fix)
# get a reference to the mesh so we can check transparency
mesh = self.scene.geometry[geometry_name]
if mesh.is_empty:
continue
# get the GL mode of the current geometry
mode = self.vertex_list_mode[geometry_name]
# if you draw a coplanar line with a triangle it will z-fight
# the best way to do this is probably a shader but this works fine
if mode == gl.GL_LINES:
# apply the offset in camera space
transform = util.multi_dot([
transform,
np.linalg.inv(transform_camera),
self._line_offset,
transform_camera])
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
# draw an axis marker for each mesh frame
if self.view['axis'] == 'all':
self._axis.draw(mode=gl.GL_TRIANGLES)
# transparent things must be drawn last
if (hasattr(mesh, 'visual') and
hasattr(mesh.visual, 'transparency')
and mesh.visual.transparency):
# put the current item onto the back of the queue
if count < count_original:
# add the node to be drawn last
node_names.append(current_node)
# pop the matrix stack for now
gl.glPopMatrix()
# come back to this mesh later
continue
# if we have texture enable the target texture
texture = None
if geometry_name in self.textures:
texture = self.textures[geometry_name]
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
# draw the mesh with its transform applied
self.vertex_list[geometry_name].draw(mode=mode)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
# disable texture after using
if texture is not None:
gl.glDisable(texture.target)
if self._profile:
profiler.stop()
print(profiler.output_text(unicode=True, color=True))
x = hmd.headPose.translation.x
y = hmd.headPose.translation.y
z = hmd.headPose.translation.z
# print(x, y, z)
# use OpenGL rendering commands here...
# Just draw a triangle 2 meters away. Let's use the ovrMatrix4f type to
# handle the translation. You can do whatever you like to the position
# every frame.
#
triangle_origin = ovrVector3f(0.0, 0.0, -2.0)
M = ovrMatrix4f.translation(triangle_origin)
GL.glPushMatrix()
GL.glMultMatrixf(M.ctypes) # multiply the scene by the matrix
GL.glBegin(GL.GL_TRIANGLES)
GL.glColor3f(1, 0, 0)
GL.glVertex3f(-1.0, -1.0, 0.0)
GL.glColor3f(0, 1, 0)
GL.glVertex3f(1.0, -1.0, 0.0)
GL.glColor3f(0, 0, 1)
GL.glVertex3f(0.0, 1.0, 0.0)
GL.glEnd()
GL.glPopMatrix()
# send the rendered buffer to the HMD
hmd.flip()
# check if the application should exit
if event.getKeys('q') or hmd.shouldQuit: