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
