def mousemove(handle, x1, y1): nonlocal x0, y0 if glfw.get_mouse_button(window, 0): dx = x1-x0 dy = y1-y0 self.camera.transform = glm.inverse(puregl.transform.orbit(glm.inverse(self.camera.transform), dx * 2, dy * 2)) x0, y0 = x1, y1
def _generate_nodeview_matrix2( rsm_version: int, node: AbstractNode) -> Tuple[glm.mat4, glm.mat4]: # Transformations which are inherited by children local_transform_matrix = glm.mat4() rsm_node = node.impl # Scaling if len(rsm_node.scale_key_frames) > 0: local_transform_matrix = glm.scale( local_transform_matrix, glm.vec3(rsm_node.scale_key_frames[0].scale)) # Rotation if len(rsm_node.rot_key_frames) > 0: # Animated model key_frame = rsm_node.rot_key_frames[0] quaternion = glm.quat(key_frame.quaternion[3], key_frame.quaternion[0], key_frame.quaternion[1], key_frame.quaternion[2]) local_transform_matrix *= glm.mat4_cast(quaternion) else: # Static model local_transform_matrix = rag_mat4_mul( local_transform_matrix, mat3tomat4(rsm_node.info.offset_matrix)) if node.parent: parent_offset_matrix = mat3tomat4( node.parent.impl.info.offset_matrix) local_transform_matrix = rag_mat4_mul( local_transform_matrix, glm.inverse(parent_offset_matrix)) # Translation if rsm_version >= 0x203 and len(rsm_node.pos_key_frames) > 0: key_frame = rsm_node.pos_key_frames[0] position = glm.vec3(key_frame.position) elif node.parent: position = glm.vec3(rsm_node.info.offset_vector) - \ glm.vec3(node.parent.impl.info.offset_vector) parent_offset_matrix = mat3tomat4(node.parent.impl.info.offset_matrix) position = glm.vec3( glm.inverse(parent_offset_matrix) * glm.vec4(position, 1.0)) else: position = glm.vec3(rsm_node.info.offset_vector) # Transformations which are applied only to this node final_transform_matrix = copy.copy(local_transform_matrix) # Reset translation transformation to `position` final_transform_matrix[3] = glm.vec4(position, 1.0) # Inherit transformations from ancestors parent = node.parent while parent: final_transform_matrix = rag_mat4_mul(final_transform_matrix, parent.local_transform_matrix) parent = parent.parent if node.parent: parent_translation = glm.vec3(node.parent.final_transform_matrix[3]) final_transform_matrix[3] += glm.vec4(parent_translation, 0.0) return (local_transform_matrix, final_transform_matrix)
def getCubeRay(self, wnd_pos): ndc_xy = wnd_pos[0] * 2 / self.__vp_size[0] - 1, wnd_pos[ 1] * 2 / self.__vp_size[1] - 1 cube_mv = self.__view * self.__model * self.__voxel_map.cube_model cube_space = glm.inverse(cube_mv) inverse_prj = glm.inverse(self.__proj) view_dir1_h = inverse_prj * glm.vec4(*ndc_xy, 1, 1) view_dir0_h = inverse_prj * glm.vec4(*ndc_xy, -1, 1) view_dir = view_dir1_h.xyz / view_dir1_h.w - view_dir0_h.xyz / view_dir0_h.w cube_origin = cube_space[3].xyz cube_dir = glm.mat3(cube_space) * view_dir return (cube_origin, cube_dir)
def __init__(self, scene, width=1280, height=720, title="Viewer", floating=False, background_color=(0, 0, 0, 1)): # window self.width = width self.height = height self.scene = scene self.title = title self._floating = floating self.background_color = background_color # threading self.thread = None self.lock = None # renderer from editor.render.graphics import PerspectiveCamera self.camera = PerspectiveCamera(glm.mat4(1), glm.radians(39.6), self.width / self.height, 0.1, 30) self.camera.transform = glm.inverse( glm.lookAt(glm.vec3(2, 3, 6), glm.vec3(0, 0, 0), glm.vec3(0, 1, 0))) self.renderer = DeferredPBRRenderer(self.width, self.height)
def voxel_to_ray(self, x, y): """Return tuple with ray-origin and normalized ray-direction for input render-res x, y""" st = glm.vec2(x / self.width, y / self.height) * 2. - 1. if self.is_perspective(): near, far = -self.near, -self.far else: near, far = -1, 1 pos = self.inverse_projection_matrix * glm.vec4(st.x, st.y, near, 1) pos /= pos.w dirf = self.inverse_projection_matrix * glm.vec4(st.x, st.y, far, 1) dirf /= dirf.w dir = glm.normalize(glm.vec3(dirf - pos)) t = glm.inverse(self.transformation_matrix) ro, rd = glm.vec3(t * pos), glm.normalize( glm.vec3(t * glm.vec4(dir, 0))) if self.is_perspective(): rd = -rd if 0: def _v(v): return "(%s)" % ", ".join("%s" % round(x, 2) for x in v) print("near", _v(pos), "far", _v(dirf), "ro", _v(ro), "rd", _v(rd)) return ro, rd
def __init__(self, mode=1, position=glm.vec3(1, 0, 0), target=glm.vec3(0), worldUp=glm.vec3(0, 1, 0)): # settings self.fpsRotationSpeed = 0.005 # speed with which the camera rotates in fps mode self.moveSpeed = 0.125 # speed with which the camera moves in fps mode self.tbRotationSpeed = 0.015 # speed with which the camera rotates in trackball mode self.panSpeed = 0.006 # speed with which the camera pans in trackball mode self.zoomSpeed = 0.25 # speed with which the camera zooms (used for Z axis in trackball mode) self.enableAllControls = False # enable movement while in trackball mode and pan/zoom while in fps mode self.movementSmoothing = 0.25 # higher numbers result in stronger smoothing and delayed movement self.rotationSmoothing = 0.3 # higher numbers result in stronger smoothing and delayed rotation self.worldUp = worldUp # worlds up vector self.mode = mode # 0 = trackball, 1 = first person self.movementSpeedMod = 1.0 # temporary modified movement speed, will be reset every frame # cameras internal state (DO NOT WRITE) self._movementInput = glm.vec3(0) self._rotationInput = glm.vec2(0) self._desiredTransform = Transform( ) # Transform(position) # desired transform based on inputs self._desiredTargetDistance = 0 # desired distance along the front vector where the center for trackball mode lives self._currentTransform = Transform( ) #Transform(position) # transform object describing orientation and position of camera self._currentTargetDistance = 0 # distance along the front vector where the center for trackball mode lives self.setPosition(position) self.setTarget(target) # variables depending on state, they are automatically updated when calling the Camera.update() (DO NOT WRITE, only read) self.modelMatrix = self._currentTransform.mat4() self.viewMatrix = glm.inverse(self.modelMatrix)
def pan(self, old_pos, new_pos): inv_view = glm.inverse(self.view) view_pos = glm.vec3(inv_view[3]) los = -glm.vec3(inv_view[2]) up = glm.vec3(inv_view[1]) wnd_from = glm.vec3(old_pos[0], old_pos[1], 1) wnd_to = glm.vec3(new_pos[0], new_pos[1], 1) vp_rect = glm.vec4(0, 0, self.width, self.height) world_from = glm.unProject(wnd_from, self.view, self.proj, vp_rect) world_to = glm.unProject(wnd_to, self.view, self.proj, vp_rect) dir_from = glm.normalize(world_from - view_pos) dir_to = glm.normalize(world_to - view_pos) rot_axis = glm.normalize(glm.cross(dir_from, dir_to)) rot_angle = math.acos(glm.dot(dir_from, dir_to)) rotate = glm.rotate(glm.mat4(1), rot_angle, rot_axis) model_rot = glm.translate(glm.mat4(1), view_pos) * rotate * glm.translate( glm.mat4(1), -view_pos) self.view = self.view * model_rot
def draw_scene(self, shader): # ---------------------------------------------------------------------- # 1. Setup shader uniforms # ---------------------------------------------------------------------- shader.use() # model view projection model = glm.mat4(1.0) shader.set_mat4('model', np.asarray(model)) view = self.camera.get_view() shader.set_mat4('view', np.asarray(view)) ortho = self.camera.get_projection() shader.set_mat4('projection', np.asarray(ortho)) # lighting lightPos = np.array(self.light_pos) shader.set_vec3('lightPos', lightPos) shader.set_vec3('lightColor', np.array([1.0, 1.0, 1.0], 'f')) cameraPos = glm.vec3(glm.column(glm.inverse(view), 3)) shader.set_vec3('viewPos', np.asarray(cameraPos)) # ---------------------------------------------------------------------- # 2. Draw scene # ---------------------------------------------------------------------- glLineWidth(2) self.system.draw(shader) self.system.collider.draw(shader) self.draw_grid(shader)
def render( self, projection: glm.mat4, transformation: glm.mat4, ): glEnable(GL_CULL_FACE) glEnable(GL_DEPTH_TEST) transforms = np.array([m.to_list() for m in self.part_transforms], dtype="float32") transforms = transforms.flatten() self.drawable.shader.set_uniform("u_projection", projection) self.drawable.shader.set_uniform("u_transformation", transformation) self.drawable.shader.set_uniform("u_transformation_inv", glm.inverse(transformation)) self.drawable.shader.set_uniform("u_part_transformation[0]", transforms) if not self.instance_buffers: self.drawable.prepare() vao: VertexArrayObject = self.drawable.vao mat = glm.mat4(1) for i in range(4): self.instance_buffers.append( vao.create_attribute_buffer( attribute_location=self.drawable.shader.attribute("a_instance_transform").location + i, num_dimensions=4, Type=GLfloat, #values=[1.,0.,0.,0., 0.,1.,0.,0., 0.,0.,1.,0., 0.,0.,0.,1.], values=mat[i], stride=ctypes.sizeof(GLfloat) * 16, offset=ctypes.sizeof(ctypes.c_float) * 4 * i, divisor=1, ) ) self.drawable.draw(num_instances=None)
def MoveOnLineOfSight(self, cursor_pos, delta): # get viewport rectangle #vp_rect = self.VpRect() # get view, projection and window matrix proj, inv_proj = self.ProjectionMat() view, inv_view = self.ViewMat() wnd, inv_wnd = self.WindowMat() # get world space position on view ray pt_wnd = glm.vec3(*cursor_pos, 1.0) #pt_world = glm.unProject(pt_wnd, view, proj, vp_rect) pt_h_world = inv_view * inv_proj * inv_wnd * glm.vec4(*pt_wnd, 1) pt_world = glm.vec3(pt_h_world) / pt_h_world.w # get view position eye = glm.vec3(inv_view[3]) # get "zoom" direction and amount ray_cursor = glm.normalize(pt_world - eye) # translate view position and update view matrix inv_view = glm.translate(glm.mat4(1), ray_cursor * delta) * inv_view # return new view matrix return glm.inverse(inv_view), True
def update(self, dt): # print (self.throttle_up - self.throttle_down - .2) accel = self.throttle_up - self.throttle_down if not self.collider.platform: accel -= .2 if accel: self.collider.sleeping = False self.collider.force.y += accel * self.vertical_force self.animate(self.ix, self.iy, (self.throttle_up - self.throttle_down), self.collider.platform, dt) if not self.collider.platform and 0 in self.occupied_seats: if abs(self.collider.vel.y) > self.max_y_vel: self.collider.vel.y = cmp(self.collider.vel.y, 0) * self.max_y_vel rot_mat = glm.rotate(glm.mat4(1.0), glm.radians(90 - self.angle), glm.vec3(0, 1, 0)) local_vel = rot_mat * glm.vec4(self.collider.vel, 1) local_vel.x += self.ix * self.accel_force * dt local_vel.z += self.iy * self.turn_force * dt turn_input = util.angle_diff( self.angle, 90 - self.engine.renderer.camera.yaw) * .1 turn_force = self.turn_force * turn_input self.angle += turn_force * dt local_vel.z *= 1 - self.side_friction * dt local_vel.x = min(self.max_speed, max(self.min_speed, local_vel.x)) self.collider.vel = glm.vec3(glm.inverse(rot_mat) * local_vel).xyz
def CalcViewMatrix(self): transfrom = glm.translate(glm.mat4(1), self.position) transfrom = glm.rotate(transfrom, glm.radians(self.rotation), glm.vec3(0, 0, 1)) self.viewMat = glm.inverse(transfrom) self.VP = self.projectionMat * self.viewMat
def WindowMat(self): vp_rect = self.VpRect() inv_wnd = glm.translate(glm.mat4(1), glm.vec3(-1, -1, -1)) inv_wnd = glm.scale(inv_wnd, glm.vec3(2 / vp_rect[2], 2 / vp_rect[3], 2)) inv_wnd = glm.translate(inv_wnd, glm.vec3(vp_rect[0], vp_rect[1], 0)) return glm.inverse(inv_wnd), inv_wnd
def getViewMatrix(self): i = glm.mat4(1) camTranslate = glm.translate(i, self.camPosition) camPitch = glm.rotate(i, glm.radians( self.camRotation.x ), glm.vec3(1,0,0)) camYaw = glm.rotate(i, glm.radians( self.camRotation.y ), glm.vec3(0,1,0)) camRoll = glm.rotate(i, glm.radians( self.camRotation.z ), glm.vec3(0,0,1)) camRotate = camPitch * camYaw * camRoll return glm.inverse( camTranslate * camRotate )
def _drawOrientationIndicator(self): gloo.set_state(line_width=5) # we want the rotation of the camera but not the translation view = glm.inverse(glm.mat4_cast(self.cam._currentTransform.orientation)) view = glm.scale( view, glm.vec3(0.25)) self._oriProgram['projection'] = self._oriProjection self._oriProgram['view'] = view self._oriProgram.draw('lines')
def distance(self, other:"Transformation") -> float: td = glm.distance(self.translation, other.translation) sd = glm.distance(self.scale, other.scale) qn : glm.Quat = glm.inverse(self.quaternion) # type: ignore qn = qn * other.quaternion if qn.w<0: qn = -qn qd = glm.length(qn - glm.quat()) return td+sd+qd
def unproject(screen_point, mvp_matrix, width, height): mvp_matrix_inv = np.array(glm.inverse(mvp_matrix), dtype=np.float32) x = screen_point.x / width * 2.0 - 1.0 y = screen_point.y / height * 2.0 - 1.0 z = screen_point.z * 2.0 - 1.0 point = mvp_matrix_inv.dot(glm.vec4(x, y, z, 1.0)) if point[2] == 0.0: return glm.vec4(0.0) point /= point[2] return glm.vec3(point[0], point[1], point[2])
def quaternion_of_rotation(rotation:glm.Mat3) -> glm.Quat: """ Note that R . axis = axis RI = (R - I*999/1000) Then RI . axis = axis/1000 Then det(RI) is going to be 1/1000 * at most 2 * at most 2 And if na is perp to axis, then RI.na = R.na - 999/1000.na, which is perp to axis Then |R.na| < 2|na| If RI' . RI = I, then consider v' = RI' . v for some v=(a*axis + b*na0 + c*na1) (a'*axis + b'*na0 + c'*na1) = RI' . (a*axis + b*na0 + c*na1) Then RI . (a'*axis + b'*na0 + c'*na1) = (a*axis + b*na0 + c*na1) Then a'*RI.axis + b'*RI.na0 + c'*RI.na1 = a*axis + b*na0 + c*na1 Then a'/1000*axis + b'*(R.na0-0.999.na0) + c'*(R.na1-0.999.na1) = a*axis + b*na0 + c*na1 Then a = a'/1000, and -0.999b' + b'cos(angle) + c'sin(angle) = b, etc If we set |v| to be 1, then |v'| must be det(RI') = 1/det(RI) > 100 If angle is not close to zero, then a' / b' >> 1 This can be repeated: v' = normalize(RI' . v) v'' = normalize(RI' . v') v''' = normalize(RI' . v'') etc This gets closer and closer to the axis """ rot_min_id : glm.Mat3 = rotation - (0.99999 * glm.mat3()) # type: ignore rot_min_id_i : glm.Mat3 = glm.inverse(rot_min_id) # type: ignore for j in range(3): v = glm.vec3() v[j] = 1. for i in range(10): last_v = v rid_i_v : glm.Vec3 = rot_min_id_i * v # type: ignore v = glm.normalize(rid_i_v) pass axis = v dist2 = glm.length2(v - last_v) # type: ignore if dist2<0.00001: break pass w = glm.vec3([1.0,0,0]) if axis[0]>0.9 or axis[0]<-0.9: w = glm.vec3([0,1.0,0]) na0 : glm.Vec3 = glm.normalize(glm.cross(w, axis)) na1 : glm.Vec3 = glm.cross(axis, na0) # Rotate w_perp_n around the axis of rotation by angle A na0_r : glm.Vec3 = rotation * na0 # type: ignore na1_r : glm.Vec3 = rotation * na1 # type: ignore # Get angle of rotation cos_angle = glm.dot(na0, na0_r) sin_angle = -glm.dot(na0, na1_r) angle = math.atan2(sin_angle, cos_angle) # Set quaternion return glm.angleAxis(angle, axis)
def getViewMatrix(self): i = glm.mat4(1) # View Matrix and Translation camTranslate = glm.translate(i, self.camPos) camPitch = glm.rotate(i, glm.radians(self.pitchCam), glm.vec3(1, 0, 0)) camYaw = glm.rotate(i, glm.radians(self.yawCam), glm.vec3(0, 1, 0)) camRoll = glm.rotate(i, glm.radians(self.rollCam), glm.vec3(0, 0, 1)) camRotate = camPitch * camYaw * camRoll view = glm.inverse(camTranslate * camRotate) return view
def derive_matrices(self) -> None: btp = self.transformation.mat4() self.ptb = glm.inverse(btp) # type: ignore if self.parent is None: self.mtb = glm.mat4(self.ptb) pass else: self.mtb = self.ptb * self.parent.mtb pass for c in self.children: c.derive_matrices() pass pass
def __init__(self, width=1280, height=720, title="puregl-viewer", floating=False): self.width, self.height = width, height self.title = title self._floating = floating self.events = {'on_setup':[], 'on_draw':[]} # Handle window events # ------------- self.camera = PerspectiveCamera(transform=glm.inverse(glm.lookAt(glm.vec3(1,1.5,4), glm.vec3(0,0,0), glm.vec3(0,1,0))), fovy=glm.radians(48.5), aspect=self.width/self.height, near=0.1, far=30)
def draw_scene(prog, projection_matrix, view_matrix): """Draw scen with a shader program""" program.set_uniform(prog, 'projectionMatrix', projection_matrix) program.set_uniform(prog, 'viewMatrix', view_matrix) camera_pos = glm.inverse(view_matrix)[3].xyz program.set_uniform(prog, 'cameraPos', camera_pos) model_matrix = glm.translate(glm.mat4(1), (-1, 0.5, 0)) normal_matrix = glm.mat3(glm.transpose(glm.inverse(model_matrix))) program.set_uniform(prog, 'modelMatrix', model_matrix) program.set_uniform(prog, 'normalMatrix', normal_matrix) imdraw.cube(prog) model_matrix = glm.translate(glm.mat4(1), (1, 0, 0)) normal_matrix = glm.mat3(glm.transpose(glm.inverse(model_matrix))) program.set_uniform(prog, 'modelMatrix', model_matrix) program.set_uniform(prog, 'normalMatrix', normal_matrix) imdraw.sphere(prog) model_matrix = glm.mat4(1) normal_matrix = glm.mat3(glm.transpose(glm.inverse(model_matrix))) program.set_uniform(prog, 'modelMatrix', model_matrix) program.set_uniform(prog, 'normalMatrix', normal_matrix) imdraw.plane(prog)
def update(self, dt): rot_mat = glm.rotate(glm.mat4(1.0), glm.radians(90 -self.angle), glm.vec3(0, 1, 0)) local_vel = rot_mat * glm.vec4(self.collider.vel, 1) local_vel.x += self.ix * dt * 100 local_vel.z += self.iy * dt * 100 if self.ix: turn_input = abs(self.ix) ** 1.2 * cmp(-self.ix, 0) turn_force = abs(local_vel.x) * self.turn_force self.angle += turn_force * turn_input * dt local_vel.z *= 1 - self.side_friction * dt local_vel.x = min(self.max_speed, max(self.min_speed, local_vel.x)) self.collider.vel = glm.vec3(glm.inverse(rot_mat) * local_vel).xyz
def intersect(self, ray, hit, tmin): minverse = glm.inverse(self.matrix) tdir4 = minverse * glm.vec4(ray.direction, 0.0) tdir3 = tdir4.xyz if tdir4.w != 0.0: tdir3 = tdir3 / tdir4.w torig4 = minverse * glm.vec4(ray.origin, 1.0) torig3 = torig4.xyz / torig4.w hit = self.primitive.intersect(Ray(torig3, tdir3), hit, tmin) if hit: hit.normal = (glm.transpose(minverse) * glm.vec4(hit.normal, 1.0)).xyz return hit
def render(self): glClearColor(0.2, 0.2, 0.2, 1) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) i = glm.mat4(1) #como las matrices vistas en Static rendering # Model/Object matrix: translate * rotate * scale translate = glm.translate(i, self.cubePos) pitch = glm.rotate(i, glm.radians(0), glm.vec3(1, 0, 0)) yaw = glm.rotate(i, glm.radians(0), glm.vec3(0, 1, 0)) roll = glm.rotate(i, glm.radians(0), glm.vec3(0, 0, 1)) rotate = pitch * yaw * roll scale = glm.scale(i, glm.vec3(1, 1, 1)) model = translate * rotate * scale # View Matrix # glm.lookAt( eye, center, up) camTranslate = glm.translate(i, glm.vec3(0, 0, 3)) camPitch = glm.rotate(i, glm.radians(0), glm.vec3(1, 0, 0)) camYaw = glm.rotate(i, glm.radians(0), glm.vec3(0, 1, 0)) camRoll = glm.rotate(i, glm.radians(0), glm.vec3(0, 0, 1)) camRotate = camPitch * camYaw * camRoll view = glm.inverse(camTranslate * camRotate) if self.active_shader: glUniformMatrix4fv( glGetUniformLocation(self.active_shader, "model"), 1, GL_FALSE, glm.value_ptr(model)) glUniformMatrix4fv( glGetUniformLocation(self.active_shader, "view"), 1, GL_FALSE, glm.value_ptr(view)) glUniformMatrix4fv( glGetUniformLocation(self.active_shader, "projection"), 1, GL_FALSE, glm.value_ptr(self.projection)) glBindVertexArray(self.VAO) glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, None) glBindVertexArray(0)
def render(self): glClearColor(0.2, 0.2, 0.2, 1) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) i = glm.mat4(1) translate = glm.translate(i, self.cube_position) pitch = glm.rotate(i, glm.radians(0), glm.vec3(1, 0, 0)) yaw = glm.rotate(i, glm.radians(0), glm.vec3(0, 1, 0)) roll = glm.rotate(i, glm.radians(0), glm.vec3(0, 0, 1)) rotate = pitch * yaw * roll scale = glm.scale(i, glm.vec3(1, 1, 1)) model = translate * rotate * scale camera_translate = glm.translate(i, self.camera_position) camera_pitch = glm.rotate(i, glm.radians(self.camera_pitch_degrees), glm.vec3(1, 0, 0)) camera_yaw = glm.rotate(i, glm.radians(self.camera_yaw_degrees), glm.vec3(0, 1, 0)) camera_roll = glm.rotate(i, glm.radians(self.camera_roll_degrees), glm.vec3(0, 0, 1)) camera_rotate = camera_pitch * camera_yaw * camera_roll view = glm.inverse(camera_translate * camera_rotate) if self.active_shader: glUniformMatrix4fv( glGetUniformLocation(self.active_shader, 'model'), 1, GL_FALSE, glm.value_ptr(model)) glUniformMatrix4fv( glGetUniformLocation(self.active_shader, 'view'), 1, GL_FALSE, glm.value_ptr(view)) glUniformMatrix4fv( glGetUniformLocation(self.active_shader, 'projection'), 1, GL_FALSE, glm.value_ptr(self.projection)) glBindVertexArray(self.VAO) glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, None) glBindVertexArray(0)
def draw_scene(self, shader): # ---------------------------------------------------------------------- # 1. Setup shader uniforms # ---------------------------------------------------------------------- shader.use() # model view projection model = glm.mat4(1.0) shader.set_mat4('model', np.asarray(model)) view = self.camera.get_view() shader.set_mat4('view', np.asarray(view)) width = self.window.width height = self.window.height projection = glm.perspective(glm.radians(50.0), width/height, 0.1, 100.0) shader.set_mat4('projection', np.asarray(projection)) # lighting lightPos = np.array(self.light_pos) shader.set_vec3('lightPos', lightPos) shader.set_vec3('lightColor', np.array([1.0, 1.0, 1.0], 'f')) cameraPos = glm.vec3(glm.column(glm.inverse(view), 3)) shader.set_vec3('viewPos', np.asarray(cameraPos)) # ---------------------------------------------------------------------- # 2. Draw scene # ---------------------------------------------------------------------- self.system.draw(shader) # self.hand.draw(shader) # self.baton.draw(shader) if self.show_grid: self.grid.draw(shader) if self.show_contact_frames or self.show_contacts or self.show_velocities: self.draw_contact_frames(shader)
def _compute_transform_matrices(rsm_version: int, node: AbstractNode, is_only_node: bool, model_bbox: BoundingBox) -> None: if rsm_version >= 0x200: (node.local_transform_matrix, node.final_transform_matrix) = _generate_nodeview_matrix2( rsm_version, node) if node.parent: node.gltf_transform_matrix = glm.inverse( node.parent.final_transform_matrix ) * node.final_transform_matrix else: node.gltf_transform_matrix = node.final_transform_matrix elif rsm_version >= 0x100: node.gltf_transform_matrix = _generate_nodeview_matrix1( rsm_version, node, is_only_node, model_bbox) else: raise ValueError("Invalid RSM file version") for child in node.children: _compute_transform_matrices(rsm_version, child, is_only_node, model_bbox)
def reset(textureDict, bufferDict, cameraConfig, fusionConfig, clickedPoint3D): frame.generateTextures(textureDict, cameraConfig, fusionConfig) #generateBuffers(bufferDict, cameraConfig) currPose = glm.mat4(1.0) currPose = glm.translate(glm.mat4(1.0), glm.vec3(-clickedPoint3D[0] + fusionConfig['volDim'][0] / 2.0, -clickedPoint3D[1] + fusionConfig['volDim'][0] / 2.0, -clickedPoint3D[2] + fusionConfig['volDim'][0] / 2.0)) #currPose[3,0] = (fusionConfig['volDim'][0] / 2.0) - clickedPoint3D[0] #currPose[3,1] = (fusionConfig['volDim'][1] / 2.0) - clickedPoint3D[1] #currPose[3,2] = (fusionConfig['volDim'][2] / 2.0) - clickedPoint3D[2] blankResult = np.array([0, 0, 0, 0, 0, 0], dtype='float32') glBindBuffer(GL_SHADER_STORAGE_BUFFER, bufferDict['poseBuffer']) glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 16 * 4, glm.value_ptr(currPose)) glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4, 16 * 4, glm.value_ptr(glm.inverse(currPose))) glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 2, 16 * 4, glm.value_ptr(glm.mat4(1.0))) glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 3, 16 * 4, glm.value_ptr(glm.mat4(1.0))) glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 4, 6 * 4, blankResult) glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0) initAtomicCount = np.array([0], dtype='uint32') mapSize = np.array([0], dtype='uint32') glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic0']) glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount) glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0) glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic1']) glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount) glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0) integrateFlag = 0 resetFlag = 1 return currPose, integrateFlag, resetFlag
def __init__(self, scene): # window self.width = 1024 self.height = 768 self.window = GLFWViewer(self.width, self.height, (0.2, 0.2, 0.2, 1.0)) self.camera = PerspectiveCamera(glm.inverse(self.window.view_matrix), glm.radians(60), self.width / self.height, 1, 30) self.scene = scene # assets self.environment_image = assets.imread('hdri/Tropical_Beach_3k.hdr') self.environment_image = assets.to_linear(self.environment_image) # render passes self.environment_pass = EnvironmentPass(512, 512) self.irradiance_pass = IrradiancePass(32, 32) self.prefilter_pass = PrefilterPass() self.brdf_pass = BRDFPass(512, 512) self.tonemapping_pass = TonemappingPass(self.width, self.height) self.geometry_pass = GeometryPass(self.width, self.height, self.draw_scene_for_geometry) dirlight.shadowpass = DepthPass(1024, 1024, GL_FRONT, self.draw_scene_for_shadows) spotlight.shadowpass = DepthPass(1024, 1024, GL_FRONT, self.draw_scene_for_shadows) pointlight.shadowpass = CubeDepthPass( 512, 512, GL_FRONT, near=1, far=15, draw_scene=self.draw_scene_for_shadows) self.lighting_pass = LightingPass( self.width, self.height, lights=[dirlight, spotlight, pointlight])