731 lines
22 KiB
TypeScript
731 lines
22 KiB
TypeScript
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 { getBodyGeometry, castRay, blockLookup, BlockType } from './chunk';
|
|
import { draw, getOrbitDrawContext, initWorldGl } from './draw';
|
|
import * as quat from './quat';
|
|
|
|
const kEpoch = 0;
|
|
|
|
function closeToPlanet(context) {
|
|
const body = findSoi(context.universe, context.player.position);
|
|
const relativePos = linalg.diff(context.player.position, body.position);
|
|
|
|
return linalg.norm(relativePos) < 20;
|
|
}
|
|
|
|
function getSolarSystem(seed: number) {
|
|
/// XXX: only returns 1 body for now
|
|
|
|
return {
|
|
name: 'Tat',
|
|
|
|
mass: 1000.0,
|
|
spin: [0, 0, 0.2],
|
|
|
|
geometry: getBodyGeometry(0),
|
|
glowColor: [0.5, 0.5, 0.46],
|
|
|
|
children: [
|
|
{
|
|
name: 'Quicksilver',
|
|
seed: 1336,
|
|
|
|
mass: 0.1,
|
|
spin: [0.0, 0.0, 0.05],
|
|
|
|
geometry: makeCube([0, 4]),
|
|
|
|
orbit: {
|
|
excentricity: 0.0,
|
|
semimajorAxis: 200,
|
|
inclination: 0.8,
|
|
ascendingNodeLongitude: 0,
|
|
periapsisArgument: 0,
|
|
t0: 0,
|
|
},
|
|
},
|
|
{
|
|
name: 'Satourne',
|
|
seed: 1338,
|
|
|
|
mass: 0.1,
|
|
spin: [0.0, 0.5, 0.0],
|
|
|
|
geometry: makeCube([0, 5]),
|
|
|
|
orbit: {
|
|
excentricity: 0.0,
|
|
semimajorAxis: 900,
|
|
inclination: 0.0,
|
|
ascendingNodeLongitude: 0,
|
|
periapsisArgument: 0,
|
|
t0: 0,
|
|
},
|
|
|
|
children: [
|
|
{
|
|
name: 'Kyoujin',
|
|
seed: 13381,
|
|
|
|
mass: 0.01,
|
|
spin: [0.0, 0.0, 0.05],
|
|
|
|
geometry: makeCube([0, 6]),
|
|
|
|
orbit: {
|
|
excentricity: 0.0,
|
|
semimajorAxis: 20,
|
|
inclination: Math.PI / 2,
|
|
ascendingNodeLongitude: 0,
|
|
periapsisArgument: 0,
|
|
t0: 0,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
{
|
|
name: 'Tataooine',
|
|
seed: 1337,
|
|
|
|
mass: 50,
|
|
spin: [0.0, 0.0, 0.05],
|
|
|
|
geometry: getBodyGeometry(1337),
|
|
|
|
orbit: {
|
|
excentricity: 0.3,
|
|
semimajorAxis: 500,
|
|
inclination: 0.0,
|
|
ascendingNodeLongitude: 0,
|
|
periapsisArgument: 0,
|
|
t0: 0,
|
|
},
|
|
|
|
children: [
|
|
{
|
|
name: 'Mun',
|
|
seed: 13371,
|
|
|
|
mass: 0.01,
|
|
spin: [0.0, 0.0, 0.05],
|
|
|
|
geometry: makeCube([0, 7]),
|
|
|
|
orbit: {
|
|
excentricity: 0.0,
|
|
semimajorAxis: 50,
|
|
inclination: Math.PI / 2,
|
|
ascendingNodeLongitude: 0,
|
|
periapsisArgument: 0,
|
|
t0: 0,
|
|
},
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function initUiListeners(canvas: HTMLCanvasElement, context) {
|
|
const canvasClickHandler = () => {
|
|
canvas.requestPointerLock();
|
|
canvas.onclick = null;
|
|
// const clickListener = e => {
|
|
// switch(e.button) {
|
|
// case 0: // left click
|
|
// destroySelectedBlock(context);
|
|
// break;
|
|
// case 2: // right click
|
|
// makeDirBlock(context);
|
|
// break;
|
|
// }
|
|
// };
|
|
const clickListener = e => {};
|
|
const keyListener = e => {
|
|
if (e.type === 'keydown') {
|
|
if (e.repeat) return;
|
|
context.keys.add(e.code);
|
|
|
|
switch (e.code) {
|
|
case 'KeyF':
|
|
context.flying = !context.flying;
|
|
context.player.velocity = [0, 0, 0];
|
|
delete context.orbit;
|
|
return false;
|
|
case 'KeyL':
|
|
context.landing = !context.landing;
|
|
return false;
|
|
case 'KeyP':
|
|
context.pause = !context.pause;
|
|
return false;
|
|
case 'Space':
|
|
if (!context.flying) {
|
|
jump(context);
|
|
}
|
|
return false;
|
|
}
|
|
} else {
|
|
context.keys.delete(e.code);
|
|
}
|
|
};
|
|
const moveListener = e => {
|
|
const cam = context.camera;
|
|
if (context.landed) {
|
|
cam.orientation[1] -= e.movementX / 500;
|
|
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);
|
|
};
|
|
const changeListener = () => {
|
|
if (document.pointerLockElement === canvas) {
|
|
return;
|
|
}
|
|
document.removeEventListener('pointerdown', clickListener);
|
|
document.removeEventListener('pointerlockchange', changeListener);
|
|
document.removeEventListener('pointermove', moveListener);
|
|
document.removeEventListener('keydown', keyListener);
|
|
document.removeEventListener('keyup', keyListener);
|
|
canvas.onclick = canvasClickHandler;
|
|
};
|
|
document.addEventListener('pointerdown', clickListener);
|
|
document.addEventListener('pointerlockchange', changeListener);
|
|
document.addEventListener('pointermove', moveListener);
|
|
document.addEventListener('keydown', keyListener);
|
|
document.addEventListener('keyup', keyListener);
|
|
};
|
|
canvas.onclick = canvasClickHandler;
|
|
document.addEventListener('keydown', e => {
|
|
if (e.repeat) return;
|
|
switch (e.code) {
|
|
case 'F11':
|
|
canvas.requestFullscreen();
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
|
|
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 = (f, r) => (context.landed ? moveOnGround : moveShip)(context, f, r);
|
|
|
|
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':
|
|
move(0.5, 0.0);
|
|
return;
|
|
case 'KeyA':
|
|
move(0.0, -0.5);
|
|
return;
|
|
case 'KeyS':
|
|
move(-0.5, 0.0);
|
|
return;
|
|
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;
|
|
}
|
|
});
|
|
}
|
|
|
|
function slerp(current: linalg.Mat4, target: linalg.Mat4, maxVelocity: number) : linalg.Mat4 {
|
|
const q0 = quat.mat2Quat(current);
|
|
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 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);
|
|
context.lastTime = time;
|
|
|
|
player.position = se3.apply(player.tf, [0, 0, 0, 1]);
|
|
|
|
if (!context.pause) {
|
|
updateBodyPhysics(time, context.universe);
|
|
}
|
|
|
|
const kShipRotateSpeed = 0.1;
|
|
|
|
if (context.landed) {
|
|
return updateLandedPhysics(context, dt);
|
|
}
|
|
|
|
if (context.landing) {
|
|
autoLand(context, dt);
|
|
} else {
|
|
// allow adjusting 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;
|
|
}
|
|
}
|
|
|
|
function updateGeometry(context, timeout_ms = 10) {
|
|
}
|
|
|
|
function tick(time: number, context) {
|
|
handleInput(context);
|
|
const simTime = time * 0.001 + context.timeOffset;
|
|
updatePhysics(simTime, context);
|
|
|
|
// world generation / geometry update
|
|
{
|
|
// frame time is typically 16.7ms, so this may lag a bit
|
|
let timeLeft = 10;
|
|
const start = performance.now();
|
|
updateGeometry(context, timeLeft);
|
|
}
|
|
|
|
draw(context);
|
|
|
|
const dt = (time - context.lastFrameTime) * 0.001;
|
|
context.lastFrameTime = time;
|
|
|
|
document.querySelector('#fps')!.textContent = `${1.0 / dt} fps`;
|
|
|
|
requestAnimationFrame(time => tick(time, context));
|
|
}
|
|
|
|
function makeCube(texture) {
|
|
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() {
|
|
const canvas = document.querySelector('#game')! as HTMLCanvasElement;
|
|
// adjust canvas aspect ratio to that of the screen
|
|
canvas.height = screen.height / screen.width * canvas.width;
|
|
const gl = canvas.getContext('webgl');
|
|
|
|
if (gl === null) {
|
|
console.error('webgl not available')
|
|
return;
|
|
}
|
|
|
|
// TODO
|
|
// [ ] loading bar
|
|
// [x] spaceship
|
|
// [x] landing
|
|
// [ ] huge planets
|
|
// [x] lighting
|
|
// [x] better lighting
|
|
// [ ] betterer lighting
|
|
// [x] optimize geometry generation
|
|
|
|
const modelPromise = loadObjModel('spaceship.obj');
|
|
|
|
const context = {
|
|
gl,
|
|
projMatrix: se3.perspective(Math.PI / 3, canvas.clientWidth / canvas.clientHeight, 0.1, 10000.0),
|
|
player: {
|
|
tf: se3.translation(0.0, 0.0, 80.0),
|
|
position: [0.0, 0.0, 80.0],
|
|
velocity: [0, 0, 0],
|
|
},
|
|
camera: {
|
|
orientation: [0, 0, 0],
|
|
tf: se3.identity(),
|
|
},
|
|
keys: new Set(),
|
|
lightDirection: [-0.2, -0.5, 0.4],
|
|
skyColor: [0.10, 0.15, 0.2],
|
|
ambiantLight: 0.4,
|
|
blockSelectDistance: 8,
|
|
flying: true,
|
|
isOnGround: false,
|
|
gravity: -17,
|
|
jumpForce: 6.5,
|
|
universe: getSolarSystem(0),
|
|
timeOffset: 0,
|
|
};
|
|
|
|
context.glContext = await initWorldGl(gl);
|
|
context.orbitGlContext = getOrbitDrawContext(gl);
|
|
initUiListeners(canvas, context);
|
|
|
|
const starshipGeom = await modelPromise;
|
|
|
|
context.spaceship = starshipGeom;
|
|
|
|
requestAnimationFrame(time => tick(time, context));
|
|
}
|
|
|
|
window.onload = main;
|