251 lines
13 KiB
JavaScript
Executable File
251 lines
13 KiB
JavaScript
Executable File
// Original static broadleaf sculptures. Pure, bounded, deterministic; no MTL,
|
|
// external assets, random state or filesystem access. Ten model units per node.
|
|
import { PALETTE, SPECIES_NAMES, EVERGREEN_NAMES, worldArt } from './world-art.mjs';
|
|
|
|
// Deprecated compatibility exports only. New trees are built from cube nodes;
|
|
// do not spend geometry on new OBJ files or infer runtime usage from this list.
|
|
export const LEGACY_MESH_SPECIES = Object.freeze(['oak','birch','pine','willow','alder']);
|
|
export const SPECIES_MESH_NAMES = Object.freeze(LEGACY_MESH_SPECIES.flatMap(s=>[
|
|
`${s}_seedling`,`${s}_young`,`${s}_mature`,...(s==='pine'?[]:[`${s}_young_winter`,`${s}_mature_winter`])]));
|
|
export const FLORA_NAMES = Object.freeze(['tree_seedling', 'young_tree', 'mature_tree', 'deadwood',
|
|
'young_tree_winter', 'mature_tree_winter',...SPECIES_MESH_NAMES]);
|
|
export const TREE_SEASONS = Object.freeze(['summer','spring','autumn','winter']);
|
|
export const SPECIES_ATLAS_NAMES = Object.freeze(SPECIES_NAMES.flatMap(s=>[
|
|
`${s}_atlas`,...(EVERGREEN_NAMES.includes(s)?[]:['spring','autumn','winter'].map(season=>`${s}_atlas_${season}`))]));
|
|
const sub = (a,b) => a.map((n,i)=>n-b[i]);
|
|
const cross = (a,b) => [a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0]];
|
|
const dot = (a,b) => a.reduce((s,n,i)=>s+n*b[i],0);
|
|
const unit = a => a.map(n=>n/Math.hypot(...a));
|
|
const directions = [[1,0],[Math.SQRT1_2,Math.SQRT1_2],[0,1],[-Math.SQRT1_2,Math.SQRT1_2],
|
|
[-1,0],[-Math.SQRT1_2,-Math.SQRT1_2],[0,-1],[Math.SQRT1_2,-Math.SQRT1_2]];
|
|
const number = n => Number(n.toFixed(6));
|
|
|
|
class Sculpture {
|
|
vertices=[]; uv=[]; normals=[]; faces=[]; groups=[];
|
|
solid(name, points, triangles, material) {
|
|
const center=[0,1,2].map(i=>points.reduce((s,p)=>s+p[i],0)/points.length);
|
|
const start=this.vertices.length;
|
|
this.groups.push({name, start, count:points.length, faceStart:this.faces.length});
|
|
this.vertices.push(...points.map(p=>p.map(number)));
|
|
// Each face has an explicit flat normal and its own inset UV triangle.
|
|
// OBJ V is bottom-up; both halves use the full 32px material height.
|
|
const u0=(material==='bark'?0.5:32.5)/64, u1=(material==='bark'?31.5:63.5)/64;
|
|
for(let ids of triangles) {
|
|
ids=[...ids];
|
|
let [a,b,c]=ids.map(i=>this.vertices[start+i]);
|
|
let normal=cross(sub(b,a),sub(c,a));
|
|
if(dot(normal,sub(a,center))<0) {
|
|
[ids[1],ids[2]]=[ids[2],ids[1]];
|
|
[a,b,c]=ids.map(i=>this.vertices[start+i]); normal=cross(sub(b,a),sub(c,a));
|
|
}
|
|
if(Math.hypot(...normal)<1e-8) throw new Error('Degenerate flora triangle');
|
|
const uvStart=this.uv.length;
|
|
this.uv.push([u0,0.5/32],[u1,0.5/32],[(u0+u1)/2,31.5/32]);
|
|
this.normals.push(unit(normal).map(number));
|
|
this.faces.push(ids.map((id,i)=>[start+id+1,uvStart+i+1,this.normals.length]));
|
|
}
|
|
}
|
|
branch(name, a,b,r0,r1) {
|
|
const axis=unit(sub(b,a)), side=unit(cross(axis,Math.abs(axis[1])<.9?[0,1,0]:[0,0,1]));
|
|
const up=cross(axis,side), points=[];
|
|
for(const [center,r] of [[a,r0],[b,r1]]) for(const [x,z] of directions)
|
|
points.push(center.map((n,i)=>n+r*(side[i]*x+up[i]*z)));
|
|
// A leaning stem still seats on a horizontal node-bottom cut, not below it.
|
|
if(a[1]===-5) for(let i=0;i<8;i++) points[i][1]=-5;
|
|
const triangles=[];
|
|
for(let i=0;i<8;i++) {
|
|
const j=(i+1)%8;
|
|
triangles.push([i,j,8+j],[i,8+j,8+i]);
|
|
}
|
|
for(let i=1;i<7;i++) triangles.push([0,i+1,i],[8,8+i,8+i+1]);
|
|
this.solid(name,points,triangles,'bark');
|
|
}
|
|
crown(name, center, radii, phase=0, shape='broad') {
|
|
// Three uneven eight-sided rings and off-axis tips make a lobed volume,
|
|
// not a cube, crossed plane or radially identical stack of spheres.
|
|
const profile=[1,.88,.94,1,.9,.98,1,.86], points=[];
|
|
const rings=shape==='conifer'?[[-.65,.88],[-.4,1],[.25,.48]]:[[-.55,.72],[0,1],[.55,.65]];
|
|
for(const [level,width] of rings) directions.forEach(([x,z],i)=> {
|
|
const bulge=profile[(i+phase)%8];
|
|
points.push([center[0]+x*radii[0]*width*bulge,center[1]+level*radii[1],center[2]+z*radii[2]*width*bulge]);
|
|
});
|
|
points.push([center[0]-.12*radii[0],center[1]-radii[1],center[2]+.08*radii[2]],
|
|
[center[0]+.08*radii[0],center[1]+radii[1],center[2]-.1*radii[2]]);
|
|
const triangles=[];
|
|
for(let i=0;i<8;i++) {
|
|
const j=(i+1)%8;
|
|
triangles.push([24,j,i],[25,16+i,16+j]);
|
|
for(let ring=0;ring<2;ring++) {
|
|
const k=ring*8; triangles.push([k+i,k+j,k+8+j],[k+i,k+8+j,k+8+i]);
|
|
}
|
|
}
|
|
this.solid(name,points,triangles,'leaf');
|
|
}
|
|
obj() {
|
|
const lines=['# Original Last Hearth volumetric ecology; 10 units/node; ground Y=-5','s off'];
|
|
for(const v of this.vertices) lines.push(`v ${v.join(' ')}`);
|
|
for(const t of this.uv) lines.push(`vt ${t.join(' ')}`);
|
|
for(const n of this.normals) lines.push(`vn ${n.join(' ')}`);
|
|
for(let i=0;i<this.faces.length;i++) {
|
|
const group=this.groups.find(g=>g.faceStart===i);
|
|
if(group) lines.push(`g ${group.name}`);
|
|
lines.push(`f ${this.faces[i].map(p=>p.join('/')).join(' ')}`);
|
|
}
|
|
return lines.join('\n')+'\n';
|
|
}
|
|
}
|
|
|
|
// Every species has an authored branching architecture, not a rescaled generic
|
|
// crown. Mature bounds fit the ecosystem's ±1.5 by five-node clearance. Young
|
|
// forms are half-size around ground Y=-5, hence ≤±.75 by 2.5 nodes.
|
|
function speciesSculpture(species,stage,winter) {
|
|
const m=new Sculpture(), conifer=species==='pine';
|
|
if(stage==='seedling') {
|
|
const index=SPECIES_NAMES.indexOf(species), lean=(index-2)*.22;
|
|
m.branch('stem',[0,-5,0],[lean,.8+index*.2,.2],.22,.07);
|
|
m.branch('twig',[0,-2.5,0],[-1.3,-.2,index*.2],.12,.04);
|
|
if(conifer) for(let i=0;i<3;i++)
|
|
m.crown(`leaf_tier_${i}`,[0,-1.7+i*1.6,0],[2-i*.5,1.6,1.9-i*.5],i,'conifer');
|
|
else {
|
|
m.crown('leaf_left',[-1.2,-.4,index*.15],[1.3,1.2,1.1],index);
|
|
m.crown('leaf_right',[.9,.7+index*.2,-.3],[1.2,conifer?2:1.5,1],index+2);
|
|
}
|
|
return m;
|
|
}
|
|
let limbs,clusters;
|
|
if(species==='oak') {
|
|
m.branch('trunk',[0,-5,0],[.7,23,.4],1.65,.65);
|
|
limbs=[[[0,8,0],[-9,24,2]],[[.2,12,0],[9,27,-2]],[[.5,18,0],[-2,35,3]],
|
|
[[.3,13,0],[2,25,-9]],[[.3,15,.2],[3,27,9]]];
|
|
clusters=[[[-8,26,2],[6.7,7,6]],[[8,28,-2],[6.3,7,6]],[[0,35,2],[7,8.5,6.7]],
|
|
[[1,26,-8],[6,6.5,6]],[[3,28,8],[6.2,6,6.4]],[[0,28,0],[6,7,6]]];
|
|
} else if(species==='birch') {
|
|
m.branch('trunk',[0,-5,0],[1.2,38,-.7],.85,.22);
|
|
limbs=[[[.3,16,0],[-4.8,27,1]],[[.6,23,-.2],[5.3,33,-2]],
|
|
[[1,29,-.5],[-3,38,2.4]],[[.5,21,-.3],[1.5,29,-5]]];
|
|
clusters=[[[-4.5,29,1],[3.6,5.3,3.8]],[[5.2,34,-2],[3.5,5,3.3]],
|
|
[[-3,38,2],[3.5,5.3,3.5]],[[1,40,-.8],[3.2,4,3]],[[1,30,-5],[3.5,5,3.3]],
|
|
[[2,25,4],[3.3,4,3.4]]];
|
|
} else if(conifer) {
|
|
m.branch('trunk',[0,-5,0],[.25,43,.1],1.05,.08);
|
|
limbs=[];
|
|
for(let i=0;i<4;i++) for(const [j,[x,z]] of [[-1,.2],[.6,.8],[.4,-1]].entries()) {
|
|
const length=10-i*2.2, y=8+i*8;
|
|
limbs.push([[0,y,0],[x*length,y+1,z*length]]);
|
|
// Separate tapered whorls, daylight gaps, and drooped lower skirts.
|
|
m.crown(`foliage_tier_${i}_${j}`,[x*length*.45,y+3,z*length*.45],
|
|
[length*.68,5.8-i*.3,length*.64],i+j,'conifer');
|
|
}
|
|
m.crown('foliage_leader',[.2,39,.1],[3.3,5.3,3.1],2,'conifer');
|
|
clusters=[];
|
|
} else if(species==='willow') {
|
|
m.branch('trunk',[0,-5,0],[-1,20,.7],1.4,.75);
|
|
limbs=[[[0,7,0],[-9,27,1]],[[0,10,0],[9,29,-2]],[[0,14,0],[0,34,3]],
|
|
[[0,12,0],[1,26,-9]],[[0,13,0],[3,26,9]]];
|
|
clusters=[[[-7,28,1],[6,5,6]],[[7,30,-2],[6,5,6]],[[0,34,2],[6,6,5]],
|
|
[[0,27,-7],[6,5,6]],[[3,28,7],[6,5,6]]];
|
|
for(const [i,[x,y,z]] of [[-11,23,1],[11,25,-2],[-5,24,-10],[3,23,11],[8,24,8],[-9,23,8]].entries()) {
|
|
m.branch(`pendant_${i}`,[x*.75,y+3,z*.75],[x,y-11,z],.17,.045);
|
|
if(!winter) m.crown(`foliage_curtain_${i}`,[x,y-4,z],[2.5,9,2.3],i);
|
|
}
|
|
} else { // Alder: upright multiple leaders and a compact rounded riparian crown.
|
|
m.branch('trunk',[0,-5,0],[.3,18,.2],1.15,.5);
|
|
limbs=[[[0,2,0],[-5,27,1]],[[0,5,0],[5.8,28,-1]],[[0,10,0],[0,32,3]],
|
|
[[0,9,0],[1,25,-5]]];
|
|
clusters=[[[-5,27,1],[5,7,4.7]],[[5.5,28,-1],[5,7,5]],[[0,32,3],[5.5,7,5]],
|
|
[[1,26,-5],[5,6,5]],[[0,24,1],[6,6,5]]];
|
|
}
|
|
limbs.forEach(([a,b],i)=> {
|
|
m.branch(`bough_${i}`,a,b,conifer?.28:species==='birch'?.3:.6,conifer?.08:.15);
|
|
if(!conifer) {
|
|
const start=a.map((n,j)=>n+(b[j]-n)*.7), sign=Math.sign(b[0]) || (i%2?-1:1);
|
|
m.branch(`twig_${i}`,start,[b[0]+sign*1.8,b[1]+1,b[2]+(i%2?-1.5:1.5)],.15,.035);
|
|
}
|
|
});
|
|
if(!winter) clusters.forEach(([c,r],i)=>m.crown(`foliage_${i}`,c,r,i+SPECIES_NAMES.indexOf(species)));
|
|
if(stage==='young') m.vertices=m.vertices.map(([x,y,z])=>[number(x*.5),number((y+5)*.5-5),number(z*.5)]);
|
|
return m;
|
|
}
|
|
|
|
function sculpture(name) {
|
|
if(!FLORA_NAMES.includes(name)) throw new Error('Unknown flora mesh');
|
|
const match=name.match(/^(oak|birch|pine|willow|alder)_(seedling|young|mature)(_winter)?$/);
|
|
if(match) return speciesSculpture(match[1],match[2],Boolean(match[3]));
|
|
const m=new Sculpture();
|
|
if(name==='deadwood') {
|
|
m.branch('fallen_trunk',[0,-3.4,-8],[.2,-3.4,8],1.6,1.3);
|
|
m.branch('broken_left',[0,-3.1,-2],[-3.9,-1.4,-4.8],.6,.24);
|
|
m.branch('broken_right',[.1,-3,2],[3.9,-.6,4.7],.55,.2);
|
|
m.branch('fork',[2.2,-1.7,3.5],[3.3,-1.2,6.6],.3,.12);
|
|
return m;
|
|
}
|
|
if(name==='tree_seedling') {
|
|
m.branch('stem',[0,-5,0],[.12,.1,-.05],.22,.09);
|
|
m.branch('twig', [0,-2.8,0],[-1.2,-1,0],.12,.06);
|
|
m.crown('leaf_left',[-1.15,-1.1,.2],[1.5,1.4,1.25]);
|
|
m.crown('leaf_right',[1,-.1,-.35],[1.5,2.1,1.4],2);
|
|
return m;
|
|
}
|
|
const winter=name.endsWith('_winter'), mature=name.startsWith('mature_tree');
|
|
m.branch('trunk',[0,-5,0],[.15,mature?15:7,.1],mature?1.2:.85,mature?.7:.35);
|
|
const limbs=mature ? [
|
|
[[0,5,0],[-5,16,1],.75,.28],[[0,8,0],[5.7,19,-1],.65,.24],
|
|
[[0,11,0],[-1,23,2.5],.55,.2],[[0,8,0],[1,17,-5],.55,.2],
|
|
] : [
|
|
[[0,0,0],[-2.8,6,.5],.36,.13],[[0,2,0],[3,8,-.4],.3,.12],
|
|
[[0,4,0],[0,10,1.2],.24,.09],
|
|
];
|
|
limbs.forEach(([a,b,r0,r1],i)=>m.branch(`bough_${i}`,a,b,r0,r1));
|
|
if(winter) {
|
|
// Preserve every original trunk/bough vertex, UV and normal. Add woody
|
|
// lateral forks along the boughs, never a recoloured canopy or leaf planes.
|
|
limbs.forEach(([a,b],i)=> {
|
|
const start=a.map((n,j)=>n+(b[j]-n)*.62), sign=Math.sign(b[0]-a[0]) || (i%2?-1:1);
|
|
const tip=[b[0]+sign*(mature?2.2:1.3),b[1]-.8,b[2]+sign*(mature?1.8:1)];
|
|
m.branch(`winter_fork_${i}`,start,tip,mature?.22:.11,mature?.06:.035);
|
|
});
|
|
return m;
|
|
}
|
|
const clusters=mature ? [
|
|
[[-5,16,1],[6,6,6]],[[5,19,-1],[6,6,6]],[[0,23,1],[6,7,6]],
|
|
[[0,16,-5],[6,5.5,6]],[[1,15,5],[6,5,6]],
|
|
] : [
|
|
[[-2.5,6,.5],[4,4,4]],[[2.5,8,-.4],[4,4.5,4]],
|
|
[[0,10.5,1],[3.5,4.5,3.5]],[[.3,6,-2],[3.5,3.5,4]],
|
|
];
|
|
clusters.forEach(([c,r],i)=>m.crown(`foliage_${i}`,c,r,i*2));
|
|
return m;
|
|
}
|
|
|
|
export function floraOBJ(name) { return sculpture(name).obj(); }
|
|
export function floraBounds(name) {
|
|
const {vertices}=sculpture(name);
|
|
return {min:[0,1,2].map(i=>Math.min(...vertices.map(v=>v[i]))/10),
|
|
max:[0,1,2].map(i=>Math.max(...vertices.map(v=>v[i]))/10)};
|
|
}
|
|
|
|
export function treeAtlas(art=worldArt(), season='summer', species=null) {
|
|
if(!TREE_SEASONS.includes(season)) throw new Error('Unknown tree season');
|
|
if(species!==null && !SPECIES_NAMES.includes(species)) throw new Error('Unknown tree species');
|
|
if(EVERGREEN_NAMES.includes(species) && season!=='summer') throw new Error('Conifer uses its evergreen summer atlas');
|
|
// Two 32px patches, no external MTL. Leaves keep a dark opaque underpaint:
|
|
// silhouette holes come from gaps between 3D lobes, never torn polygon faces.
|
|
const data=new Uint8Array(64*32*4);
|
|
const prefix=species?`${species}_`:'', leaves=`${prefix}leaves${season==='summer'?'':`_${season}`}`;
|
|
const underpaint=season==='summer' && species?
|
|
{oak:'leafDark',birch:'leaf',pine:'pineShade',willow:'willowShade',alder:'leafDark',
|
|
beech:'leafDark',aspen:'leafDark',rowan:'leafDark',hazel:'leafDark',spruce:'pineShade',
|
|
crab_apple:'leafDark',wild_cherry:'leafDark',field_maple:'leafDark'}[species]:
|
|
{summer:'leafDark',spring:'springDark',autumn:'autumnDark',winter:'barkDark'}[season];
|
|
for(const [half,name] of [`${prefix}log_side`,leaves].entries()) {
|
|
const image=art.get(`hearth_${name}.png`);
|
|
if(!image || image.width!==32 || image.height!==32 || image.data.length!==4096)
|
|
throw new Error('Tree atlas requires 32px RGBA bark and leaves');
|
|
for(let y=0;y<32;y++) for(let x=0;x<32;x++) {
|
|
const p=image.data.subarray((y*32+x)*4,(y*32+x+1)*4);
|
|
data.set(p[3]===255?p:[...PALETTE[underpaint],255],(y*64+half*32+x)*4);
|
|
}
|
|
}
|
|
return {width:64,height:32,data};
|
|
}
|