directory name changed
This commit is contained in:
97
src/app.py
97
src/app.py
@@ -1,97 +0,0 @@
|
||||
from src.renderer import Renderer
|
||||
from src.object_builder import ObjectBuilder
|
||||
|
||||
class App:
|
||||
renderer : Renderer
|
||||
|
||||
def __init__(self):
|
||||
self.renderer = Renderer(1280, 720)
|
||||
self.renderer.caption = "3D Renderer"
|
||||
|
||||
def main(self):
|
||||
obj_builder1 = ObjectBuilder()
|
||||
va = obj_builder1.add_vertex(-1, 1, 1)
|
||||
vb = obj_builder1.add_vertex( 1, 1, 1)
|
||||
vc = obj_builder1.add_vertex( 1, 3, 1)
|
||||
vd = obj_builder1.add_vertex(-1, 3, 1)
|
||||
ve = obj_builder1.add_vertex(-1, 1, -1)
|
||||
vf = obj_builder1.add_vertex( 1, 1, -1)
|
||||
vg = obj_builder1.add_vertex( 1, 3, -1)
|
||||
vh = obj_builder1.add_vertex(-1, 3, -1)
|
||||
obj_builder1.add_vertices_connection(va, vb)
|
||||
obj_builder1.add_vertices_connection(va, vd)
|
||||
obj_builder1.add_vertices_connection(vd, vc)
|
||||
obj_builder1.add_vertices_connection(vb, vc)
|
||||
obj_builder1.add_vertices_connection(ve, vf)
|
||||
obj_builder1.add_vertices_connection(ve, vh)
|
||||
obj_builder1.add_vertices_connection(vh, vg)
|
||||
obj_builder1.add_vertices_connection(vf, vg)
|
||||
obj_builder1.add_vertices_connection(va, ve)
|
||||
obj_builder1.add_vertices_connection(vb, vf)
|
||||
obj_builder1.add_vertices_connection(vd, vh)
|
||||
obj_builder1.add_vertices_connection(vc, vg)
|
||||
self.renderer.add_object(obj_builder1.build())
|
||||
|
||||
obj_builder2 = ObjectBuilder()
|
||||
wa = obj_builder2.add_vertex(-2, 0, 2)
|
||||
wb = obj_builder2.add_vertex( 2, 0, 2)
|
||||
wc = obj_builder2.add_vertex( 2, 4, 2)
|
||||
wd = obj_builder2.add_vertex(-2, 4, 2)
|
||||
we = obj_builder2.add_vertex(-2, 0, -2)
|
||||
wf = obj_builder2.add_vertex( 2, 0, -2)
|
||||
wg = obj_builder2.add_vertex( 2, 4, -2)
|
||||
wh = obj_builder2.add_vertex(-2, 4, -2)
|
||||
obj_builder2.add_vertices_connection(wa, wb)
|
||||
obj_builder2.add_vertices_connection(wa, wd)
|
||||
obj_builder2.add_vertices_connection(wd, wc)
|
||||
obj_builder2.add_vertices_connection(wb, wc)
|
||||
obj_builder2.add_vertices_connection(we, wf)
|
||||
obj_builder2.add_vertices_connection(we, wh)
|
||||
obj_builder2.add_vertices_connection(wh, wg)
|
||||
obj_builder2.add_vertices_connection(wf, wg)
|
||||
obj_builder2.add_vertices_connection(wa, we)
|
||||
obj_builder2.add_vertices_connection(wb, wf)
|
||||
obj_builder2.add_vertices_connection(wd, wh)
|
||||
obj_builder2.add_vertices_connection(wc, wg)
|
||||
self.renderer.add_object(obj_builder2.build())
|
||||
|
||||
obj_builder3 = ObjectBuilder()
|
||||
ua = obj_builder3.add_vertex(-14, 0, 10)
|
||||
ub = obj_builder3.add_vertex(-8, 0, 10)
|
||||
uc = obj_builder3.add_vertex(-8, 8, 10)
|
||||
ud = obj_builder3.add_vertex(-14, 8, 10)
|
||||
ue = obj_builder3.add_vertex(-14, 0, -2)
|
||||
uf = obj_builder3.add_vertex(-8, 0, -2)
|
||||
ug = obj_builder3.add_vertex(-8, 8, -2)
|
||||
uh = obj_builder3.add_vertex(-14, 8, -2)
|
||||
obj_builder3.add_vertices_connection(ua, ub)
|
||||
obj_builder3.add_vertices_connection(ua, ud)
|
||||
obj_builder3.add_vertices_connection(ud, uc)
|
||||
obj_builder3.add_vertices_connection(ub, uc)
|
||||
obj_builder3.add_vertices_connection(ue, uf)
|
||||
obj_builder3.add_vertices_connection(ue, uh)
|
||||
obj_builder3.add_vertices_connection(uh, ug)
|
||||
obj_builder3.add_vertices_connection(uf, ug)
|
||||
obj_builder3.add_vertices_connection(ua, ue)
|
||||
obj_builder3.add_vertices_connection(ub, uf)
|
||||
obj_builder3.add_vertices_connection(ud, uh)
|
||||
obj_builder3.add_vertices_connection(uc, ug)
|
||||
self.renderer.add_object(obj_builder3.build())
|
||||
|
||||
obj_builder4 = ObjectBuilder()
|
||||
za = obj_builder4.add_vertex(-2, 0, 10)
|
||||
zb = obj_builder4.add_vertex( 2, 0, 10)
|
||||
zc = obj_builder4.add_vertex( 2, 0, 6)
|
||||
zd = obj_builder4.add_vertex(-2, 0, 6)
|
||||
ze = obj_builder4.add_vertex( 0, 8, 8)
|
||||
obj_builder4.add_vertices_connection(za, zb)
|
||||
obj_builder4.add_vertices_connection(za, zd)
|
||||
obj_builder4.add_vertices_connection(zd, zc)
|
||||
obj_builder4.add_vertices_connection(zb, zc)
|
||||
obj_builder4.add_vertices_connection(za, ze)
|
||||
obj_builder4.add_vertices_connection(zb, ze)
|
||||
obj_builder4.add_vertices_connection(zc, ze)
|
||||
obj_builder4.add_vertices_connection(zd, ze)
|
||||
self.renderer.add_object(obj_builder4.build())
|
||||
|
||||
self.renderer.run()
|
||||
148
src/camera.py
148
src/camera.py
@@ -1,148 +0,0 @@
|
||||
import numpy as np
|
||||
import math as mt
|
||||
import src.transformations as tn
|
||||
|
||||
class Camera:
|
||||
__position: np.ndarray[float]
|
||||
__yaw: float
|
||||
__pitch: float
|
||||
__roll: float
|
||||
__right: np.ndarray[float]
|
||||
__up: np.ndarray[float]
|
||||
__forward: np.ndarray[float]
|
||||
is_static: bool
|
||||
moving_speed: float
|
||||
rotation_speed: float
|
||||
h_fov: float
|
||||
v_fov: float
|
||||
near_plane: float
|
||||
far_plane: float
|
||||
|
||||
def __init__(self, renderer):
|
||||
self.__renderer = renderer
|
||||
self.__position = np.array([-5, 6, -55, 1.0])
|
||||
self.__yaw = 0
|
||||
self.__pitch = 0
|
||||
self.__roll = 0
|
||||
self.__right = np.array([1, 0, 0, 1])
|
||||
self.__up = np.array([0, 1, 0, 1])
|
||||
self.__forward = np.array([0, 0, 1, 1])
|
||||
self.moving_speed = 0.3
|
||||
self.rotation_speed = 0.015
|
||||
self.is_static = False
|
||||
self.near_plane = 0.1
|
||||
self.far_plane = 100
|
||||
self.set_fov(mt.pi / 3)
|
||||
|
||||
def projection_matrix(self):
|
||||
right = mt.tan(self.h_fov / 2)
|
||||
top = mt.tan(self.v_fov / 2)
|
||||
|
||||
m00 = 1 / right
|
||||
m11 = 1 / top
|
||||
m22 = (self.far_plane + self.near_plane) / (self.far_plane - self.near_plane)
|
||||
m32 = -2 * self.near_plane * self.far_plane / (self.far_plane - self.near_plane)
|
||||
|
||||
matrix = np.matrix([
|
||||
[m00, 0, 0, 0],
|
||||
[0, m11, 0, 0],
|
||||
[0, 0, m22, 1],
|
||||
[0, 0, m32, 0]
|
||||
])
|
||||
return matrix
|
||||
|
||||
def screen_matrix(self):
|
||||
hw = self.__renderer.window_width / 2
|
||||
hh = self.__renderer.window_height / 2
|
||||
|
||||
matrix = np.matrix([
|
||||
[hw, 0, 0, 0],
|
||||
[0, -hh, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[hw, hh, 0, 1]
|
||||
])
|
||||
return matrix
|
||||
|
||||
def set_fov(self, h_fov: float):
|
||||
self.h_fov = h_fov
|
||||
self.v_fov = h_fov * (self.__renderer.window_height / self.__renderer.window_width)
|
||||
|
||||
def set_position(self, x: float = None, y: float = None, z: float = None):
|
||||
if x is not None:
|
||||
self.__position[0] = x
|
||||
if y is not None:
|
||||
self.__position[1] = y
|
||||
if z is not None:
|
||||
self.__position[2] = z
|
||||
|
||||
def move_left(self):
|
||||
self.__position -= self.__right * self.moving_speed
|
||||
|
||||
def move_right(self):
|
||||
self.__position += self.__right * self.moving_speed
|
||||
|
||||
def move_down(self):
|
||||
self.__position -= self.__up * self.moving_speed
|
||||
|
||||
def move_up(self):
|
||||
self.__position += self.__up * self.moving_speed
|
||||
|
||||
def move_backward(self):
|
||||
self.__position -= self.__forward * self.moving_speed
|
||||
|
||||
def move_forward(self):
|
||||
self.__position += self.__forward * self.moving_speed
|
||||
|
||||
def yaw_down(self):
|
||||
self.__yaw -= self.rotation_speed
|
||||
|
||||
def yaw_up(self):
|
||||
self.__yaw += self.rotation_speed
|
||||
|
||||
def pitch_down(self):
|
||||
self.__pitch -= self.rotation_speed
|
||||
|
||||
def pitch_up(self):
|
||||
self.__pitch += self.rotation_speed
|
||||
|
||||
def roll_down(self):
|
||||
self.__roll -= self.rotation_speed
|
||||
|
||||
def roll_up(self):
|
||||
self.__roll += self.rotation_speed
|
||||
|
||||
def fov_up(self):
|
||||
self.set_fov(self.h_fov - 0.05)
|
||||
|
||||
def fov_down(self):
|
||||
self.set_fov(self.h_fov + 0.05)
|
||||
|
||||
def update_axis(self):
|
||||
rotate = tn.rotate_x(self.__pitch) @ tn.rotate_y(self.__yaw) @ tn.rotate_z(self.__roll)
|
||||
self.__forward = np.array([0, 0, 1, 1]) @ rotate
|
||||
self.__right = np.array([1, 0, 0, 1]) @ rotate
|
||||
self.__up = np.array([0, 1, 0, 1]) @ rotate
|
||||
|
||||
def camera_matrix(self) -> np.matrix:
|
||||
self.update_axis()
|
||||
return self.translate_matrix() @ self.rotate_matrix()
|
||||
|
||||
def translate_matrix(self) -> np.matrix:
|
||||
x, y, z, w = self.__position
|
||||
return np.matrix([
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[-x, -y, -z, 1]
|
||||
])
|
||||
|
||||
def rotate_matrix(self) -> np.matrix:
|
||||
rx, ry, rz, w = self.__right
|
||||
fx, fy, fz, w = self.__forward
|
||||
ux, uy, uz, w = self.__up
|
||||
return np.matrix([
|
||||
[rx, ux, fx, 0],
|
||||
[ry, uy, fy, 0],
|
||||
[rz, uz, fz, 0],
|
||||
[0, 0, 0, 1]
|
||||
])
|
||||
@@ -1,39 +0,0 @@
|
||||
import numpy as np
|
||||
import pygame as pg
|
||||
import os
|
||||
from src.vertex import Vertex
|
||||
|
||||
class Object:
|
||||
vertices: list[Vertex]
|
||||
lines: list[(Vertex, Vertex)]
|
||||
|
||||
def __init__(self, vertices: list[Vertex], lines: list[(Vertex, Vertex)]):
|
||||
self.vertices = vertices
|
||||
self.lines = lines
|
||||
|
||||
def attach_renderer(self, renderer):
|
||||
self.__renderer = renderer
|
||||
|
||||
def draw(self):
|
||||
vertices_matrix = np.array([[v.x, v.y, v.z, 1.0] for v in self.vertices])
|
||||
vertices_matrix = vertices_matrix @ self.__renderer.camera.camera_matrix()
|
||||
hidden_vertices = [row[0, 2] <= 0 for row in vertices_matrix]
|
||||
vertices_matrix = vertices_matrix @ self.__renderer.camera.projection_matrix()
|
||||
vertices_matrix /= vertices_matrix[:, -1].reshape(-1, 1)
|
||||
vertices_matrix = vertices_matrix @ self.__renderer.camera.screen_matrix()
|
||||
vertices_matrix = vertices_matrix[:, :2]
|
||||
vertices = {}
|
||||
for i in range(len(self.vertices)):
|
||||
if not hidden_vertices[i]:
|
||||
vertices[self.vertices[i]] = vertices_matrix[i].tolist()[0]
|
||||
|
||||
for v in vertices.values():
|
||||
pg.draw.circle(self.__renderer.screen, pg.Color("black"), v, 2)
|
||||
for l in self.lines:
|
||||
v1 = vertices.get(l[0])
|
||||
v2 = vertices.get(l[1])
|
||||
if (v1 is None or v2 is None):
|
||||
continue
|
||||
pg.draw.line(self.__renderer.screen, pg.Color("black"), v1, v2, 1)
|
||||
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
from src.object import Object
|
||||
from src.vertex import Vertex
|
||||
|
||||
class ObjectBuilder:
|
||||
__vertices: list[Vertex]
|
||||
__lines: list[(Vertex, Vertex)]
|
||||
|
||||
def __init__(self):
|
||||
self.__vertices = []
|
||||
self.__lines = []
|
||||
|
||||
def add_vertex(self, x: int, y: int, z: int) -> Vertex:
|
||||
v = Vertex(x, y, z)
|
||||
self.__vertices.append(v)
|
||||
return v
|
||||
|
||||
def add_vertices_connection(self, vertex1: Vertex, vertex2: Vertex):
|
||||
self.__lines.append((vertex1, vertex2))
|
||||
|
||||
def build(self) -> Object:
|
||||
return Object(self.__vertices, self.__lines)
|
||||
@@ -1,81 +0,0 @@
|
||||
import pygame as pg
|
||||
import numpy as np
|
||||
from math import *
|
||||
from src.camera import Camera
|
||||
from src.object import Object
|
||||
|
||||
class Renderer:
|
||||
__clock: pg.time.Clock
|
||||
screen: pg.Surface
|
||||
fps: int
|
||||
caption: str
|
||||
camera: Camera
|
||||
window_width: int
|
||||
window_height: int
|
||||
objects: list[Object]
|
||||
|
||||
def __init__(self, window_width: int, window_height: int):
|
||||
self.__clock = pg.time.Clock()
|
||||
self.screen = pg.display.set_mode((window_width, window_height))
|
||||
self.window_width = window_width
|
||||
self.window_height = window_height
|
||||
self.fps = 60
|
||||
self.caption = "window"
|
||||
self.camera = Camera(self)
|
||||
self.objects = []
|
||||
|
||||
def __quit(self):
|
||||
pg.quit()
|
||||
exit()
|
||||
|
||||
def __handle_event(self, event: pg.event.Event):
|
||||
if event.type == pg.QUIT:
|
||||
self.__quit()
|
||||
if not self.camera.is_static:
|
||||
key = pg.key.get_pressed()
|
||||
if key[pg.K_w]:
|
||||
self.camera.move_forward()
|
||||
if key[pg.K_s]:
|
||||
self.camera.move_backward()
|
||||
if key[pg.K_a]:
|
||||
self.camera.move_left()
|
||||
if key[pg.K_d]:
|
||||
self.camera.move_right()
|
||||
if key[pg.K_SPACE]:
|
||||
self.camera.move_up()
|
||||
if key[pg.K_LSHIFT]:
|
||||
self.camera.move_down()
|
||||
if key[pg.K_EQUALS]:
|
||||
self.camera.fov_up()
|
||||
if key[pg.K_MINUS]:
|
||||
self.camera.fov_down()
|
||||
if key[pg.K_r]:
|
||||
self.camera.pitch_down()
|
||||
if key[pg.K_f]:
|
||||
self.camera.pitch_up()
|
||||
if key[pg.K_q]:
|
||||
self.camera.yaw_down()
|
||||
if key[pg.K_e]:
|
||||
self.camera.yaw_up()
|
||||
if key[pg.K_z]:
|
||||
self.camera.roll_down()
|
||||
if key[pg.K_c]:
|
||||
self.camera.roll_up()
|
||||
|
||||
def __update(self):
|
||||
self.screen.fill((255,255,255))
|
||||
for o in self.objects:
|
||||
o.draw()
|
||||
pg.display.update()
|
||||
|
||||
def add_object(self, object: Object):
|
||||
object.attach_renderer(self)
|
||||
self.objects.append(object)
|
||||
|
||||
def run(self):
|
||||
pg.display.set_caption(self.caption)
|
||||
while True:
|
||||
for event in pg.event.get():
|
||||
self.__handle_event(event)
|
||||
self.__update()
|
||||
self.__clock.tick(self.fps)
|
||||
@@ -1,42 +0,0 @@
|
||||
import math
|
||||
import numpy as np
|
||||
|
||||
def translate(x, y, z):
|
||||
return np.array([
|
||||
[1, 0, 0, 0],
|
||||
[0, 1, 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[x, y, z, 1]
|
||||
])
|
||||
|
||||
def rotate_x(a):
|
||||
return np.array([
|
||||
[1, 0, 0, 0],
|
||||
[0, math.cos(a), math.sin(a), 0],
|
||||
[0, -math.sin(a), math.cos(a), 0],
|
||||
[0, 0, 0, 1]
|
||||
])
|
||||
|
||||
def rotate_y(a):
|
||||
return np.array([
|
||||
[math.cos(a), 0, -math.sin(a), 0],
|
||||
[0, 1, 0, 0],
|
||||
[math.sin(a), 0, math.cos(a), 0],
|
||||
[0, 0, 0, 1]
|
||||
])
|
||||
|
||||
def rotate_z(a):
|
||||
return np.array([
|
||||
[math.cos(a), math.sin(a), 0, 0],
|
||||
[-math.sin(a), math.cos(a), 0, 0],
|
||||
[0, 0, 1, 0],
|
||||
[0, 0, 0, 1]
|
||||
])
|
||||
|
||||
def scale(n):
|
||||
return np.array([
|
||||
[n, 0, 0, 0],
|
||||
[0, n, 0, 0],
|
||||
[0, 0, n, 0],
|
||||
[0, 0, 0, 1]
|
||||
])
|
||||
@@ -1,14 +0,0 @@
|
||||
import numpy as np
|
||||
|
||||
class Vertex:
|
||||
x: int
|
||||
y: int
|
||||
z: int
|
||||
|
||||
def __init__(self, x: int, y: int, z: int):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
|
||||
def to_matrix(self) -> np.matrix:
|
||||
return np.matrix([self.x, self.y, self.z])
|
||||
Reference in New Issue
Block a user