common/se3.js

@@ -86,42 +86,6 @@ export function orientationOnly(m) {
     ];
 }
 
-export function fromBases(x, y, z) {
-    return [
-        x[0], x[1], x[2], 0,
-        y[0], y[1], y[2], 0,
-        z[0], z[1], z[2], 0,
-        0, 0, 0, 1,
-    ];
-}
-
-export function positionOnly(m) {
-    return [
-        1, 0, 0, 0,
-        0, 1, 0, 0,
-        0, 0, 1, 0,
-        m[12], m[13], m[14], m[15],
-    ]
-}
-
-export function setOrientation(m, o) {
-    return [
-        o[0], o[1], o[2], m[3],
-        o[4], o[5], o[6], m[7],
-        o[8], o[9], o[10], m[11],
-        m[12], m[13], m[14], m[15],
-    ];
-}
-
-export function setPosition(m, x) {
-    return [
-        m[0], m[1], m[2], m[3],
-        m[4], m[5], m[6], m[7],
-        m[8], m[9], m[10], m[11],
-        x[0], x[1], x[2], 1,
-    ];
-}
-
 export function inverse(m) {
     const t = apply(m, [0, 0, 0, 1]);
     const r = orientationOnly(m);

skycraft/chunk.ts

@@ -4,7 +4,7 @@ import {memoize} from 'wmc-common/memoize';
 
 type direction = ('-x' | '+x' | '-y' | '+y' | '-z' | '+z');
 
-export const BlockType = {
+const BlockType = {
     UNDEFINED: 0,
     AIR: 1,
     DIRT: 2,
@@ -18,6 +18,7 @@ export const BlockType = {
 
 const CHUNKSIZE = 32;
 
+
 /** seed: some kind of number uniquely defining the body
  *  x, y, z: space coordinates in the body's frame
  *
@@ -303,115 +304,10 @@ function getBodyChunks(seed: number) {
     return chunks;
 }
 
-/** fake chunk map re-using the memoize */
-class ChunkMap {
-    constructor(seed) {
-        this.seed = seed;
-    }
-
-    get(i, j, k) {
-        return getChunk(this.seed, i, j, k);
-    }
-
-    has(i, j, k) {
-        return getChunk(this.seed, i, j, k) !== undefined;
-    }
-}
-
 export function getBodyGeometry(seed: number) {
     const faces = getBodyChunks(seed)
         .filter(chunk => !chunk.underground)
         .map(chunk => [...makeChunkFaces(chunk)]);
 
-    return {
+    return faces.reduce((a, b) => a.concat(b));
-        faces: faces.reduce((a, b) => a.concat(b)),
-        chunkMap: new ChunkMap(seed),
-    };
-}
-
-function blockLookup(chunkMap, x, y, z) {
-    const chunki = Math.floor((x + CHUNKSIZE / 2) / CHUNKSIZE);
-    const chunkj = Math.floor((y + CHUNKSIZE / 2) / CHUNKSIZE);
-    const chunkk = Math.floor((z + CHUNKSIZE / 2) / CHUNKSIZE);
-
-    const chunk = chunkMap.get(chunki, chunkj, chunkk);
-    if (chunk === undefined) {
-        return {
-            type: BlockType.UNDEFINED,
-        };
-    }
-
-    const i = Math.floor(x - chunk.position[0] + 0.5);
-    const j = Math.floor(y - chunk.position[1] + 0.5);
-    const k = Math.floor(z - chunk.position[2] + 0.5);
-
-    const blockIndex = CHUNKSIZE * (CHUNKSIZE * i + j) + k;
-
-    return {
-        type: chunk.blocks[blockIndex],
-        centerPosition: [
-            chunk.position[0] + i,
-            chunk.position[1] + j,
-            chunk.position[2] + k,
-        ],
-        chunk,
-        blockIndex,
-    };
-}
-
-function movePoint(p, s, u) {
-    return linalg.add(p, linalg.scale(u, s));
-}
-
-function minIndex(arr) {
-    return arr.reduce((min, val, i) => val >= arr[min] ? min : i, -1);
-}
-
-/** Imported from wmc, looks like it calculates the distance to the next grid block */
-function rayThroughGrid(origin, direction, maxDistance) {
-    const range = i => [...Array(i).keys()];
-
-    const nextGrid = range(3).map(i => direction[i] > 0 ?
-        Math.floor(origin[i] + 0.5) + 0.5 :
-        Math.floor(origin[i] + 0.5) - 0.5);
-    const distanceToGrid = range(3).map(i => (nextGrid[i] - origin[i]) / direction[i])
-        .map(v => v === 0.0 ? Number.POSITIVE_INFINITY : v);
-    const axis = minIndex(distanceToGrid);
-    const rayLength = distanceToGrid[axis];
-
-    if (rayLength > maxDistance) {
-        return {};
-    }
-
-    const position = movePoint(origin, distanceToGrid[axis], direction);
-    const normal = range(3).map(i => i === axis ? -Math.sign(direction[i]) : 0);
-
-    return {position, normal, distance: rayLength};
-}
-
-/** needs a blockLookup function, finds the first non-air block along a ray */
-export function castRay(chunkMap, origin, direction, maxDistance=CHUNKSIZE) {
-    let currentPoint = origin;
-
-    while (maxDistance > 0) {
-        const {position, normal, distance} = rayThroughGrid(currentPoint, direction, maxDistance);
-
-        if (position === undefined) {
-            return;
-        }
-
-        maxDistance -= distance;
-        currentPoint = movePoint(position, 0.01, direction);
-        const blockCenter = movePoint(position, -0.5, normal);
-        const block = blockLookup(chunkMap, ...blockCenter);
-
-        if (block.type === BlockType.AIR) {
-            continue;
-        }
-
-        return {
-            block,
-            normal,
-        };
-    }
 }

skycraft/draw.ts

@@ -250,7 +250,7 @@ function getObjects(context, body, parentPosition = undefined) {
     const {position, orientation, glowColor, specularColor} = body;
 
     if (body.glBuffer === undefined) {
-        body.glBuffer = makeBufferFromFaces(gl, body.geometry.faces);
+        body.glBuffer = makeBufferFromFaces(gl, body.geometry);
     }
 
     objects.push({
@@ -263,21 +263,14 @@ function getObjects(context, body, parentPosition = undefined) {
     });
     if (parentPosition !== undefined) {
         const orbitObject = makeOrbitObject(gl, context.orbitGlContext, body.orbit, parentPosition);
-        //objects.push(orbitObject);
+        objects.push(orbitObject);
     } else {
-        const tfs = [player.tf];
-        if (context.landed) {
-            const body = context.landedBody;
-            const bodyTf = se3.product(se3.translation(...body.position), body.orientation);
-            tfs.splice(0, 0, bodyTf);
-        }
-        const tf = tfs.reduce(se3.product);
         const shipOrientation = [
-            se3.rotationOnly(tf),
+            se3.rotationOnly(player.tf),
             //se3.rotationOnly(context.camera.tf),
             se3.rotxyz(-Math.PI / 2, Math.PI / 2, Math.PI / 2),
         ].reduce(se3.product);
-        const shipPos = se3.apply(tf, [0, 0, 0, 1]);
+        const shipPos = player.position;
         objects.push({
             geometry: makeBufferFromFaces(gl, context.spaceship),
             orientation: shipOrientation,
@@ -304,7 +297,7 @@ export function draw(context) {
     const {gl, camera, player, universe, orbit, orbitGlContext, orbitBody} = context;
     const {skyColor, ambiantLight, projMatrix} = context;
     const objects = getObjects(context, universe); 
-    if (orbit !== undefined && orbit.excentricity < 1 && !context.landing) {
+    if (orbit !== undefined && orbit.excentricity < 1) {
         objects.push(makeOrbitObject(gl, orbitGlContext, orbit, orbitBody.position));
     }
 
@@ -320,18 +313,11 @@ export function draw(context) {
 
     gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
-    const playerView = [
+    const viewMatrix = se3.inverse([
         player.tf,  // player position & orientation
         camera.tf,  // camera orientation relative to player
         se3.translation(0, 1, 4),  // step back from the player
-    ];
+    ].reduce(se3.product));
-    if (context.landed) {
-        const body = context.landedBody;
-        const bodyTf = se3.product(se3.translation(...body.position), body.orientation);
-        playerView.splice(0, 0, bodyTf);
-    }
-
-    const viewMatrix = se3.inverse(playerView.reduce(se3.product));
     let lastGlContext;
 
     for (const {position, orientation, geometry, glContext, glowColor, specularColor} of objects) {

skycraft/index.ts

@@ -3,8 +3,8 @@ import { makeFace } from 'wmc-common/geometry';
 import * as linalg from './linalg';
 import { loadObjModel } from './obj';
 import * as se3 from 'wmc-common/se3';
-import { computeOrbit, findSoi, getCartesianState, updateBodyPhysics, isInSoi } from './orbit';
+import { computeOrbit, findSoi, getCartesianState, updateBodyPhysics } from './orbit';
-import { getBodyGeometry, castRay, BlockType } from './chunk';
+import { getBodyGeometry } from './chunk';
 import { draw, getOrbitDrawContext, initWorldGl } from './draw';
 import * as quat from './quat';
 
@@ -157,10 +157,18 @@ function initUiListeners(canvas: HTMLCanvasElement, context) {
                         delete context.orbit;
                         return false;
                     case 'KeyL':
-                        context.landing = !context.landing;
+                        if (closeToPlanet(context)) {
+                            context.landing = True;
+                        }
                         return false;
                     case 'Space':
-                        context.pause = !context.pause;
+                        if (!context.flying) {
+                            if (context.jumpAmount > 0) {
+                                const amount = context.jumpForce;
+                                context.player.velocity[1] = amount;
+                                context.jumpAmount -= 1;
+                            }
+                        }
                         return false;
                 }
             } else {
@@ -228,16 +236,6 @@ function handleInput(context) {
         }
     };
 
-    const roll = (amount: number) => {
-        if (context.keys.has('ShiftLeft')) {
-            amount *= 10;
-        }
-        context.camera.tf =[
-            context.camera.tf,
-            se3.rotz(amount),
-        ].reduce(se3.product);
-    };
-
     context.keys.forEach(key => {
         switch (key) {
             case 'KeyW':
@@ -252,12 +250,6 @@ function handleInput(context) {
             case 'KeyD':
                 move(0.0, 0.5);
                 return;
-            case 'KeyQ':
-                roll(0.02);
-                return;
-            case 'KeyE':
-                roll(-0.02);
-                return;
             case 'KeyR':
                 context.timeOffset += 1;
                 return;
@@ -267,120 +259,15 @@ function handleInput(context) {
 
 function slerp(current: linalg.Mat4, target: linalg.Mat4, maxVelocity: number) : linalg.Mat4 {
     const q0 = quat.mat2Quat(current);
-    let q1 = quat.mat2Quat(target);
+    const q1 = quat.mat2Quat(target);
 
     const dq = quat.diff(q1, q0);
     const maxt = maxVelocity / quat.norm(dq);
 
-    //const q = quat.normalize(quat.add(q0, quat.scale(dq, Math.min(1, maxt))));
+    const q = quat.normalize(quat.add(q0, quat.scale(dq, Math.min(1, maxt))));
-    const t = maxVelocity;
-    if (quat.dot(q0, q1) < 0) {
-        q1 = quat.scale(q1, -1);
-    }
-    const q = quat.normalize(quat.add(quat.scale(q0, 1 - t), quat.scale(q1, t)));
     return quat.quat2Mat(q);
 }
 
-function distanceToGround(body: Body, position: number[], direction: number[]) : number {
-    const inChunkOrientation = se3.inverse(body.orientation);
-    const toChunk = vec => se3.apply(inChunkOrientation, vec.concat([0]));
-    const directionInChunk = toChunk(direction);
-    const positionInChunk = toChunk(linalg.diff(position, body.position));
-
-    const hit = castRay(body.geometry.chunkMap, positionInChunk, directionInChunk);
-
-    if (hit === undefined || hit.block.type === BlockType.UNDEFINED || hit.block.type === undefined) {
-        const ray = linalg.diff(position, body.position);
-        return {
-            distance: linalg.norm(ray),
-            normal: linalg.normalize(ray),
-        };
-    }
-    
-    const distance = linalg.norm(linalg.diff(positionInChunk, hit.block.centerPosition));
-    const normal = se3.apply(body.orientation, hit.normal.concat([0]));
-    return {distance, normal};
-}
-
-function autoLand(context) {
-    const p = context.player;
-    // 0. check prereqs:
-    //   - none
-    // 1. adjust tangential speed to match body rotational
-    // 2. cast ray towards center
-    // 3. while high, go towards center
-    // 4. when low, go towards ground
-    // 5. stop when on ground
-    const kShipRotateSpeed = 0.1;
-
-    const body = findSoi(context.universe, p.position);
-    const toBodyCenter = linalg.diff(body.position, p.position);
-    const {distance: altitude, normal: surfaceNormal} = distanceToGround(body, p.position, linalg.normalize(toBodyCenter));
-
-    // figure out tangential speed
-    const spinSpeed = linalg.add(body.velocity, linalg.cross(body.spin, linalg.scale(toBodyCenter, -1)));
-    const dv = linalg.diff(spinSpeed, p.velocity);
-    // remove vertical component
-    const vertical = linalg.scale(surfaceNormal, -linalg.dot(dv, surfaceNormal));
-    const smallDv = linalg.scale(linalg.add(dv, vertical), 0.01);
-//    const smallDv = linalg.scale(dv, 0.05);
-    p.velocity = linalg.add(p.velocity, smallDv);
-
-    // up is up
-    const shipZ = se3.apply(p.tf, [0, 0, 1, 0]);
-    const ny = surfaceNormal;
-    const nx = linalg.normalize(linalg.cross(ny, shipZ));
-    const nz = linalg.normalize(linalg.cross(nx, ny));
-
-    const targetOrientation = se3.fromBases(nx, ny, nz);
-    const currentOrientation = slerp(p.tf, targetOrientation, kShipRotateSpeed);
-    p.tf = se3.setOrientation(p.tf, currentOrientation);
-
-    if (altitude < 1.5) {
-        const upward = linalg.dot(linalg.diff(p.velocity, body.velocity), surfaceNormal);
-        if (upward < -2) {
-            p.velocity = linalg.add(p.velocity, linalg.scale(surfaceNormal, -2*upward));
-            context.landing = false;
-        } else if (upward < 0) {
-            context.landed = true;
-            context.landedBody = body;
-
-            p.tf = [
-                se3.inverse(body.orientation),
-                se3.inverse(se3.translation(...body.position)),
-                p.tf,
-            ].reduce(se3.product);
-            p.velocity = [0, 0, 0];
-            p.position = se3.apply(p.tf, [0, 0, 0, 1]);
-        }
-    }
-//    p.velocity = linalg.add(p.velocity, linalg.scale(surfaceNormal, dvup));
-}
-
-function effectiveGravity(position: number[], rootBody: Body) : number[] {
-    let body = rootBody;
-    let acceleration = [0, 0, 0];
-    while (body !== undefined) {
-        const toBodyCenter = linalg.diff(body.position, position);
-        const d = linalg.norm(toBodyCenter);
-        const gravity = body.mass / d**3;
-        acceleration = linalg.add(acceleration, linalg.scale(toBodyCenter, gravity));
-
-        const parentMass = body.mass;
-        const children = body.children || [];
-        body = undefined;
-        for (const child of children) {
-            if (!isInSoi(child, parentMass, position)) {
-                continue;
-            }
-            body = child;
-            break;
-        }
-    }
-
-    return acceleration;
-}
-
 function updatePhysics(time: number, context) {
     const {player} = context;
     const dt = time - (context.lastTime || 0);
@@ -388,41 +275,37 @@ function updatePhysics(time: number, context) {
 
     player.position = se3.apply(player.tf, [0, 0, 0, 1]);
 
-    if (!context.pause) {
     updateBodyPhysics(time, context.universe);
-    }
 
-    const kShipRotateSpeed = 0.1;
+    const dr = slerp(se3.identity(), context.camera.tf, 0.007);
-
-    if (context.landed) {
-        return; // TODO: implement
-    }
-
-    if (context.landing) {
-        autoLand(context);
-    } else {
-        // allow acdjusting camera
-        const dr = slerp(se3.identity(), context.camera.tf, kShipRotateSpeed);
     player.tf = se3.product(player.tf, dr);
     context.camera.tf = se3.product(context.camera.tf, se3.inverse(dr));
-    }
-
-    if (context.flying) {
-        // no physics, just magically moving around
-        return;
-    }
-
-    const gravity = effectiveGravity(player.position, context.universe);
-    player.velocity = linalg.add(player.velocity, linalg.scale(gravity, dt));
-
-    const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
-    player.tf = se3.setPosition(player.tf, newPos);
 
+    if (!context.flying) {
         if (context.orbit === undefined) {
+            const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
+            const dx = linalg.diff(newPos, player.position);
+            player.tf = se3.product(se3.translation(...dx), player.tf);
+
             const body = findSoi(context.universe, context.player.position);
             context.orbit = computeOrbit(player, body, time);
             console.log(`orbiting ${body.name}, excentricity: ${context.orbit.excentricity}`);
             context.orbitBody = body;
+        } else {
+            const {position: orbitPos, velocity: orbitVel} = getCartesianState(
+                context.orbit, context.orbitBody.mass, time);
+            if (orbitPos === undefined) {
+                const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
+                const dx = linalg.diff(newPos, player.position);
+                player.tf = se3.product(se3.translation(...dx), player.tf);
+            } else {
+                const position = linalg.add(orbitPos, context.orbitBody.position);
+                const velocity = linalg.add(orbitVel, context.orbitBody.velocity);
+                player.velocity = velocity;
+                const dx = linalg.diff(position, player.position);
+                player.tf = se3.product(se3.translation(...dx), player.tf);
+            }
+        }
     }
 }
 
@@ -453,16 +336,14 @@ function tick(time: number, context) {
 }
 
 function makeCube(texture) {
-    return {
+    return [
-        faces: [
         makeFace('-x', texture, [-0.5, 0, 0]),
         makeFace('+x', texture, [+0.5, 0, 0]),
         makeFace('-y', texture, [0, -0.5, 0]),
         makeFace('+y', texture, [0, +0.5, 0]),
         makeFace('-z', texture, [0, 0, -0.5]),
         makeFace('+z', texture, [0, 0, +0.5]),
-        ]
+    ];
-    };
 }
 
 async function main() {
@@ -518,6 +399,7 @@ async function main() {
     initUiListeners(canvas, context);
 
     const starshipGeom = await modelPromise;
+    console.log(`loaded ${starshipGeom.length} triangles`);
 
     context.spaceship = starshipGeom;
 

skycraft/linalg.ts

@@ -39,7 +39,3 @@ export function scale(a: Vec3, s: number) : Vec3 {
         a[2] * s,
     ];
 }
-
-export function normalize(a: Vec3) : Vec3 {
-    return scale(a, 1/norm(a));
-}

skycraft/orbit.ts

@@ -52,14 +52,6 @@ export function updateBodyPhysics(time: number, body: Body, parentBody : Body |
     }
 }
 
-export function isInSoi(body: Body, parentMass: number, position: number[]) : boolean {
-    const soi = body.orbit.semimajorAxis * Math.pow(body.mass / parentMass, 2/5);
-    const pos = position;
-    const bod = body.position;
-    const dr = [pos[0] - bod[0], pos[1] - bod[1], pos[2] - bod[2]];
-    return (dr[0]**2 + dr[1]**2 + dr[2]**2 < soi**2);
-}
-
 export function findSoi(rootBody: Body, position: number[]) : Body {
     const bodies = [rootBody];
     let body : Body;
@@ -71,7 +63,11 @@ export function findSoi(rootBody: Body, position: number[]) : Body {
         }
 
         for (const child of body.children) {
-            if (isInSoi(child, body.mass, position)) {
+            const soi = child.orbit.semimajorAxis * Math.pow(child.mass / body.mass, 2/5);
+            const pos = position;
+            const bod = child.position;
+            const dr = [pos[0] - bod[0], pos[1] - bod[1], pos[2] - bod[2]];
+            if (dr[0]**2 + dr[1]**2 + dr[2]**2 < soi**2) {
                 bodies.push(child);
             }
         }

skycraft/quat.ts

@@ -122,7 +122,3 @@ export function scale(q: Quat, a: number): Quat {
         w: a * q.w,
     };
 }
-
-export function dot(q0: Quat, q1: Quat): number {
-    return q0.x*q1.x + q0.y*q1.y + q0.z*q1.z + q0.w*q1.w;
-}