One-way seeing and Better rendering

Author: Cypooos

core/eclCameras.py

@@ -2,7 +2,7 @@
 import math
 import pygame
 
-class FlyCamera():
+class FlyAbsoluteCamera():
 
   def __init__(self):
     self.transform = Transform([0,0,0],[0,0,0])
@@ -15,17 +15,22 @@ def onKey(self,key):
     s=self.scene.deltaTime*self.movement_speed
     if key[pygame.K_q]: self.transform.position.y -=s
     if key[pygame.K_e]: self.transform.position.y +=s
+    if key[pygame.K_w]: self.transform.position.x +=s
+    if key[pygame.K_s]: self.transform.position.x -=s
+    if key[pygame.K_a]: self.transform.position.z +=s
+    if key[pygame.K_d]: self.transform.position.z -=s
+    """
+    x,z = s*math.sin(self.transform.rotation.x),s*math.cos(self.transform.rotation.z)
 
-    x,y = s*math.sin(self.transform.rotation.y),s*math.cos(self.transform.rotation.y)
+    if key[pygame.K_w]: self.transform.position.x +=x;self.transform.position.z +=z
+    if key[pygame.K_s]: self.transform.position.x -=x;self.transform.position.z -=z
+    if key[pygame.K_a]: self.transform.position.x -=z;self.transform.position.z +=x
+    if key[pygame.K_d]: self.transform.position.x +=z;self.transform.position.z -=x"""
 
-    if key[pygame.K_w]: self.transform.position.x +=x;self.transform.position.z +=y;
-    if key[pygame.K_s]: self.transform.position.x  -=x;self.transform.position.z -=y;
-    if key[pygame.K_a]: self.transform.position.x  -=y;self.transform.position.z +=x;
-    if key[pygame.K_d]: self.transform.position.x  +=y;self.transform.position.z -=x;
 
   def onMouseMove(self,move):
-    x,y = move
-    x/=self.sensitive; y/=self.sensitive
-    self.transform.rotation.x+=y;self.transform.rotation.y+=x
-    if self.transform.rotation.x > math.pi:self.transform.rotation.x = math.pi
-    if self.transform.rotation.x < -math.pi:self.transform.rotation.x = -math.pi
+    x,z = move
+    x/=self.sensitive; z/=self.sensitive
+    self.transform.rotation.z-=z;self.transform.rotation.x+=x
+    if self.transform.rotation.z > math.pi/2:self.transform.rotation.z = math.pi/2
+    if self.transform.rotation.z < -math.pi/2:self.transform.rotation.z = -math.pi/2

core/eclDef.py

@@ -1,5 +1,7 @@
+import math
+
 class eclVector3():
-  def __init__(self,x,y,z):
+  def __init__(self,x=0,y=0,z=0):
     self.x,self.y,self.z = x,y,z
   def __setitem__(self, numb, data):
     if numb == 0: self.x = data
@@ -9,10 +11,10 @@ def __getitem__(self, numb):
     if numb == 0: return self.x
     elif numb == 1: return self.y
     elif numb == 2: return self.z
-  def __add__(self, vect3):
-    return eclVector3(self.x+vect3[0],self.y+vect3[1],self.z+vect3[2])
-  def __sub__(self, vect3):
-    return eclVector3(self.x-vect3[0],self.y-vect3[1],self.z-vect3[2])
+  def __add__(self, vect3):return eclVector3(self.x+vect3[0],self.y+vect3[1],self.z+vect3[2])
+  def __sub__(self, vect3):return eclVector3(self.x-vect3[0],self.y-vect3[1],self.z-vect3[2])
+  def __len__(self):return 3
+
 
 class Transform():
   def __init__(self,position,rotation):
@@ -31,11 +33,23 @@ class elcTriangle():
   def __init__(self,ptA=eclVector3(0,0,0),ptB=eclVector3(0,0,0),ptC=eclVector3(0,0,0)):
     self.points = [ptA,ptB,ptC]
   def calculateNormal(self):
-    return NotImplemented
+    line1 = eclVector3();line2 = eclVector3()
+    
+    line1.x = self.points[1].x - self.points[0].x
+    line1.y = self.points[1].y - self.points[0].y
+    line1.z = self.points[1].z - self.points[0].z
+    
+    line2.x = self.points[2].x - self.points[0].x
+    line2.y = self.points[2].y - self.points[0].y
+    line2.z = self.points[2].z - self.points[0].z
+    
+    return crossProduct(line1,line2)
+
   def __setitem__(self, numb, data):
     self.points[numb] = data
   def __getitem__(self, numb):
     return self.points[numb]
+  def __len__(self):return 3
 
 class elcMesh():
   def __init__(self,triList,isDoubleSided=False):
@@ -45,6 +59,19 @@ def __setitem__(self, numb, data):
     self.tri[numb] = data
   def __getitem__(self, numb):
     return self.tri[numb]
+  def __len__(self):return len(self.tri)
+
+def crossProduct(first:eclVector3,second:eclVector3):
+  returning = eclVector3(1,1,1)
+  try:
+    returning.x = first.y*second.z - first.z*second.y
+    returning.y = first.z*second.x - first.x*second.z
+    returning.z = first.x*second.y - first.y*second.x
+    l = math.sqrt(returning.x**2+returning.y**2+returning.z**2)
+    returning.x /= l;returning.y /= l;returning.z /= l
+  except ZeroDivisionError:
+    print("Err")
+  return returning
 
 def setMeshByPoints(points,triangles):
   end = []

core/eclRenderer.py

@@ -4,6 +4,7 @@
 
 from core.eclDef import eclVector3, Transform, elcTriangle
 from core.eclDef import XbyXmatrix, multiplyMatrixVector3
+from core.eclDef import crossProduct
 
 class OldEuclidianRenderer():
 
@@ -178,28 +179,68 @@ def onAwake(self):
     self.screen = self.scene.screen
     self.w, self.h = self.screen.get_size()
     self.cx, self.cy = self.w //2,self.h //2
-    near = self.conf.get("near",0.1)
-    far = self.conf.get("far",1000)
-    fov = self.conf.get("fov",90)
-  
+    self.near = self.conf.get("near",0.1)
+    self.far = self.conf.get("far",1000)
+    self.fov = self.conf.get("fov",90)
+    self.far_length = math.tan(self.fov/2)*self.far
+
+  @staticmethod # nerd shit
+  def rotate2d(pos,rad): x,y = pos;  s,c = math.sin(rad),math.cos(rad); return x*c-y*s,y*c+x*s
 
+  def _projection(self,vect3:eclVector3):
+    try:
+      X = vect3.x/((vect3.z*self.far_length)/self.far)
+      Y = vect3.y/((vect3.z*self.far_length)/self.far)
+      Z = (vect3.z-self.near)/(self.far-self.near)
+      return eclVector3(X,Y,Z) # -1_1 -1_1 0_1
+    except ZeroDivisionError:
+      return eclVector3(0,0,0)
+
+  def draw(self,triangle:elcTriangle):
+    try:
+      pygame.draw.polygon(self.screen, (100,10,255),
+        [ (triangle[0].x, triangle[0].y),
+          (triangle[1].x, triangle[1].y),
+          (triangle[2].x, triangle[2].y),
+          (triangle[0].x, triangle[0].y)
+        ], 3)
+    except TypeError:
+      pass
 
   def onRender(self):
 
     self.screen.fill((0,0,0))
+    absPosSelf = self.scene.getAbsoluteTransform(self).position
+    absRotSelf = self.scene.getAbsoluteTransform(self).rotation
 
     objs = self.scene.getByTag(self.tagToRender)
-    for x in objs:
-      for tri_ in x.mesh.tri:
-
-      #
-      # x,y,z --> X,Y and Z as depth for verts calculations
-      # -1 <= X,Y <= 1
-      # 0 < Z < 1
-      # BC = tan(fov/2)*far
-      # X = x/((z*BC)/far)
-      # Y = y/((z*BC)/far)
-      # Z = (z-near)/(far-near)
-
-      # have a isVisible if countained X,Y in drawned shapes
-
+    for obj in objs:
+      absPosObj = self.scene.getAbsoluteTransform(obj).position
+      absRotObj = self.scene.getAbsoluteTransform(obj).rotation
+      for tri_ in obj.mesh.tri:
+        
+        triProj = elcTriangle()
+        for x in range(3):
+          posTemp = tri_[x]+absPosObj+absPosSelf
+          # rotate
+          posTemp.x, posTemp.z = self.rotate2d((posTemp.x,posTemp.z),absRotObj.x+absRotSelf.x)
+          posTemp.y, posTemp.x = self.rotate2d((posTemp.y,posTemp.x),absRotObj.y+absRotSelf.y)
+          posTemp.z, posTemp.y = self.rotate2d((posTemp.z,posTemp.y),absRotObj.z+absRotSelf.z)
+          #posTemp.z, posTemp.x = self.rotate2d((posTemp.z,posTemp.x),absRotObj.y+absRotSelf.y)
+          triProj[x] = self._projection(posTemp)
+
+        shouldDraw = False
+        normal = triProj.calculateNormal()
+        if (normal.x * (triProj[0].x - absPosObj.x + absPosSelf.x) + 
+          normal.y * (triProj[0].y - absPosObj.y + absPosSelf.y) +
+          normal.z * (triProj[0].z - absPosObj.z + absPosSelf.z) < 0):shouldDraw = True
+        
+        def rescale(x,min_,max_):return (x/2+0.5)*(max_+min_)
+
+        if shouldDraw:
+          print("Draw, pos ="+str(triProj[0].x)+", "+str(triProj[0].x))
+          self.draw(elcTriangle(
+            eclVector3(rescale(triProj[0].x,0,self.w),rescale(triProj[0].y,0,self.h),0),
+            eclVector3(rescale(triProj[1].x,0,self.w),rescale(triProj[1].y,0,self.h),0),
+            eclVector3(rescale(triProj[2].x,0,self.w),rescale(triProj[2].y,0,self.h),0)
+          ))

core/eclShapes.py

@@ -1,10 +1,11 @@
 from core.eclDef import elcMesh, Transform, setMeshByPoints
 class Cube():
 
-  def __init__(self,pos,parent = None):
-    self.transform = Transform(pos,[0,0,0])
+  def __init__(self,transform,parent = None):
+    if isinstance(transform,Transform):self.transform = transform
+    else: self.transform = Transform(transform,[0,0,0])
     self.parent = parent
-    """self.mesh = elcMesh( [
+    self.mesh = elcMesh( [
       [ [0,0,0], [0,1,0], [1,1,0]],
       [ [0,0,0], [1,1,0], [1,0,0]],
       [ [1,0,0], [1,1,0], [1,1,1]],
@@ -17,8 +18,9 @@ def __init__(self,pos,parent = None):
       [ [0,1,0], [1,1,1], [1,1,0]],
       [ [1,0,1], [0,0,1], [0,0,0]],
       [ [1,0,1], [0,0,0], [1,0,0]],
-    ])"""
+    ])
+    """
     self.mesh = elcMesh(setMeshByPoints(
-      [(-1,-1,-1),(1,-1,-1),(1,1,-1),(-1,1,-1),(-1,-1,1),(1,-1,1),(1,1,1),(-1,1,1)],
+      [(0,0,0),(1,0,0),(1,1,0),(0,1,0),(0,0,1),(1,0,1),(1,1,1),(0,1,1)],
       [(0,1,2,3),(4,5,6,7),(0,1,5,4),(2,3,7,6),(0,3,7,4),(1,2,6,5)]
-    ))
+    ))"""

core/main.py

@@ -24,9 +24,9 @@ def getByID(self,id_):
     if id_ in self._objs.keys():return self._objs[id_]
     return None
 
-  def getAbsolutePos(self,obj):
+  def getAbsoluteTransform(self,obj):
     if obj.parent == None: return obj.transform
-    Ppos = self.getAbsolutePos(obj.parent)
+    Ppos = self.getAbsoluteTransform(obj.parent)
     return Ppos+obj.transform
 
   def call(self,methodName,*arg,**kwargs):

core/scene.py

@@ -1,12 +1,13 @@
-from core.eclRenderer import MatrixEuclidianRenderer, OldEuclidianRenderer
+from core.eclRenderer import MatrixEuclidianRenderer, OldEuclidianRenderer, EuclidianRenderer
 from core.scene import Scene
 
 from core.eclShapes import Cube
+from core.eclDef import Transform
 
 import asyncio
 import pygame 
 
-from core.eclCameras import FlyCamera
+from core.eclCameras import FlyAbsoluteCamera
 
 screen = pygame.display.set_mode([800,800])
 
@@ -16,13 +17,15 @@
 sc = Scene()
 
 
-cam = FlyCamera()
+cam = FlyAbsoluteCamera()
 sc.addObject(cam)
-renderer = MatrixEuclidianRenderer('EUCLID',cam)
+renderer = EuclidianRenderer('EUCLID',cam)
 sc.addObject(renderer)
 
 sc.addObject(Cube((0,0,0)),["EUCLID"])
-sc.addObject(Cube((3,0,2)),["EUCLID"])
+sc.addObject(Cube((0,0,1)),["EUCLID"])
+sc.addObject(Cube((0,0,-1)),["EUCLID"])
+sc.addObject(Cube(Transform([0,2,0],[0,0,0])),["EUCLID"])
 
 loop = asyncio.get_event_loop()
 loop.run_until_complete(sc.load(screen))