def world_to_screen_point(point, camera): """Get view of the point on screen""" tr = camera.transform.get_global_transform() screen_plane = Plane.From_normal(tr.forward, point) screen_middle_point = Ray(tr.position, tr.forward).intersect_plane(screen_plane) screen_width = math.tan(math.radians(camera.FOV / 2)) * vector3.magnitude( vector3.subtract(screen_middle_point, tr.position)) * 2 screen_height = screen_width / camera.aspect_ratio point_in_camera_space = convert_to_different_space( vector3.subtract(point, screen_middle_point), tr.right, tr.down, tr.forward) point_right_vector = vector3.add( vector3.scale(tr.right, screen_width / 2), vector3.scale(tr.right, point_in_camera_space[0])) point_down_vector = vector3.add( vector3.scale(tr.down, screen_height / 2), vector3.scale(tr.down, point_in_camera_space[1])) point_right = vector3.magnitude(point_right_vector) / screen_width point_down = vector3.magnitude(point_down_vector) / screen_height scale_right = vector3.scale_div(point_right_vector, tr.right) if scale_right < 0: point_right = -point_right scale_down = vector3.scale_div(point_down_vector, tr.down) if scale_down < 0: point_down = -point_down return (point_right * camera.resolution[0], point_down * camera.resolution[1])
def Ray_on_pixel(point2d): cam = camera.main_camera tr = cam.transform.get_global_transform() dist_from_mid = vector2.subtract(point2d, cam.middle_pixel) tg_alfa = math.tan(math.radians( cam.FOV / 2)) * dist_from_mid[0] / (cam.resolution[0] / 2) tg_beta = math.tan(math.radians( cam.FOV_vertical / 2)) * dist_from_mid[1] / (cam.resolution[1] / 2) direction = vector3.add( vector3.add(tr.forward, vector3.scale(tr.right, tg_alfa)), vector3.scale(tr.down, tg_beta)) direction = vector3.normalize(direction) ray = Ray(tr.position, direction) return ray
def Move(self, vector): last_pos = self.parent.transform.position self.parent.transform.position = vector3.add( self.parent.transform.position, vector) if 'collider' in dir(self.parent) and self.parent.collider: for obj in Mesh.objects: if obj != self.parent: if self.parent.collider.Collide(obj.collider): self.parent.transform.Set_pos(last_pos) return self.parent.transform.Set_pos(vector3.add(last_pos, vector))
def _calculate_global_tranform(self): if not self.parent: self._global_transform = self return parent_global_transform = self.parent.get_global_transform() position = vector3.add( parent_global_transform.position, Quaternion.rotate_vector(self.position, parent_global_transform.rotation)) rotation = Quaternion.composite_rotations( self.rotation, parent_global_transform.rotation) scale = Quaternion.rotate_vector(self.scale, parent_global_transform.rotation) obj = self.object transform = Transform(obj, position, rotation, scale) transform.forward = Quaternion.rotate_vector( self.forward, parent_global_transform.rotation) transform.backward = Quaternion.rotate_vector( self.backward, parent_global_transform.rotation) transform.right = Quaternion.rotate_vector( self.right, parent_global_transform.rotation) transform.left = Quaternion.rotate_vector( self.left, parent_global_transform.rotation) transform.up = Quaternion.rotate_vector( self.up, parent_global_transform.rotation) transform.down = Quaternion.rotate_vector( self.down, parent_global_transform.rotation) self._global_transform = transform
def recalculate(self): tr = self.camera.transform.get_global_transform() normal = tr.forward point = vector3.add(tr.position, vector3.scale(tr.forward, self.camera.clip_min)) self.clipping_plane = Plane.From_normal(normal, point) self.previous_position = tr.position self.previous_rotation = tr.rotation self.previous_scale = tr.scale
def Point_collision(box, point): box_center = vector3.add( box.parent.transform.position, Quaternion.rotate_vector(box.center, box.parent.transform.rotation)) rotated_point = Quaternion.rotate_vector( vector3.subtract(point, box_center), box.parent.transform.rotation.conjugate()) if abs(rotated_point[0]) > box.size[0] * box.parent.transform.scale[0]: return False if abs(rotated_point[1]) > box.size[1] * box.parent.transform.scale[1]: return False if abs(rotated_point[2]) > box.size[2] * box.parent.transform.scale[2]: return False return True
def __init__(self, position, rotation = Quaternion(1,(0,0,0)), scale = (1,1,1)): self.transform = Transform(self, position, rotation, scale) self.edges_init = [] self.vertices_init = [] self.vertices_init.append(vector3.add((0.5,0.5,0.5), self.transform.position)) self.vertices_init.append(vector3.add((0.5,-0.5,0.5), self.transform.position)) self.vertices_init.append(vector3.add((-0.5,-0.5,0.5), self.transform.position)) self.vertices_init.append(vector3.add((-0.5,0.5,0.5), self.transform.position)) self.vertices_init.append(vector3.add((0.5,0.5,-0.5), self.transform.position)) self.vertices_init.append(vector3.add((0.5,-0.5,-0.5), self.transform.position)) self.vertices_init.append(vector3.add((-0.5,-0.5,-0.5), self.transform.position)) self.vertices_init.append(vector3.add((-0.5,0.5,-0.5), self.transform.position)) self.edges_init.append(Edge(self.vertices_init[0], self.vertices_init[1])) self.edges_init.append(Edge(self.vertices_init[1], self.vertices_init[2])) self.edges_init.append(Edge(self.vertices_init[2], self.vertices_init[3])) self.edges_init.append(Edge(self.vertices_init[3], self.vertices_init[0])) self.edges_init.append(Edge(self.vertices_init[4], self.vertices_init[5])) self.edges_init.append(Edge(self.vertices_init[5], self.vertices_init[6])) self.edges_init.append(Edge(self.vertices_init[6], self.vertices_init[7])) self.edges_init.append(Edge(self.vertices_init[7], self.vertices_init[4])) self.edges_init.append(Edge(self.vertices_init[0], self.vertices_init[4])) self.edges_init.append(Edge(self.vertices_init[1], self.vertices_init[5])) self.edges_init.append(Edge(self.vertices_init[2], self.vertices_init[6])) self.edges_init.append(Edge(self.vertices_init[3], self.vertices_init[7])) self.edges = [] self.vertices = [] for edge in self.edges_init: A = edge.A B = edge.B self.edges.append(Edge(A, B)) for vertex in self.vertices_init: self.vertices.append(vertex) # if rotation.struct !=(1,0,0,0): # self.transform.Rotate(rotation = rotation)
def Gravity(): for obj in Mesh.objects: if obj.rigidbody: if obj.rigidbody.use_gravity: height = obj.rigidbody.Dist_from_ground() if not height or height > 0.05: obj.rigidbody.time_in_air += Other.delta_time obj.rigidbody.velocity = vector3.add( obj.rigidbody.velocity, vector3.scale(g_acc, obj.rigidbody.time_in_air)) if height != None and obj.rigidbody.velocity[ 2] < 0 and obj.rigidbody.velocity[ 2] * Other.delta_time < -height: obj.rigidbody.velocity = (obj.rigidbody.velocity[0], obj.rigidbody.velocity[1], -height / (2 * Other.delta_time)) else: obj.rigidbody.time_in_air = 0 if obj.rigidbody.velocity[2] < 0: obj.rigidbody.velocity = (obj.rigidbody.velocity[0], obj.rigidbody.velocity[1], 0) obj.rigidbody.Apply()
def SAT_collision(collider1, collider2): points1 = list(collider1.points) center1 = vector3.add( collider1.parent.transform.position, Quaternion.rotate_vector(collider1.center, collider1.parent.transform.rotation)) for i in range(0, len(points1)): points1[i] = Quaternion.rotate_vector( points1[i], collider1.parent.transform.rotation) points1[i] = vector3.add(points1[i], center1) points2 = list(collider2.points) center2 = vector3.add( collider2.parent.transform.position, Quaternion.rotate_vector(collider2.center, collider2.parent.transform.rotation)) for i in range(0, len(points2)): points2[i] = Quaternion.rotate_vector( points2[i], collider2.parent.transform.rotation) points2[i] = vector3.add(points2[i], center2) for normal in collider1.normals: rotated_normal = Quaternion.rotate_vector( Quaternion.rotate_vector(normal, collider1.rotation), collider1.parent.transform.rotation) min1 = None max1 = None for point in points1: axis_view = vector3.dot(rotated_normal, point) if min1 == None or min1 > axis_view: min1 = axis_view if max1 == None or max1 < axis_view: max1 = axis_view min2 = None max2 = None for point in points2: axis_view = vector3.dot(rotated_normal, point) if min2 == None or min2 > axis_view: min2 = axis_view if max2 == None or max2 < axis_view: max2 = axis_view if min1 > max2 or max1 < min2: return False for normal in collider2.normals: rotated_normal = Quaternion.rotate_vector( Quaternion.rotate_vector(normal, collider2.rotation), collider2.parent.transform.rotation) min1 = None max1 = None for point in points1: axis_view = vector3.dot(rotated_normal, point) if min1 == None or min1 > axis_view: min1 = axis_view if max1 == None or max1 < axis_view: max1 = axis_view min2 = None max2 = None for point in points2: axis_view = vector3.dot(rotated_normal, point) if min2 == None or min2 > axis_view: min2 = axis_view if max2 == None or max2 < axis_view: max2 = axis_view if max1 < min2 or min1 > max2: return False return True
def Local_to_world_space(point, transform): point_rotated = Quaternion.rotate_vector(point, transform.rotation) point_rotated_and_translated = vector3.add(point_rotated, transform.position) return point_rotated_and_translated
def Screen_to_world(point2d, distance): ray = Ray_on_pixel(point2d) point = vector3.add(ray.origin, vector3.scale(ray.direction, distance)) return point
def _rotate_vertex_(self, vertex_init): resultant_local_pos = Quaternion.rotate_vector(vertex_init, self.rotation) resultant_global_pos = vector3.add(resultant_local_pos, self.position) return resultant_global_pos
def Translate(self, vector): self.Set_pos(vector3.add(self.position, vector))
def is_point_behind_camera_clip(point, camera): tr = camera.transform.get_global_transform() clip_position = vector3.add(tr.position, vector3.scale(tr.forward, camera.clip_min)) return vector3.dot(vector3.subtract(point, clip_position), tr.forward) < 0.0
cam.transform.Translate((0, 0, -0.9)) crouching = True if Input.Get_key("lshift"): if crouching: crouching = False cam.transform.Translate((0, 0, 0.9)) move_speed = run_speed elif not crouching: move_speed = walk_speed else: move_speed = crouch_speed right_move_vec = vector3.scale(cam.transform.right, player_move[0]) forward_move_vec = vector3.scale(cam.transform.forward, player_move[1]) move_vec = (vector3.add(right_move_vec, forward_move_vec)[0], vector3.add(right_move_vec, forward_move_vec)[1], 0) move_vec = vector3.normalize(move_vec) move_vec = vector3.scale(move_vec, move_speed) player.rigidbody.Move(vector3.scale(move_vec, Other.delta_time)) if vector3.magnitude(move_vec) > 0 and step_timer <= 0: if player.rigidbody.Dist_from_ground( ) and player.rigidbody.Dist_from_ground() <= 0.05: if move_speed == walk_speed: step_channel.play(footstep) step_timer = walk_step_time elif move_speed == run_speed: step_channel.play(footstep) step_timer = run_step_time