Added new primitives

Author: Sekqies

index.html

@@ -42,9 +42,8 @@
     stroke-width ="0.01"
     id="model-preview-container"
     shape-rendering ="optimizeSpeed"
-    >
-</svg>
-
+>       
 
+</svg>
 </body>
 </html>

src/main.ts

@@ -12,7 +12,6 @@ import { Light } from "./rendering/types/light";
 import { parse_obj } from "./utils/parser";
 import type { Geometry } from "./rendering/types/geometry";
 
-let uploaded_geometry:Geometry|null = null;
 
 function generate_random_lights(LIGHT_COUNT:number, scene:Scene){
     const lights = [];
@@ -40,7 +39,6 @@ function generate_random_lights(LIGHT_COUNT:number, scene:Scene){
 
 let animation_id:number|null = null;
 
-
 const frame_max = 1000;
 let frame_count = 0;
 
@@ -52,8 +50,10 @@ export function main_3d() {
     if (!target) return;
     const wireframe_el = document.getElementById('wireframe-mode') as HTMLInputElement;
 
-    const sun_geo = create_sphere(1.5, 32, 32); 
-    const planet_geo = create_sphere(0.5, 16, 16);
+    const RESOLUTION = 32;
+
+    const sun_geo = create_sphere(1.5, RESOLUTION, RESOLUTION); 
+    const planet_geo = create_sphere(0.5, RESOLUTION/2, RESOLUTION/2);
     const bulb_geo = create_sphere(0.15, 8, 8); 
 
     const scene: Scene = new Scene(sun_geo.indices.length + planet_geo.indices.length + bulb_geo.indices.length*32);
@@ -207,7 +207,7 @@ const preview_loop = () => {
 
     render_scene(scene, [mul_mat4(vp, model_matrix)], true);
 
-    target.innerHTML = build_scene(scene, true, string_buffer);
+    target.innerHTML = build_scene(scene, false, string_buffer);
     preview_animation_id = requestAnimationFrame(preview_loop);
 };
 

src/rendering/types/node.ts

@@ -0,0 +1,14 @@
+import type { mat4 } from "../../math/types";
+import type { Mesh } from "./mesh";
+
+class Node{
+    mesh:Mesh;
+    model:mat4;
+    mvp:mat4;
+
+    constructor(mesh:Mesh, model:mat4, mvp:mat4){
+        this.mesh = mesh;
+        this.model = model;
+        this.mvp = mvp;
+    }
+}

src/rendering/utils/primitives.ts

@@ -1,4 +1,6 @@
-import { ArrayType, IndexingType } from "../../math/types";
+import { identity, rotate, translate } from "../../math/transformations";
+import { ArrayType, IndexingType, mat4, vec3, vec4 } from "../../math/types";
+import { transform_vertex_mutate } from "../clip_space/vertex";
 import { Geometry } from "../types/geometry";
 
 export function create_sphere(radius: number, rings: number, slices: number):Geometry {
@@ -41,4 +43,198 @@ export function create_sphere(radius: number, rings: number, slices: number):Geo
         }
     }
     return new Geometry(vertices,indices);
+}
+
+
+export function create_flat_ngon(n:number, side_length:number, axis:vec3 | null = null, angle:number | null = null, translate_vec:vec3 | null =null) : Geometry{
+    if(n<=2){
+        console.warn("Invalid n - There are no polygons of dimension 2 or less.");
+        throw new Error("Cannot create a polygon with less than 3 sides.");
+    }
+
+    const vertice_count = n + 1;
+    const triangle_count = n * 3;
+
+    const vertices = new ArrayType(vertice_count * 3);
+    const indices = new IndexingType(triangle_count);
+
+    vertices[0] = 0;
+    vertices[1] = 0;
+    vertices[2] = 0;
+
+    const radius = side_length / (2 * Math.sin(Math.PI / n));
+    const theta_step = (Math.PI * 2) / n
+
+    let vert_i = 3;
+
+    for(let i = 0; i < n; ++i){
+        const theta = theta_step * i;
+        vertices[vert_i++] = Math.cos(theta) * radius;
+        vertices[vert_i++] = Math.sin(theta) * radius;
+        vertices[vert_i++] = 0;
+    }
+
+    let ind_i = 0;
+
+    for(let i = 1; i <= n; ++i){
+        indices[ind_i++] = 0;
+        indices[ind_i++] = i;
+        indices[ind_i++] = (i === n) ? 1 : i + 1;
+    }
+    let transform:mat4 = identity();
+
+    if(angle && axis)
+        transform = rotate(transform,angle,axis);
+    if(translate_vec)
+        transform = translate(transform,translate_vec);
+
+    let vert = vec3(0,0,0);
+    let out = vec4(0,0,0,0);
+    for(let i = 0; i < vertices.length; i+=3){
+        vert[0] = vertices[i]; vert[1] = vertices[i+1]; vert[2] = vertices[i+2];
+        transform_vertex_mutate(transform,vert,out);
+        vertices[i] = out[0]; vertices[i + 1] = out[1]; vertices[i + 2] = out[2];
+    }
+    return new Geometry(vertices,indices);
+}
+
+export function create_3d_ngon(
+    n: number, 
+    side_length: number, 
+    depth_length: number | null,
+    axis: vec3 | null = null, 
+    angle: number | null = null, 
+    translate_vec: vec3 | null = null
+): Geometry {
+    if (n <= 2) {
+        console.warn("Invalid n - There are no polygons of dimension 2 or less.");
+        throw new Error("Cannot create a polygon with less than 3 sides.");
+    }
+    let depth = side_length;
+    if(depth_length) 
+        depth = depth_length;
+
+    const vertice_count = 2 + (2 * n); 
+    
+    const triangle_count = n * 4; 
+
+    const vertices = new ArrayType(vertice_count * 3);
+    const indices = new IndexingType(triangle_count * 3);
+
+    const radius = side_length / (2 * Math.sin(Math.PI / n));
+    const theta_step = (Math.PI * 2) / n;
+
+    vertices[0] = 0; vertices[1] = 0; vertices[2] = -depth / 2;
+    vertices[3] = 0; vertices[4] = 0; vertices[5] = depth / 2;
+
+    let vert_i = 6;
+
+    for (let i = 0; i < n; i++) {
+        const theta = theta_step * i;
+        vertices[vert_i++] = Math.cos(theta) * radius;
+        vertices[vert_i++] = Math.sin(theta) * radius;
+        vertices[vert_i++] = -depth / 2;
+    }
+
+    for (let i = 0; i < n; i++) {
+        const theta = theta_step * i;
+        vertices[vert_i++] = Math.cos(theta) * radius;
+        vertices[vert_i++] = Math.sin(theta) * radius;
+        vertices[vert_i++] = depth / 2;
+    }
+
+    let ind_i = 0;
+
+    for (let i = 0; i < n; i++) {
+        const bottom_current = 2 + i;
+        const bottom_next = 2 + ((i + 1) % n);
+        const top_current = 2 + n + i;
+        const top_next = 2 + n + ((i + 1) % n);
+
+        indices[ind_i++] = 0;
+        indices[ind_i++] = bottom_next;
+        indices[ind_i++] = bottom_current;
+
+        indices[ind_i++] = 1;
+        indices[ind_i++] = top_current;
+        indices[ind_i++] = top_next;
+
+        indices[ind_i++] = bottom_current;
+        indices[ind_i++] = bottom_next;
+        indices[ind_i++] = top_current;
+
+        indices[ind_i++] = bottom_next;
+        indices[ind_i++] = top_next;
+        indices[ind_i++] = top_current;
+    }
+
+    let transform: mat4 = identity();
+
+    if (angle && axis) transform = rotate(transform, angle, axis);
+    if (translate_vec) transform = translate(transform, translate_vec);
+
+    let vert = vec3(0, 0, 0);
+    let out = vec4(0, 0, 0, 0); 
+    for (let i = 0; i < vertices.length; i += 3) {
+        vert[0] = vertices[i]; vert[1] = vertices[i + 1]; vert[2] = vertices[i + 2];
+        transform_vertex_mutate(transform, vert, out);
+        vertices[i] = out[0]; vertices[i + 1] = out[1]; vertices[i + 2] = out[2];
+    }
+
+    return new Geometry(vertices, indices);
+}
+
+
+
+export function create_torus(
+    inner_radius: number, 
+    outer_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); 
+
+    let vert_i = 0;
+    let ind_i = 0;
+
+    for (let ring = 0; ring <= rings; ring++) {
+        const phi = (ring * 2 * Math.PI) / rings; 
+        const sinPhi = Math.sin(phi);
+        const cosPhi = Math.cos(phi);
+
+        for (let slice = 0; slice <= slices; slice++) {
+            const theta = (slice * 2 * Math.PI) / slices; 
+            const sinTheta = Math.sin(theta);
+            const cosTheta = Math.cos(theta);
+
+            const x = (outer_radius + inner_radius * cosPhi) * cosTheta;
+            const y = inner_radius * sinPhi;
+            const z = (outer_radius + inner_radius * cosPhi) * sinTheta;
+
+            vertices[vert_i++] = x;
+            vertices[vert_i++] = y;
+            vertices[vert_i++] = z;
+        }
+    }
+
+    for (let ring = 0; ring < rings; ring++) {
+        for (let slice = 0; slice < slices; slice++) {
+            const first = (ring * (slices + 1)) + slice;
+            const second = first + slices + 1;
+
+            indices[ind_i++] = first;
+            indices[ind_i++] = second;
+            indices[ind_i++] = first + 1;
+
+            indices[ind_i++] = second;
+            indices[ind_i++] = second + 1;
+            indices[ind_i++] = first + 1;
+        }
+    }
+
+
+    return new Geometry(vertices, indices);
 }