136 lines
3.0 KiB
Plaintext
136 lines
3.0 KiB
Plaintext
// Math module for lance3d
|
|
var model_c = use('model')
|
|
var math = use('math/radians')
|
|
var random = use('random')
|
|
|
|
// Private RNG state
|
|
var _rng_seed = 12345
|
|
|
|
function seed(seed_int) {
|
|
_rng_seed = seed_int
|
|
}
|
|
|
|
function rand() {
|
|
// Simple LCG for deterministic random
|
|
_rng_seed = (_rng_seed * 1103515245 + 12345) & 0x7fffffff
|
|
return _rng_seed / 0x7fffffff
|
|
}
|
|
|
|
function irand(min_inclusive, max_inclusive) {
|
|
return floor(rand() * (max_inclusive - min_inclusive + 1)) + min_inclusive
|
|
}
|
|
|
|
// Matrix helpers
|
|
function identity_matrix() {
|
|
return model_c.mat4_identity()
|
|
}
|
|
|
|
function translation_matrix(x, y, z) {
|
|
return model_c.mat4_from_trs(x, y, z, 0, 0, 0, 1, 1, 1, 1)
|
|
}
|
|
|
|
function rotation_matrix(qx, qy, qz, qw) {
|
|
return model_c.mat4_from_trs(0, 0, 0, qx, qy, qz, qw, 1, 1, 1)
|
|
}
|
|
|
|
function scale_matrix(sx, sy, sz) {
|
|
return model_c.mat4_from_trs(0, 0, 0, 0, 0, 0, 1, sx, sy, sz)
|
|
}
|
|
|
|
function trs_matrix(x, y, z, qx, qy, qz, qw, sx, sy, sz) {
|
|
return model_c.mat4_from_trs(x, y, z, qx, qy, qz, qw, sx, sy, sz)
|
|
}
|
|
|
|
function euler_to_quat(pitch, yaw, roll) {
|
|
var cy = math.cosine(yaw * 0.5)
|
|
var sy = math.sine(yaw * 0.5)
|
|
var cp = math.cosine(pitch * 0.5)
|
|
var sp = math.sine(pitch * 0.5)
|
|
var cr = math.cosine(roll * 0.5)
|
|
var sr = math.sine(roll * 0.5)
|
|
|
|
return {
|
|
x: sr * cp * cy - cr * sp * sy,
|
|
y: cr * sp * cy + sr * cp * sy,
|
|
z: cr * cp * sy - sr * sp * cy,
|
|
w: cr * cp * cy + sr * sp * sy
|
|
}
|
|
}
|
|
|
|
function euler_matrix(pitch, yaw, roll) {
|
|
var q = euler_to_quat(pitch, yaw, roll)
|
|
return model_c.mat4_from_trs(0, 0, 0, q.x, q.y, q.z, q.w, 1, 1, 1)
|
|
}
|
|
|
|
function multiply_matrices(a, b) {
|
|
return model_c.mat4_mul(a, b)
|
|
}
|
|
|
|
// Vector helpers
|
|
function vec3_add(a, b) {
|
|
return {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z}
|
|
}
|
|
|
|
function vec3_sub(a, b) {
|
|
return {x: a.x - b.x, y: a.y - b.y, z: a.z - b.z}
|
|
}
|
|
|
|
function vec3_scale(v, s) {
|
|
return {x: v.x * s, y: v.y * s, z: v.z * s}
|
|
}
|
|
|
|
function vec3_dot(a, b) {
|
|
return a.x * b.x + a.y * b.y + a.z * b.z
|
|
}
|
|
|
|
function vec3_cross(a, b) {
|
|
return {
|
|
x: a.y * b.z - a.z * b.y,
|
|
y: a.z * b.x - a.x * b.z,
|
|
z: a.x * b.y - a.y * b.x
|
|
}
|
|
}
|
|
|
|
function vec3_length(v) {
|
|
return math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
|
|
}
|
|
|
|
function vec3_normalize(v) {
|
|
var len = vec3_length(v)
|
|
if (len < 0.0001) return {x: 0, y: 0, z: 0}
|
|
return {x: v.x / len, y: v.y / len, z: v.z / len}
|
|
}
|
|
|
|
function lerp(a, b, t) {
|
|
return a + (b - a) * t
|
|
}
|
|
|
|
function clamp(v, min, max) {
|
|
if (v < min) return min
|
|
if (v > max) return max
|
|
return v
|
|
}
|
|
|
|
return {
|
|
seed: seed,
|
|
rand: rand,
|
|
irand: irand,
|
|
identity_matrix: identity_matrix,
|
|
translation_matrix: translation_matrix,
|
|
rotation_matrix: rotation_matrix,
|
|
scale_matrix: scale_matrix,
|
|
trs_matrix: trs_matrix,
|
|
euler_to_quat: euler_to_quat,
|
|
euler_matrix: euler_matrix,
|
|
multiply_matrices: multiply_matrices,
|
|
vec3_add: vec3_add,
|
|
vec3_sub: vec3_sub,
|
|
vec3_scale: vec3_scale,
|
|
vec3_dot: vec3_dot,
|
|
vec3_cross: vec3_cross,
|
|
vec3_length: vec3_length,
|
|
vec3_normalize: vec3_normalize,
|
|
lerp: lerp,
|
|
clamp: clamp
|
|
}
|