229 lines
7.9 KiB
JavaScript
229 lines
7.9 KiB
JavaScript
'use strict';
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Math Stuff
|
|
|
|
const PI = Math.PI;
|
|
const abs = (value) => Math.abs(value);
|
|
const min = (valueA, valueB) => Math.min(valueA, valueB);
|
|
const max = (valueA, valueB) => Math.max(valueA, valueB);
|
|
const sign = (value) => value < 0 ? -1 : 1;
|
|
const mod = (dividend, divisor=1) => ((dividend % divisor) + divisor) % divisor;
|
|
const clamp = (value, min=0, max=1) => value < min ? min : value > max ? max : value;
|
|
const clampAngle = (value) => ((value+PI) % (2*PI) + 2*PI) % (2*PI) - PI;
|
|
const percent = (value, valueA, valueB) => (valueB-=valueA) ? clamp((value-valueA)/valueB) : 0;
|
|
const lerp = (percent, valueA, valueB) => valueA + clamp(percent) * (valueB-valueA);
|
|
const rand = (valueA=1, valueB=0) => lerp(Math.random(), valueA, valueB);
|
|
const randInt = (valueA, valueB=0) => rand(valueA, valueB)|0;
|
|
const smoothStep = (p) => p * p * (3 - 2 * p);
|
|
const isOverlapping = (posA, sizeA, posB, sizeB=vec3()) =>
|
|
abs(posA.x - posB.x)*2 < sizeA.x + sizeB.x && abs(posA.y - posB.y)*2 < sizeA.y + sizeB.y;
|
|
function buildMatrix(pos, rot, scale)
|
|
{
|
|
const R2D = 180/PI;
|
|
let m = new DOMMatrix;
|
|
pos && m.translateSelf(pos.x, pos.y, pos.z);
|
|
rot && m.rotateSelf(rot.x*R2D, rot.y*R2D, rot.z*R2D);
|
|
scale && m.scaleSelf(scale.x, scale.y, scale.z);
|
|
return m;
|
|
}
|
|
function shuffle(array)
|
|
{
|
|
for(let currentIndex = array.length; currentIndex;)
|
|
{
|
|
const randomIndex = random.int(currentIndex--);
|
|
[array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
|
|
}
|
|
return array;
|
|
}
|
|
function formatTimeString(t)
|
|
{
|
|
const timeS = t%60|0;
|
|
const timeM = t/60|0;
|
|
const timeMS = t%1*1e3|0;
|
|
return `${timeM}:${timeS<10?'0'+timeS:timeS}.${(timeMS<10?'00':timeMS<100?'0':'')+timeMS}`;
|
|
}
|
|
|
|
function noise1D(x)
|
|
{
|
|
const hash = x=>(new Random(x)).float(-1,1);
|
|
return lerp(smoothStep(mod(x,1)), hash(x), hash(x+1));
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Vector3
|
|
|
|
const vec3 = (x, y, z)=> y == undefined && z == undefined ? new Vector3(x, x, x) : new Vector3(x, y, z);
|
|
const isVector3 = (v) => v instanceof Vector3;
|
|
const isNumber = (value) => typeof value === 'number';
|
|
const ASSERT_VEC3 = (v) => ASSERT(isVector3(v));
|
|
|
|
class Vector3
|
|
{
|
|
constructor(x=0, y=0, z=0)
|
|
{
|
|
ASSERT(isNumber(x) && isNumber(y) && isNumber(z));
|
|
this.x=x; this.y=y; this.z=z;
|
|
}
|
|
copy() { return vec3(this.x, this.y, this.z); }
|
|
add(v) { ASSERT_VEC3(v); return vec3(this.x + v.x, this.y + v.y, this.z + v.z); }
|
|
addSelf(v) { ASSERT_VEC3(v); this.x += v.x, this.y += v.y, this.z += v.z; return this }
|
|
subtract(v) { ASSERT_VEC3(v); return vec3(this.x - v.x, this.y - v.y, this.z - v.z); }
|
|
multiply(v) { ASSERT_VEC3(v); return vec3(this.x * v.x, this.y * v.y, this.z * v.z); }
|
|
divide(v) { ASSERT_VEC3(v); return vec3(this.x / v.x, this.y / v.y, this.z / v.z); }
|
|
scale(s) { ASSERT(isNumber(s)); return vec3(this.x * s, this.y * s, this.z * s); }
|
|
length() { return this.lengthSquared()**.5; }
|
|
lengthSquared() { return this.x**2 + this.y**2 + this.z**2; }
|
|
distance(v) { ASSERT_VEC3(v); return this.distanceSquared(v)**.5; }
|
|
distanceSquared(v) { ASSERT_VEC3(v); return this.subtract(v).lengthSquared(); }
|
|
normalize(length=1) { const l = this.length(); return l ? this.scale(length/l) : vec3(length); }
|
|
clampLength(length=1) { const l = this.length(); return l > length ? this.scale(length/l) : this; }
|
|
dot(v) { ASSERT_VEC3(v); return this.x*v.x + this.y*v.y + this.z*v.z; }
|
|
angleBetween(v) { ASSERT_VEC3(v); return Math.acos(clamp(this.dot(v), -1, 1)); }
|
|
clamp(a, b) { return vec3(clamp(this.x, a, b), clamp(this.y, a, b), clamp(this.z, a, b)); }
|
|
cross(v) { ASSERT_VEC3(v); return vec3(this.y*v.z-this.z*v.y, this.z*v.x-this.x*v.z, this.x*v.y-this.y*v.x); }
|
|
lerp(v, p) { ASSERT_VEC3(v); return v.subtract(this).scale(clamp(p)).addSelf(this); }
|
|
rotateX(a)
|
|
{
|
|
const c=Math.cos(a), s=Math.sin(a);
|
|
return vec3(this.x, this.y*c - this.z*s, this.y*s + this.z*c);
|
|
}
|
|
rotateY(a)
|
|
{
|
|
const c=Math.cos(a), s=Math.sin(a);
|
|
return vec3(this.x*c - this.z*s, this.y, this.x*s + this.z*c);
|
|
}
|
|
rotateZ(a)
|
|
{
|
|
const c=Math.cos(a), s=Math.sin(a);
|
|
return vec3(this.x*c - this.y*s, this.x*s + this.y*c, this.z);
|
|
}
|
|
transform(matrix)
|
|
{
|
|
const p = matrix.transformPoint(this);
|
|
return vec3(p.x, p.y, p.z);
|
|
}
|
|
getHSLColor(a=1) { return hsl(this.x, this.y, this.z, a); }
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Color
|
|
|
|
const rgb = (r, g, b, a) => new Color(r, g, b, a);
|
|
const hsl = (h, s, l, a) => rgb().setHSLA(h, s, l, a);
|
|
const isColor = (c) => c instanceof Color;
|
|
|
|
class Color
|
|
{
|
|
constructor(r=1, g=1, b=1, a=1)
|
|
{
|
|
this.r = r;
|
|
this.g = g;
|
|
this.b = b;
|
|
this.a = a;
|
|
}
|
|
|
|
copy() { return rgb(this.r, this.g, this.b, this.a); }
|
|
|
|
lerp(c, percent)
|
|
{
|
|
ASSERT(isColor(c));
|
|
percent = clamp(percent);
|
|
return rgb(
|
|
lerp(percent, this.r, c.r),
|
|
lerp(percent, this.g, c.g),
|
|
lerp(percent, this.b, c.b),
|
|
lerp(percent, this.a, c.a),
|
|
);
|
|
}
|
|
|
|
brighten(amount=.1)
|
|
{
|
|
return rgb
|
|
(
|
|
clamp(this.r + amount),
|
|
clamp(this.g + amount),
|
|
clamp(this.b + amount),
|
|
this.a
|
|
);
|
|
}
|
|
|
|
setHSLA(h=0, s=0, l=1, a=1)
|
|
{
|
|
h = mod(h,1);
|
|
s = clamp(s);
|
|
l = clamp(l);
|
|
const q = l < .5 ? l*(1+s) : l+s-l*s, p = 2*l-q,
|
|
f = (p, q, t)=>
|
|
(t = mod(t,1))*6 < 1 ? p+(q-p)*6*t :
|
|
t*2 < 1 ? q :
|
|
t*3 < 2 ? p+(q-p)*(4-t*6) : p;
|
|
this.r = f(p, q, h + 1/3);
|
|
this.g = f(p, q, h);
|
|
this.b = f(p, q, h - 1/3);
|
|
this.a = a;
|
|
return this;
|
|
}
|
|
|
|
toString()
|
|
{ return `rgb(${this.r*255},${this.g*255},${this.b*255},${this.a})`; }
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Random
|
|
|
|
class Random
|
|
{
|
|
constructor(seed) { this.setSeed(seed); }
|
|
setSeed(seed)
|
|
{
|
|
this.seed = seed+1|0;
|
|
this.float();this.float();this.float();// warmup
|
|
}
|
|
float(a=1, b=0)
|
|
{
|
|
// xorshift
|
|
this.seed ^= this.seed << 13;
|
|
this.seed ^= this.seed >>> 17;
|
|
this.seed ^= this.seed << 5;
|
|
if (js13kBuild)
|
|
return b + (a-b) * Math.abs(this.seed % 1e9) / 1e9; // bias low values due to float error
|
|
else
|
|
return b + (a-b) * Math.abs(this.seed % 1e8) / 1e8;
|
|
}
|
|
floatSign(a, b) { return this.float(a,b) * this.sign(); }
|
|
int(a, b) { return this.float(a, b)|0; }
|
|
bool(chance = .5) { return this.float() < chance; }
|
|
sign() { return this.bool() ? -1 : 1; }
|
|
circle(radius=0, bias = .5)
|
|
{
|
|
const r = this.float()**bias*radius;
|
|
const a = this.float(PI*2);
|
|
return vec3(r*Math.cos(a), r*Math.sin(a));
|
|
}
|
|
mutateColor(color, amount=.1, brightnessAmount=0)
|
|
{
|
|
return rgb
|
|
(
|
|
clamp(random.float(1,1-brightnessAmount)*(color.r + this.floatSign(amount))),
|
|
clamp(random.float(1,1-brightnessAmount)*(color.g + this.floatSign(amount))),
|
|
clamp(random.float(1,1-brightnessAmount)*(color.b + this.floatSign(amount))),
|
|
color.a
|
|
);
|
|
}
|
|
fromList(list,startBias=1) { return list[this.float()**startBias*list.length|0]; }
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
class Timer
|
|
{
|
|
constructor(timeLeft)
|
|
{ this.time = timeLeft == undefined ? undefined : time + timeLeft; }
|
|
set(timeLeft=0) { this.time = time + timeLeft; }
|
|
unset() { this.time = undefined; }
|
|
isSet() { return this.time != undefined; }
|
|
active() { return time < this.time; }
|
|
elapsed() { return time >= this.time; }
|
|
get() { return this.isSet()? time - this.time : 0; }
|
|
} |