diff --git a/skycraft/chunk.ts b/skycraft/chunk.ts index 318dc56..3b85008 100644 --- a/skycraft/chunk.ts +++ b/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), + }; +} + +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, + }; + } } diff --git a/skycraft/draw.ts b/skycraft/draw.ts index a134fa3..383963a 100644 --- a/skycraft/draw.ts +++ b/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); + body.glBuffer = makeBufferFromFaces(gl, body.geometry.faces); } objects.push({ @@ -263,14 +263,21 @@ 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(player.tf), + se3.rotationOnly(tf), //se3.rotationOnly(context.camera.tf), se3.rotxyz(-Math.PI / 2, Math.PI / 2, Math.PI / 2), ].reduce(se3.product); - const shipPos = player.position; + const shipPos = se3.apply(tf, [0, 0, 0, 1]); objects.push({ geometry: makeBufferFromFaces(gl, context.spaceship), orientation: shipOrientation, @@ -297,7 +304,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,11 +320,18 @@ export function draw(context) { gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); - const viewMatrix = se3.inverse([ + const playerView = [ 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) { diff --git a/skycraft/index.ts b/skycraft/index.ts index 0ed9515..82ed0b2 100644 --- a/skycraft/index.ts +++ b/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 { getBodyGeometry } from './chunk'; +import { computeOrbit, findSoi, getCartesianState, updateBodyPhysics, isInSoi } from './orbit'; +import { getBodyGeometry, castRay, BlockType } from './chunk'; import { draw, getOrbitDrawContext, initWorldGl } from './draw'; import * as quat from './quat'; @@ -157,18 +157,10 @@ function initUiListeners(canvas: HTMLCanvasElement, context) { delete context.orbit; return false; case 'KeyL': - if (closeToPlanet(context)) { - context.landing = True; - } + context.landing = !context.landing; return false; case 'Space': - if (!context.flying) { - if (context.jumpAmount > 0) { - const amount = context.jumpForce; - context.player.velocity[1] = amount; - context.jumpAmount -= 1; - } - } + context.pause = !context.pause; return false; } } else { @@ -236,6 +228,16 @@ 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': @@ -250,6 +252,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 +267,120 @@ 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 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); @@ -275,37 +388,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); - player.tf = se3.product(player.tf, dr); - context.camera.tf = se3.product(context.camera.tf, se3.inverse(dr)); + const kShipRotateSpeed = 0.1; - 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); + if (context.landed) { + return; // TODO: implement + } - 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); - } - } + 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.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 +453,16 @@ function tick(time: number, context) { } function makeCube(texture) { - return [ - 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]), - ]; + 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() { @@ -399,7 +518,6 @@ async function main() { initUiListeners(canvas, context); const starshipGeom = await modelPromise; - console.log(`loaded ${starshipGeom.length} triangles`); context.spaceship = starshipGeom; diff --git a/skycraft/orbit.ts b/skycraft/orbit.ts index dea4426..03f7b80 100644 --- a/skycraft/orbit.ts +++ b/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); - 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) { + if (isInSoi(child, body.mass, position)) { bodies.push(child); } }