Added normals

Author: Sekqies

src/main.ts

@@ -17,7 +17,7 @@ export function main_3d() {
     const sun_mesh = create_sphere(1.5, 32, 32); 
     const planet_mesh = create_sphere(0.5, 16, 16);
 
-    const scene:Scene = new Scene([sun_mesh.vertices,planet_mesh.vertices],[sun_mesh.indices,planet_mesh.indices]);
+    const scene:Scene = new Scene([sun_mesh,planet_mesh]);
 
     console.log(scene.draw_end)
 

src/math/matrix_operators.ts

@@ -222,6 +222,10 @@ export function add_vec3(u:vec3, v:vec3): vec3{
     return vec3(u[0]+v[0],u[1]+v[1],u[2]+v[2]);
 }
 
+export function sub_vec3(u:vec3,v:vec3):vec3{
+    return vec3(u[0]-v[0],u[1]-v[1],u[2]-v[2]);
+}
+
 
 export function add_mat(u:ArrayType, v:ArrayType):ArrayType{
     const out:ArrayType = new ArrayType(u.length);

src/rendering/process_lighting.ts

@@ -1,4 +1,4 @@
-import { length_vec3, mul_mat4_vec4, mul_mat4_vec4_mut } from "../math/matrix_operators";
+import { length_vec3, mul_mat4_vec4, mul_mat4_vec4_mut, sub_vec3 } from "../math/matrix_operators";
 import { ArrayType, mat4, vec3, vec4 } from "../math/types";
 import type { Light } from "./types/light";
 import type { Mesh } from "./types/mesh";
@@ -9,18 +9,17 @@ export function process_lighting(mesh:Mesh, scene:Scene){
     const world_coordinates = mesh.projected_buffer;
     const lights = scene.lights;
     let vertex:vec3 = vec3(0,0,0);
+    const k = 0.01;
     for(let i = 0; i < world_coordinates.length; i+=4){
         vertex[0] = world_coordinates[i];
         vertex[1] = world_coordinates[i+1];
         vertex[2] = world_coordinates[i+2];
         let color = vec3(0,0,0);
-        let intensity = 0;
         for(const light of lights){
-            vertex[0] -= light.position[0];
-            vertex[1] -= light.position[1];
-            vertex[2] -= light.position[2];
-            const dist = length_vec3(vertex);
-
+            const L = sub_vec3(vertex,light.position);
+            const dist = length_vec3(L);
+            if (dist > light.radius) continue;
+            
         }
     }
 }

src/rendering/types/geometry.ts

@@ -4,9 +4,46 @@ import { ArrayType, IndexingType } from "../../math/types";
 export class Geometry{
     vertices:ArrayType;
     indices:IndexingType;
-
+    normals:ArrayType;
     constructor(vertices:ArrayType, indices:IndexingType){
         this.vertices = vertices;
-        this.indices = indices;
+        this.indices = indices; 
+        this.normals = new ArrayType(this.vertices.length);
+        this.compute_normals();
+    }
+    private compute_normals() {
+        const inds = this.indices;
+        const verts = this.vertices;
+        const norms = this.normals;
+
+        norms.fill(0);
+
+        for (let i = 0; i < inds.length; i += 3) {
+            const i1 = inds[i] * 3;
+            const i2 = inds[i+1] * 3;
+            const i3 = inds[i+2] * 3;
+
+            const ux = verts[i2] - verts[i1];
+            const uy = verts[i2+1] - verts[i1+1];
+            const uz = verts[i2+2] - verts[i1+2];
+
+            const vx = verts[i3] - verts[i1];
+            const vy = verts[i3+1] - verts[i1+1];
+            const vz = verts[i3+2] - verts[i1+2];
+
+            const nx = uy * vz - uz * vy;
+            const ny = uz * vx - ux * vz;
+            const nz = ux * vy - uy * vx;
+
+            norms[i1] += nx; norms[i1+1] += ny; norms[i1+2] += nz;
+            norms[i2] += nx; norms[i2+1] += ny; norms[i2+2] += nz;
+            norms[i3] += nx; norms[i3+1] += ny; norms[i3+2] += nz;
+        }
+        for (let i = 0; i < norms.length; i += 3) {
+            const len = Math.sqrt(norms[i]**2 + norms[i+1]**2 + norms[i+2]**2);
+            if (len > 0.0001) {
+                norms[i] /= len; norms[i+1] /= len; norms[i+2] /= len;
+            }
+        }
     }
 }

src/rendering/types/mesh.ts

@@ -1,20 +1,25 @@
-import { ArrayType, IndexingType, vec3 } from "../../math/types";
+import { mul_mat4_vec4 } from "../../math/matrix_operators";
+import { ArrayType, IndexingType, mat4, vec3, vec4 } from "../../math/types";
 import type { Geometry } from "./geometry";
 
 
 export class Mesh{
     vertices: ArrayType
     indices: IndexingType
+    local_normals: ArrayType
     projected_buffer: ArrayType
     raster_buffer: ArrayType
     color_buffer: ArrayType
+    normals: ArrayType;
     albedo: vec3;
     raster_end:number
     visible_triangles_count:number
 
     constructor(geometry:Geometry, albedo:vec3 = vec3(0,0,0), raster_buffer:ArrayType | null = null, projected_buffer:ArrayType | null = null, color_buffer:ArrayType | null = null){
         this.vertices = geometry.vertices;
         this.indices = geometry.indices;
+        this.local_normals = geometry.normals;
+        this.normals = new ArrayType(geometry.normals.length);
         if(projected_buffer === null)
             this.projected_buffer = new ArrayType(this.vertices.length * 4 / 3);
         else
@@ -33,5 +38,18 @@ export class Mesh{
         this.raster_end = this.indices.length * 4;
         this.visible_triangles_count = 0;
     }
+    update_normals(model: mat4) {
+        let temp_n = vec4(0,0,0,0);
+        for (let i = 0; i < this.normals.length; i += 3) {
+            temp_n[0] = this.local_normals[i];
+            temp_n[1] = this.local_normals[i+1];
+            temp_n[2] = this.local_normals[i+2];
+            temp_n[3] = 0;
+            const world_n = mul_mat4_vec4(model, temp_n);
+            this.normals[i]   = world_n[0];
+            this.normals[i+1] = world_n[1];
+            this.normals[i+2] = world_n[2];
+        }
+    }
+}
 
-}

src/rendering/types/scene.ts

@@ -43,9 +43,10 @@ export class Scene{
      * @param max_triangles The maximum number of triangles this Scene object can store. 
      */
     reserve(max_triangles:number){
-        this.scene_buffer = new ArrayType(max_triangles * 9);
+        this.scene_buffer = new ArrayType(max_triangles * 12);
         this.projected_buffer = new ArrayType(max_triangles * 12);
         this.draw_order = new IndexingType(max_triangles);
+        this.color_buffer = new ArrayType(max_triangles*3);
         this.draw_end = 0;
         this.meshes = [];
         this.lights = [];

src/rendering/utils/primitives.ts

@@ -1,7 +1,7 @@
 import { ArrayType, IndexingType } from "../../math/types";
 import { Geometry } from "../types/geometry";
 
-export function create_sphere(radius: number, rings: number, slices: number):{vertices:ArrayType, indices: IndexingType} {
+export function create_sphere(radius: number, rings: number, slices: number):Geometry {
     const vertice_count = (rings + 1) * (slices + 1) * 3;
     const vertices = new ArrayType(vertice_count);
     const indices = new IndexingType(rings * slices * 6);

src/to_html.ts

@@ -1,5 +1,5 @@
 import type { ArrayType } from "./math/types";
-import type { Scene } from "./rendering/scene";
+import type { Scene } from "./rendering/types/scene";
 import { character_to_uint, SB_TOKENS, string_to_uint, type StringBuffer } from "./utils/string_buffer";
 
 export type vec3 = [number,number,number];