skycraft: can walk around the earth

Once landed, position is locked to the body it landed on.
Not enough fuel to launch again.

common/se3.js

@@ -86,6 +86,42 @@ 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');
 
-const BlockType = {
+export const BlockType = {
     UNDEFINED: 0,
     AIR: 1,
     DIRT: 2,
@@ -18,7 +18,6 @@ const BlockType = {
 
 const CHUNKSIZE = 32;
 
-
 /** seed: some kind of number uniquely defining the body
  *  x, y, z: space coordinates in the body's frame
  *
@@ -304,10 +303,115 @@ 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 faces.reduce((a, b) => a.concat(b));
+    return {
+        faces: faces.reduce((a, b) => a.concat(b)),
+        chunkMap: new ChunkMap(seed),
+    };
+}
+
+export 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

@@ -122,8 +122,7 @@ export async function initWorldGl(gl: WebGLRenderingContext) {
 
     const drawObject = (objectParams) => {
         const {
-            position,
+            tf,
-            orientation,
             glBuffer,
             numVertices,
             lightDirection,
@@ -131,8 +130,7 @@ export async function initWorldGl(gl: WebGLRenderingContext) {
             specularColor,
         } = objectParams;
 
-        gl.uniformMatrix4fv(modelLoc, false, new Float32Array(se3.product(
+        gl.uniformMatrix4fv(modelLoc, false, new Float32Array(tf));
-            se3.translation(...position), orientation)));
         gl.uniform3fv(lightDirectionLoc, lightDirection);
         gl.uniform3fv(glowColorLoc, glowColor);
         gl.uniform3fv(specularColorLoc, specularColor);
@@ -219,14 +217,12 @@ export function getOrbitDrawContext(gl: WebGLRenderingContext) {
 
     const drawObject = (objectParams) => {
         const {
-            position,
+            tf,
-            orientation,
             value,
             glBuffer,
         } = objectParams;
 
-        gl.uniformMatrix4fv(modelLoc, false, new Float32Array(se3.product(
+        gl.uniformMatrix4fv(modelLoc, false, new Float32Array(tf));
-            se3.translation(...position), orientation)));
 
         gl.bindBuffer(gl.ARRAY_BUFFER, glBuffer);
 
@@ -244,37 +240,40 @@ export function getOrbitDrawContext(gl: WebGLRenderingContext) {
     };
 }
 
+function getShipTf(context) {
+    if (context.landed) {
+        const body = context.landedBody;
+        const bodyTf = se3.product(se3.translation(...body.position), body.orientation);
+        return se3.product(bodyTf, context.shipTf);
+    }
+
+    return context.player.tf;
+}
+
 function getObjects(context, body, parentPosition = undefined) {
     const objects = [];
     const {gl, glContext, player} = context;
     const {position, orientation, glowColor, specularColor} = body;
 
     if (body.glBuffer === undefined) {
-        body.glBuffer = makeBufferFromFaces(gl, body.geometry);
+        body.glBuffer = makeBufferFromFaces(gl, body.geometry.faces);
     }
 
     objects.push({
         geometry: body.glBuffer,
-        orientation,
+        tf: se3.product(se3.translation(...position), orientation),
-        position,
         glContext,
         glowColor,
         specularColor,
     });
     if (parentPosition !== undefined) {
         const orbitObject = makeOrbitObject(gl, context.orbitGlContext, body.orbit, parentPosition);
-        objects.push(orbitObject);
+        //objects.push(orbitObject);
     } else {
-        const shipOrientation = [
+        const shipTf = se3.product(getShipTf(context), se3.rotxyz(-Math.PI / 2, Math.PI / 2, Math.PI / 2));
-            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 = player.position;
         objects.push({
             geometry: makeBufferFromFaces(gl, context.spaceship),
-            orientation: shipOrientation,
+            tf: shipTf,
-            position: shipPos,
             glContext,
             specularColor: [0.8, 0.8, 0.8],
         });
@@ -297,7 +296,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) {
+    if (orbit !== undefined && orbit.excentricity < 1 && !context.landing) {
         objects.push(makeOrbitObject(gl, orbitGlContext, orbit, orbitBody.position));
     }
 
@@ -313,14 +312,23 @@ export function draw(context) {
 
     gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
-    const viewMatrix = se3.inverse([
+    const thirdPerson = context.landed ? se3.identity() : se3.translation(0, 1, 4);
+
+    const playerView = [
         player.tf,  // player position & orientation
         camera.tf,  // camera orientation relative to player
-        se3.translation(0, 1, 4),  // step back from the player
+        thirdPerson,
-    ].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) {
+    for (const {tf, geometry, glContext, glowColor, specularColor} of objects) {
         if (glContext !== lastGlContext) {
             glContext.setupScene({
                 projectionMatrix: projMatrix,
@@ -330,11 +338,11 @@ export function draw(context) {
         }
 
         lastGlContext = glContext;
+        const position = se3.apply(tf, [0, 0, 0, 1]);
         const lightDirection = sunDirection(position);
 
         glContext.drawObject({
-            position,
+            tf,
-            orientation,
             glBuffer: geometry.glBuffer,
             numVertices: geometry.numVertices,
             lightDirection,

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 } from './orbit';
+import { computeOrbit, findSoi, getCartesianState, updateBodyPhysics, isInSoi } from './orbit';
-import { getBodyGeometry } from './chunk';
+import { getBodyGeometry, castRay, blockLookup, BlockType } from './chunk';
 import { draw, getOrbitDrawContext, initWorldGl } from './draw';
 import * as quat from './quat';
 
@@ -157,17 +157,14 @@ function initUiListeners(canvas: HTMLCanvasElement, context) {
                         delete context.orbit;
                         return false;
                     case 'KeyL':
-                        if (closeToPlanet(context)) {
+                        context.landing = !context.landing;
-                            context.landing = True;
+                        return false;
-                        }
+                    case 'KeyP':
+                        context.pause = !context.pause;
                         return false;
                     case 'Space':
                         if (!context.flying) {
-                            if (context.jumpAmount > 0) {
+                            jump(context);
-                                const amount = context.jumpForce;
-                                context.player.velocity[1] = amount;
-                                context.jumpAmount -= 1;
-                            }
                         }
                         return false;
                 }
@@ -176,10 +173,20 @@ function initUiListeners(canvas: HTMLCanvasElement, context) {
             }
         };
         const moveListener = e => {
-//            context.camera.orientation[0] -= e.movementY / 500;
+            const cam = context.camera;
-//            context.camera.orientation[1] -= e.movementX / 500;
+            if (context.landed) {
-            context.camera.tf =[
+                cam.orientation[1] -= e.movementX / 500;
-                context.camera.tf,
+                cam.orientation[0] -= e.movementY / 500;
+                cam.tf = [
+                    se3.roty(cam.orientation[1]),
+                    se3.rotx(cam.orientation[0]),
+                ].reduce(se3.product);
+
+                return;
+            }
+
+            cam.tf =[
+                cam.tf,
                 se3.roty(-e.movementX / 500),
                 se3.rotx(-e.movementY / 500),
             ].reduce(se3.product);
@@ -212,28 +219,93 @@ function initUiListeners(canvas: HTMLCanvasElement, context) {
     });
 }
 
+function jump(context) {
+    if (context.jumpAmount > 0) {
+        const amount = context.jumpForce;
+        context.jumpAmount -= 1;
+
+        const gravity = landedGravity(context);
+        const up = linalg.normalize(linalg.scale(gravity, -1));
+        context.player.velocity = linalg.scale(up, amount);
+    }
+}
+
+function moveShip(context, forward, right) {
+    if (context.keys.has('ShiftLeft')) {
+        forward *= 10;
+        right *= 10;
+    }
+    const tf = se3.product(
+        se3.orientationOnly(context.player.tf),
+        context.camera.tf,
+    );
+    const dir = [right, 0, -forward, 10];
+    if (context.flying) {
+        context.player.tf = [
+            context.player.tf,
+            se3.translation(...dir),
+        ].reduce(se3.product);
+    } else {
+        const vel = context.player.velocity;
+        const dv = linalg.scale(se3.apply(tf, dir), 1/dir[3]);
+        context.player.velocity = linalg.add(vel, dv);
+        delete context.orbit;
+    }
+}
+
+function moveOnGround(context, forward, right) {
+    if (context.keys.has('ShiftLeft')) {
+        forward *= 2;
+        right *= 2;
+    }
+    const tf = se3.product(
+        se3.orientationOnly(context.player.tf),
+        context.camera.tf,
+    );
+    const dir = se3.apply(tf, [right, 0, -forward, 0]);
+    if (context.flying) {
+        context.player.tf = [
+            se3.translation(...dir),
+            context.player.tf,
+        ].reduce(se3.product);
+        return;
+    }
+
+    const dv = linalg.scale(dir, 10);
+
+    const maxSpeed = 8;
+    const airMovement = 0.08;
+
+    if (context.isOnGround) {
+        const up = upDirection(context);
+        const vertical = linalg.dot(dv, up);
+        const horizontal = linalg.diff(dv, linalg.scale(up, vertical));
+        context.player.velocity = horizontal;
+        return;
+    }
+
+    // steering in the air
+    context.player.velocity = linalg.add(context.player.velocity, linalg.scale(dv, airMovement));
+
+    const curVel = linalg.norm(context.player.velocity);
+
+    if (curVel > maxSpeed) {
+        context.player.velocity = linalg.scale(context.player.velocity, maxSpeed / curVel);
+    }
+}
+
+
 function handleInput(context) {
-    const move = (forward: number, right: number) => {
+    const move = (f, r) => (context.landed ? moveOnGround : moveShip)(context, f, r);
+
+    const roll = (amount: number) => {
         if (context.keys.has('ShiftLeft')) {
-            forward *= 10;
+            amount *= 10;
-            right *= 10;
         }
-        const tf = se3.product(
+        context.camera.tf =[
-            se3.orientationOnly(context.player.tf),
             context.camera.tf,
-        );
+            se3.rotz(amount),
-        const dir = [right, 0, -forward, 10];
+        ].reduce(se3.product);
-        if (context.flying) {
-            context.player.tf = [
-                context.player.tf,
-                se3.translation(...dir),
-            ].reduce(se3.product);
-        } else {
-            const vel = context.player.velocity;
-            const dv = linalg.scale(se3.apply(tf, dir), 1/dir[3]);
-            context.player.velocity = linalg.add(vel, dv);
-            delete context.orbit;
-        }
     };
 
     context.keys.forEach(key => {
@@ -250,6 +322,12 @@ 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;
@@ -259,15 +337,253 @@ function handleInput(context) {
 
 function slerp(current: linalg.Mat4, target: linalg.Mat4, maxVelocity: number) : linalg.Mat4 {
     const q0 = quat.mat2Quat(current);
-    const q1 = quat.mat2Quat(target);
+    let 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 finishLanding(context, body) {
+    const p = context.player;
+    context.landed = true;
+    context.landedBody = body;
+
+    p.tf = [
+        se3.inverse(body.orientation),
+        se3.inverse(se3.translation(...body.position)),
+        p.tf,
+    ].reduce(se3.product);
+
+    context.shipTf = p.tf;
+    p.tf = se3.product(p.tf, se3.translation(1, 1, 0));
+    p.velocity = [0, 0, 0];
+    p.position = se3.apply(p.tf, [0, 0, 0, 1]);
+}
+
+function alignUp(playerTf, surfaceNormal) {
+    const zaxis = se3.apply(playerTf, [0, 0, 1, 0]);
+    const ny = surfaceNormal;
+    const nx = linalg.normalize(linalg.cross(ny, zaxis));
+    const nz = linalg.normalize(linalg.cross(nx, ny));
+
+    return se3.fromBases(nx, ny, nz);
+}
+
+function calculateLandingDv(verticalSpeed, altitude, dt) {
+    // pretty crude logic, could be improved
+    const maxThrust = 2;
+    const final = verticalSpeed**2 / (2*(altitude - 1.0));
+
+    if (verticalSpeed > 0 || final < maxThrust * 0.8) {
+        // can still accelerate forward
+        return -maxThrust * dt;
+    } else if (final < maxThrust) {
+        // coast
+        return 0;
+    }
+    return final;
+}
+
+function autoLand(context, dt) {
+    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));
+
+    const surfaceVelocity = linalg.add(body.velocity, linalg.cross(body.spin, linalg.scale(toBodyCenter, -1)));
+    const relativeVelocity = linalg.diff(p.velocity, surfaceVelocity);
+    const upward = linalg.dot(relativeVelocity, surfaceNormal);
+    const vertical = linalg.scale(surfaceNormal, upward);
+    const horizontal = linalg.diff(relativeVelocity, vertical);
+    const smallDv = linalg.scale(horizontal, -0.01);
+    p.velocity = linalg.add(p.velocity, smallDv);
+
+    // up is up
+    const currentOrientation = slerp(p.tf, alignUp(p.tf, surfaceNormal), kShipRotateSpeed);
+    p.tf = se3.setOrientation(p.tf, currentOrientation);
+
+    if (altitude < 1.5) {
+        if (upward < -2) {
+            // going too fast, bounce
+            p.velocity = linalg.add(p.velocity, linalg.scale(surfaceNormal, -2*upward));
+            context.landing = false;
+        } else if (upward < 0) {
+            finishLanding(context, body);
+            return;
+        }
+    }
+
+    // accelerate towards the ground and then slow down to land
+    const dvup = calculateLandingDv(upward, altitude, dt);
+    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 upDirection(context) {
+    const gravity = landedGravity(context);
+    return linalg.normalize(linalg.scale(gravity, -1));
+}
+
+function landedGravity(context) {
+    // just clamp "down" to one of our six directions
+    const pos = context.player.position;
+    const altitude2 = pos[0]**2 + pos[1]**2 + pos[2]**2;
+    const g = context.landedBody.mass / altitude2;
+    if (pos[0] > 0 && Math.abs(pos[1]) < pos[0] && Math.abs(pos[2]) < pos[0]) {
+        return [-g, 0, 0];
+    }
+    if (pos[0] < 0 && Math.abs(pos[1]) < -pos[0] && Math.abs(pos[2]) < -pos[0]) {
+        return [+g, 0, 0];
+    }
+    if (pos[1] > 0 && Math.abs(pos[0]) < pos[1] && Math.abs(pos[2]) < pos[1]) {
+        return [0, -g, 0];
+    }
+    if (pos[1] < 0 && Math.abs(pos[0]) < -pos[1] && Math.abs(pos[2]) < -pos[1]) {
+        return [0, +g, 0];
+    }
+    if (pos[2] > 0 && Math.abs(pos[1]) < pos[2] && Math.abs(pos[1]) < pos[2]) {
+        return [0, 0, -g];
+    }
+    if (pos[2] < 0 && Math.abs(pos[1]) < -pos[2] && Math.abs(pos[1]) < -pos[2]) {
+        return [0, 0, +g];
+    }
+    // blarg
+}
+
+function checkCollision(curPos, newPos, chunkMap, orientation) {
+    const upDir = se3.apply(orientation, [0, 1, 0, 0]);
+    // I guess Gaspard is about 1.7 m tall?
+    // he also has a 60x60 cm axis-aligned square section '^_^
+    // box is centered around the camera
+    const gaspardBB = [
+        [-0.3, 0.2, -0.3],
+        [-0.3, 0.2, 0.3],
+        [0.3, 0.2, -0.3],
+        [0.3, 0.2, 0.3],
+
+        [-0.3, -1.5, -0.3],
+        [-0.3, -1.5, 0.3],
+        [0.3, -1.5, -0.3],
+        [0.3, -1.5, 0.3],
+    ].map(v => se3.apply(orientation, v.concat([0])));
+
+    let dp = linalg.diff(newPos, curPos);
+    let isOnGround = false;
+
+    for (let i = 0; i < 3; i++) {
+        const newGaspard = v => v.map((x, j) => i === j ? x + newPos[j] : x + curPos[j]);
+        for (const point of gaspardBB.map(newGaspard)) {
+            const block = blockLookup(chunkMap, ...point);
+            if (block.type !== BlockType.AIR) {
+                const dir = [...Array(3).keys()].map(j => j === i ? 1 : 0);
+                if (Math.abs(linalg.dot(dir, upDir)) > 0.5) {
+                    isOnGround = true;
+                }
+                dp[i] = 0;
+            }
+        }
+    }
+    for (let i = 0; i < 3; i++) {
+        const newGaspard = v => linalg.add(linalg.add(curPos, v), dp);
+        for (const point of gaspardBB.map(newGaspard)) {
+            const block = blockLookup(chunkMap, ...point);
+            if (block.type !== BlockType.AIR) {
+                dp[i] = 0;
+            }
+        }
+    }
+
+    return {
+        newPos: linalg.add(curPos, dp),
+        isOnGround,
+    };
+}
+
+function updateLandedPhysics(context, dt) {
+    const gravity = landedGravity(context);
+    context.player.velocity = linalg.add(context.player.velocity, linalg.scale(gravity, dt));
+
+    const oldPos = context.player.position;
+    const taregtPos = linalg.add(context.player.position, linalg.scale(context.player.velocity, dt));
+
+    // from wmc
+    const {isOnGround, newPos} = checkCollision(oldPos, taregtPos, context.landedBody.geometry.chunkMap, se3.orientationOnly(context.player.tf));
+    context.player.position = newPos;
+    context.player.velocity = newPos.map((p, i) => (p - oldPos[i]) / dt);
+    if (isOnGround) {
+        context.jumpAmount = 2;
+        context.player.velocity = context.player.velocity.map(v => v * 0.7);
+    }
+    context.isOnGround = isOnGround;
+    context.player.tf = se3.setPosition(context.player.tf, newPos);
+
+    // up is up
+    const p = context.player;
+    const currentOrientation = slerp(p.tf, alignUp(p.tf, upDirection(context)), 0.1);
+    p.tf = se3.setOrientation(p.tf, currentOrientation);
+}
+
 function updatePhysics(time: number, context) {
     const {player} = context;
     const dt = time - (context.lastTime || 0);
@@ -275,37 +591,41 @@ function updatePhysics(time: number, context) {
 
     player.position = se3.apply(player.tf, [0, 0, 0, 1]);
 
-    updateBodyPhysics(time, context.universe);
+    if (!context.pause) {
+        updateBodyPhysics(time, context.universe);
+    }
 
-    const dr = slerp(se3.identity(), context.camera.tf, 0.007);
+    const kShipRotateSpeed = 0.1;
-    player.tf = se3.product(player.tf, dr);
-    context.camera.tf = se3.product(context.camera.tf, se3.inverse(dr));
 
-    if (!context.flying) {
+    if (context.landed) {
-        if (context.orbit === undefined) {
+        return updateLandedPhysics(context, dt);
-            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);
+    if (context.landing) {
-            context.orbit = computeOrbit(player, body, time);
+        autoLand(context, dt);
-            console.log(`orbiting ${body.name}, excentricity: ${context.orbit.excentricity}`);
+    } else {
-            context.orbitBody = body;
+        // allow adjusting camera
-        } else {
+        const dr = slerp(se3.identity(), context.camera.tf, kShipRotateSpeed);
-            const {position: orbitPos, velocity: orbitVel} = getCartesianState(
+        player.tf = se3.product(player.tf, dr);
-                context.orbit, context.orbitBody.mass, time);
+        context.camera.tf = se3.product(context.camera.tf, se3.inverse(dr));
-            if (orbitPos === undefined) {
+    }
-                const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
+
-                const dx = linalg.diff(newPos, player.position);
+    if (context.flying) {
-                player.tf = se3.product(se3.translation(...dx), player.tf);
+        // no physics, just magically moving around
-            } else {
+        return;
-                const position = linalg.add(orbitPos, context.orbitBody.position);
+    }
-                const velocity = linalg.add(orbitVel, context.orbitBody.velocity);
+
-                player.velocity = velocity;
+    const gravity = effectiveGravity(player.position, context.universe);
-                const dx = linalg.diff(position, player.position);
+    player.velocity = linalg.add(player.velocity, linalg.scale(gravity, dt));
-                player.tf = se3.product(se3.translation(...dx), player.tf);
+
-            }
+    const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
-        }
+    player.tf = se3.setPosition(player.tf, newPos);
+
+    if (context.orbit === undefined) {
+        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;
     }
 }
 
@@ -336,14 +656,16 @@ function tick(time: number, context) {
 }
 
 function makeCube(texture) {
-    return [
+    return {
-        makeFace('-x', texture, [-0.5, 0, 0]),
+        faces: [
-        makeFace('+x', texture, [+0.5, 0, 0]),
+            makeFace('-x', texture, [-0.5, 0, 0]),
-        makeFace('-y', texture, [0, -0.5, 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('+y', texture, [0, +0.5, 0]),
-        makeFace('+z', texture, [0, 0, +0.5]),
+            makeFace('-z', texture, [0, 0, -0.5]),
-    ];
+            makeFace('+z', texture, [0, 0, +0.5]),
+        ]
+    };
 }
 
 async function main() {
@@ -360,7 +682,7 @@ async function main() {
     // TODO
     // [ ] loading bar
     // [x] spaceship
-    // [ ] landing
+    // [x] landing
     // [ ] huge planets
     // [x] lighting
     // [x] better lighting
@@ -399,7 +721,6 @@ async function main() {
     initUiListeners(canvas, context);
 
     const starshipGeom = await modelPromise;
-    console.log(`loaded ${starshipGeom.length} triangles`);
 
     context.spaceship = starshipGeom;
 

skycraft/linalg.ts

@@ -39,3 +39,7 @@ 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,6 +52,14 @@ 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;
@@ -63,11 +71,7 @@ export function findSoi(rootBody: Body, position: number[]) : Body {
         }
 
         for (const child of body.children) {
-            const soi = child.orbit.semimajorAxis * Math.pow(child.mass / body.mass, 2/5);
+            if (isInSoi(child, body.mass, position)) {
-            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);
             }
         }
@@ -273,8 +277,7 @@ export function makeOrbitObject(gl: WebGLRenderingContext, glContext: any, orbit
 
     return {
         geometry,
-        orientation,
+        tf: se3.product(se3.translation(...position), orientation),
-        position,
         glContext,
     };
 }

skycraft/quat.ts

@@ -122,3 +122,7 @@ 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;
+}