111 lines
3.7 KiB
JavaScript
111 lines
3.7 KiB
JavaScript
/* loader.js — ghost visuals.
|
|
* Multi-part OBJ ghosts: { legs|wisp, torso, head, headpiece } assembled into one Group,
|
|
* every part rendered with the recovered Hidden Side gradient shader (top->bottom tint
|
|
* by GhostColor: Red / Yellow / Blue). Until models exist, a procedural wisp fallback
|
|
* is used so the exhibit always has something to show.
|
|
*
|
|
* Model manifest (data/models.json, editable via /api/models):
|
|
* { "models": [ { "id": "classic", "scale": 1.0,
|
|
* "parts": { "legs": "/models/classic/legs.obj", "torso": "...", "head": "...", "headpiece": "..." } } ] }
|
|
*/
|
|
import * as THREE from 'three';
|
|
import { OBJLoader } from 'three/addons/loaders/OBJLoader.js';
|
|
|
|
const objLoader = new OBJLoader();
|
|
const objCache = new Map();
|
|
|
|
function gradientMaterial(top, bottom, opacity = 0.92) {
|
|
return new THREE.ShaderMaterial({
|
|
transparent: true,
|
|
depthWrite: false,
|
|
uniforms: {
|
|
topColor: { value: new THREE.Color(top) },
|
|
bottomColor: { value: new THREE.Color(bottom) },
|
|
opacity: { value: opacity },
|
|
uMinY: { value: 0 },
|
|
uMaxY: { value: 1 },
|
|
uTime: { value: 0 },
|
|
},
|
|
vertexShader: `
|
|
varying float vY;
|
|
varying vec3 vNormal;
|
|
uniform float uMinY, uMaxY;
|
|
void main() {
|
|
vY = clamp((position.y - uMinY) / max(uMaxY - uMinY, 0.001), 0.0, 1.0);
|
|
vNormal = normalize(normalMatrix * normal);
|
|
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
|
|
}`,
|
|
fragmentShader: `
|
|
varying float vY;
|
|
varying vec3 vNormal;
|
|
uniform vec3 topColor, bottomColor;
|
|
uniform float opacity, uTime;
|
|
void main() {
|
|
vec3 c = mix(bottomColor, topColor, vY);
|
|
float rim = pow(1.0 - abs(dot(vNormal, vec3(0.0, 0.0, 1.0))), 2.0);
|
|
c += rim * 0.35;
|
|
float pulse = 0.92 + 0.08 * sin(uTime * 2.2);
|
|
gl_FragColor = vec4(c, opacity * pulse);
|
|
}`,
|
|
});
|
|
}
|
|
|
|
async function loadOBJ(url) {
|
|
if (objCache.has(url)) return objCache.get(url).clone();
|
|
const obj = await objLoader.loadAsync(url);
|
|
objCache.set(url, obj);
|
|
return obj.clone();
|
|
}
|
|
|
|
function proceduralWisp() {
|
|
const g = new THREE.Group();
|
|
const body = new THREE.Mesh(new THREE.SphereGeometry(0.09, 20, 16));
|
|
body.scale.set(1, 1.35, 1);
|
|
body.position.y = 0.14;
|
|
const tail = new THREE.Mesh(new THREE.ConeGeometry(0.07, 0.16, 16));
|
|
tail.rotation.x = Math.PI;
|
|
tail.position.y = 0.0;
|
|
g.add(body, tail);
|
|
return g;
|
|
}
|
|
|
|
export async function buildGhost(ghost, gradients, manifest) {
|
|
const grad = gradients[ghost.color] || gradients.Blue;
|
|
const mat = gradientMaterial(grad.top, grad.bottom);
|
|
|
|
let group;
|
|
const model = (manifest?.models || [])[0]; // default model; per-ghost mapping can extend later
|
|
if (model && model.parts) {
|
|
group = new THREE.Group();
|
|
try {
|
|
for (const key of ['legs', 'wisp', 'torso', 'head', 'headpiece']) {
|
|
const url = model.parts[key];
|
|
if (!url) continue;
|
|
group.add(await loadOBJ(url));
|
|
}
|
|
if (model.scale) group.scale.setScalar(model.scale);
|
|
if (!group.children.length) group = proceduralWisp();
|
|
} catch (e) {
|
|
console.warn('ghost model load failed, using wisp fallback', e);
|
|
group = proceduralWisp();
|
|
}
|
|
} else {
|
|
group = proceduralWisp();
|
|
}
|
|
|
|
// apply gradient material to every mesh; compute Y-range for gradient mapping
|
|
const box = new THREE.Box3().setFromObject(group);
|
|
group.traverse(o => {
|
|
if (o.isMesh) {
|
|
o.material = mat;
|
|
o.material.uniforms.uMinY.value = box.min.y;
|
|
o.material.uniforms.uMaxY.value = box.max.y;
|
|
}
|
|
});
|
|
|
|
group.userData.material = mat;
|
|
group.userData.setOpacity = (v) => { mat.uniforms.opacity.value = v; };
|
|
group.userData.tick = (t) => { mat.uniforms.uTime.value = t; };
|
|
return group;
|
|
}
|