ray tracing and utils partially fixed

index.html

@@ -15,6 +15,6 @@
     <script type="module" src="/src/cg/perspectiveDivide.ts"></script>
     <script type="module" src="/src/cg/walkToVec.ts"></script>
     <script type="module" src="/src/cg/basis.ts"></script-->
-    <script type="module" src="/src/cg/loadBunnyDemo.ts"></script>
+    <script type="module" src="/src/cg/raytracing1.ts"></script>
   </body>
 </html>

src/cg/basis.ts

 import Playground from "./playground";
 import { vecAdd } from "./utils";
-import { vecMultiply } from "./utils";
+import { vecMultiplyScalar } from "./utils";
 
 const pg = new Playground();
 pg.gridXZ();
@@ -8,7 +8,7 @@ pg.gridXZ();
 const initialVec = [1.5, 2, 0.3];
 
 let basis = [1, 2, 1];
-basis = vecMultiply(basis, 0.5);
+basis = vecMultiplyScalar(basis, 0.5);
 const iHat = [basis[0], 0, 0];
 const jHat = [0, basis[1], 0];
 const kHat = [0, 0, basis[2]];

src/cg/raytracing1.ts

 import Playground from "./playground";
+import { vecDotProduct, vecMultiplyScalar, vecSubtract } from "./utils";
+
 const pg = new Playground();
 
 const sphere = {
-    position: [0, .5, -3],
-    radius: 1.23
+    position: [0, .5, -3], //C - Center of sphere
+    radius: 0.5
 }
 pg.visCamera(-1);
 pg.gridXZ()
 
-const o = [0, 0, 0]
-const co = ... // O - C
+const o = [0, 0, 0]; //O - Origin
+const co = vecSubtract(o, sphere.position) // O - C
+const rsq = sphere.radius * sphere.radius;
 
 const step = 1 / 8
 
@@ -18,25 +21,25 @@ for (let yCoord = -1; yCoord <= 1; yCoord +=  step) {
     for (let xCoord = -1; xCoord <= 1; xCoord +=  step) {
 
         const v = [xCoord, yCoord, -1]
-        const ov = ... // V - O
+        const ov = vecSubtract(v, o); // V - O
 
         pg.visVector(ov)
 
-        const a = ... // <---- see equations above
-        const b = ... // <---- see equations above
-        const c = ... // <---- see equations above
+        const a = vecDotProduct(ov, ov); // a = (V - O)*(V _ O)
+        const b = 2* vecDotProduct(ov, co); // b = 2 * ((V - O)*(O - C))
+        const c = vecDotProduct(co, co) - rsq; // c = ((O - C)*(O - C))-r^2
  
-        const discriminant = ... // <---- see equations above
+        const discriminant = (b*b) - (4*a*c); // b^2 - 4*a*c
 
         const t1 = (-b + Math.sqrt(discriminant)) / (2 * a)
         const t2 = (-b - Math.sqrt(discriminant)) / (2 * a)
         
         if (t1) {
-            pg.visPoint(vecMultiplyScalar(t1, v),{color:"red"});
+            pg.visPoint(vecMultiplyScalar(v, t1),{color:"red"});
         }
 
         if (t2) {
-            pg.visPoint(vecMultiplyScalar(t2, v),{color:"blue"});
+            pg.visPoint(vecMultiplyScalar(v, t2),{color:"blue"});
         }
 
     }

src/cg/utils.ts

@@ -11,21 +11,47 @@ export function vecAdd(vecOne: Array<number>, vecTwo: Array<number>){
 }
 
 export function vecSubtract(vecOne: Array<number>, vecTwo: Array<number>){
-    let vecSubt: Array<number> = vecOne;
+    //let vecSubt: Array<number> = vecOne;
 
-    vecSubt[0] -= vecTwo[0];
+    /*vecSubt[0] -= vecTwo[0];
     vecSubt[1] -= vecTwo[1];
     vecSubt[2] -= vecTwo[2];
 
+    return vecSubt;*/
+
+    return[
+        vecOne[0] - vecTwo[0],
+        vecOne[1] - vecTwo[1],
+        vecOne[2] - vecTwo[2]
+    ]
+}
+
+export function vecNumSubtract(vecOne: Array<number>, number: number){
+    let vecSubt: Array<number> = vecOne;
+
+    vecSubt[0] -= number;
+    vecSubt[1] -= number;
+    vecSubt[2] -= number;
+
     return vecSubt;
 }
 
-export function vecMultiply(vecOne: Array<number>, factor: number){
-    vecOne[0] *= factor;
-    vecOne[1] *= factor;
-    vecOne[2] *= factor;
+export function vecMultiplyScalar(vecOne: Array<number>, scalar: number){
+    return[
+        vecOne[0] * scalar,
+        vecOne[1] * scalar,
+        vecOne[2] * scalar,
+    ]
+}
+
+export function vecMultiply(vecOne: Array<number>, vecTwo: Array<number>){
+    let vecMultiplied: Array<number> = [];
+
+    vecMultiplied[0] = vecOne[0] * vecTwo[0];
+    vecMultiplied[1] = vecOne[1] * vecTwo[1];
+    vecMultiplied[2] = vecOne[2] * vecTwo[2];
 
-    return vecOne;
+    return vecMultiplied;
 }
 
 export function vecLength(vec: Array<number>){
@@ -50,8 +76,10 @@ export function vecNormalize(vec: Array<number>){
 }
 
 export function vecDotProduct(vecOne: Array<number>, vecTwo: Array<number>){
-    let dotProduct = vecOne[0]*vecTwo[0] + vecOne[1]*vecTwo[1] + vecOne[2]*vecTwo[2];
-    return dotProduct;
+    //let dotProduct = vecOne[0]*vecTwo[0] + vecOne[1]*vecTwo[1] + vecOne[2]*vecTwo[2];
+    return(
+        vecOne[0]*vecTwo[0] + vecOne[1]*vecTwo[1] + vecOne[2]*vecTwo[2]
+    )
 }
 
 export function vecAngle(vecOne: Array<number>, vecTwo: Array<number>){