Spaces:
Paused
Paused
Download src/jiangnan/engine/trees.ts from Ethscriptions/video: direct link, hf CLI and curl.
- Browser
- Download file 22.8 kB
-
https://huggingface.co/spaces/Ethscriptions/video/resolve/main/src/jiangnan/engine/trees.ts
- Command line
-
hf download hf://spaces/Ethscriptions/video/src/jiangnan/engine/trees.ts
-
curl -L -o trees.ts https://huggingface.co/spaces/Ethscriptions/video/resolve/main/src/jiangnan/engine/trees.ts
22.8 kB
| // Vegetation: the ancient camphor tree, village trees, weeping willows, | |
| // bamboo groves, hillside forest and riverside reeds. | |
| import * as THREE from 'three' | |
| import { Builder } from './geom' | |
| import { | |
| buildHouses, GROUND_Y, PAVILION_POS, riverHalfWidth, riverPoint, riverQuery, terraceMask, terrainHeight, TREE_POS, VILLAGE_S0, VILLAGE_S1, villageFactor, | |
| } from './layout' | |
| import { patch, U } from './materials' | |
| import { fbm2, mulberry32, Rng, rrange } from './rng' | |
| import { getTextures } from './textures' | |
| import { NEAR, worldHeight } from './terrain' | |
| const UP = new THREE.Vector3(0, 1, 0) | |
| function leafMaterial(map: THREE.Texture, opts: { center?: THREE.Vector3; sway?: number; key: string }) { | |
| const center = opts.center || new THREE.Vector3() | |
| const mat = patch(new THREE.MeshStandardMaterial({ map, alphaTest: 0.3, alphaToCoverage: true, side: THREE.DoubleSide, roughness: 0.82, metalness: 0 }), { | |
| key: opts.key, | |
| vertexPars: 'uniform vec3 uCrown; uniform float uSway; attribute vec3 instanceTint; varying vec3 vTint;', | |
| vertex: ` | |
| vTint = instanceTint; | |
| #ifdef USE_INSTANCING | |
| vec3 ip = (modelMatrix * instanceMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz; | |
| #else | |
| vec3 ip = vec3(0.0); | |
| #endif | |
| float ph = ip.x * 0.21 + ip.z * 0.13; | |
| float sw = sin(uTime * 1.4 + ph) * 0.6 + sin(uTime * 2.6 + ph * 1.9) * 0.3; | |
| float rustle = sin(uTime * 6.0 + position.x * 4.0 + position.y * 3.0 + ph * 5.0); | |
| transformed += vec3(sw * 0.6, sw * 0.15, sw * 0.3) * uSway * uWind + normal * rustle * 0.04 * uWind; | |
| `, | |
| fragmentPars: 'uniform vec3 uSunColor; varying vec3 vTint;', | |
| colorFrag: 'diffuseColor.rgb *= vTint;', | |
| fragment: ` | |
| vec3 vd = normalize(vFogWorld - cameraPosition); | |
| float back = pow(max(dot(vd, uSunDir), 0.0), 3.0); | |
| totalEmissiveRadiance += diffuseColor.rgb * uSunColor * back * 0.55; | |
| `, | |
| uniforms: { uCrown: { value: center }, uSway: { value: opts.sway ?? 0.15 }, uSunColor: U.uSunColor }, | |
| }) | |
| const prev = mat.onBeforeCompile | |
| mat.onBeforeCompile = (s, r) => { | |
| prev.call(mat, s, r) | |
| // spherical "crown" normals give soft volumetric shading instead of flat cards | |
| s.vertexShader = s.vertexShader.replace('#include <beginnormal_vertex>', ` | |
| vec3 objectNormal = normal; | |
| #ifdef USE_INSTANCING | |
| vec3 ipn = (modelMatrix * instanceMatrix * vec4(position * 0.6, 1.0)).xyz; | |
| vec3 wn = normalize(ipn - uCrown + vec3(0.0, 2.0, 0.0)); | |
| objectNormal = normalize(transpose(mat3(modelMatrix * instanceMatrix)) * wn); | |
| #endif | |
| #ifdef USE_TANGENT | |
| vec3 objectTangent = vec3( tangent.xyz ); | |
| #endif | |
| `) | |
| } | |
| return mat | |
| } | |
| function barkMaterial(key: string) { | |
| const T = getTextures() | |
| return patch(new THREE.MeshStandardMaterial({ map: T.bark, normalMap: T.barkN, roughness: 0.92, color: new THREE.Color(0.85, 0.82, 0.78) }), { key }) | |
| } | |
| /** Cluster card: three crossed quads. */ | |
| function clusterGeometry(size: number) { | |
| const b = new Builder() | |
| const h = size / 2 | |
| for (let k = 0; k < 3; k++) { | |
| const a = (k / 3) * Math.PI | |
| const c = Math.cos(a) * h, s = Math.sin(a) * h | |
| const tilt = k === 2 ? 0.5 : 0 | |
| b.quad({ x: -c, y: -h + tilt, z: -s }, { x: c, y: -h - tilt, z: s }, { x: c, y: h - tilt, z: s }, { x: -c, y: h + tilt, z: -s }, [0, 0, 1, 0, 1, 1, 0, 1]) | |
| } | |
| // a horizontal card to fill the crown from above | |
| b.quad({ x: -h, y: 0, z: h }, { x: h, y: 0, z: h }, { x: h, y: 0, z: -h }, { x: -h, y: 0, z: -h }, [0, 0, 1, 0, 1, 1, 0, 1], { x: 0, y: 1, z: 0 }) | |
| return b.build() | |
| } | |
| interface BranchOpts { maxDepth: number; spread: number; lenFall: number; childMin: number; childMax: number; up: number; leafEvery: number } | |
| /** Recursive branching skeleton → bark geometry + leaf cluster anchors. */ | |
| function growTree(rng: Rng, base: THREE.Vector3, height: number, radius: number, o: BranchOpts) { | |
| const bark = new Builder() | |
| const leaves: { p: THREE.Vector3; s: number }[] = [] | |
| const seg = (a: THREE.Vector3, b: THREE.Vector3, r0: number, r1: number) => { | |
| const d = new THREE.Vector3().subVectors(b, a) | |
| const L = d.length() | |
| const radial = r0 > 0.5 ? 14 : r0 > 0.15 ? 8 : 5 | |
| const g = new THREE.CylinderGeometry(r1, r0, L * 1.04, radial, 1, true) | |
| const uv = g.getAttribute('uv') as THREE.BufferAttribute | |
| for (let i = 0; i < uv.count; i++) uv.setXY(i, uv.getX(i) * Math.max(1, Math.round(r0 * 6)), uv.getY(i) * L / 2.5) | |
| const q = new THREE.Quaternion().setFromUnitVectors(UP, d.clone().normalize()) | |
| const m = new THREE.Matrix4().compose(a.clone().addScaledVector(d, 0.5), q, new THREE.Vector3(1, 1, 1)) | |
| bark.geometry(g, m) | |
| } | |
| const branch = (start: THREE.Vector3, dir: THREE.Vector3, len: number, r: number, depth: number) => { | |
| const steps = depth === 0 ? 5 : 3 | |
| let p = start.clone() | |
| let d = dir.clone().normalize() | |
| let rr = r | |
| for (let i = 0; i < steps; i++) { | |
| const sl = len / steps | |
| // gnarled growth: random bends + gentle upward tendency | |
| d.add(new THREE.Vector3(rrange(rng, -0.28, 0.28), rrange(rng, -0.12, 0.2) + o.up * 0.15, rrange(rng, -0.28, 0.28))).normalize() | |
| const np = p.clone().addScaledVector(d, sl) | |
| const nr = rr * (depth === 0 ? 0.88 : 0.8) | |
| seg(p, np, rr, nr) | |
| if (depth >= o.maxDepth - 1 && i >= steps - 2 && rng() < o.leafEvery) leaves.push({ p: np.clone(), s: 1 }) | |
| p = np | |
| rr = nr | |
| } | |
| if (depth >= o.maxDepth) { | |
| leaves.push({ p: p.clone(), s: 1.15 }) | |
| return | |
| } | |
| const kids = o.childMin + Math.floor(rng() * (o.childMax - o.childMin + 1)) | |
| for (let k = 0; k < kids; k++) { | |
| const az = (k / kids) * Math.PI * 2 + rng() * 1.2 | |
| const tilt = o.spread * (0.6 + rng() * 0.6) | |
| // child direction: rotate parent dir away by `tilt` around a random perpendicular axis | |
| const perp = new THREE.Vector3(Math.cos(az), 0, Math.sin(az)).cross(d).normalize() | |
| if (perp.lengthSq() < 1e-4) perp.set(1, 0, 0) | |
| const cd = d.clone().applyAxisAngle(perp, tilt) | |
| cd.y = Math.max(cd.y, -0.15) | |
| branch(p, cd, len * o.lenFall * (0.8 + rng() * 0.4), rr * 0.72, depth + 1) | |
| } | |
| } | |
| branch(base, UP.clone(), height * 0.32, radius, 0) | |
| return { bark, leaves } | |
| } | |
| export interface TreesOut { group: THREE.Group; camphorTop: THREE.Vector3 } | |
| export function createTrees(quality: 'low' | 'medium' | 'high' = 'high'): TreesOut { | |
| const density = quality === 'high' ? 1 : quality === 'medium' ? 0.55 : 0.32 | |
| const T = getTextures() | |
| const group = new THREE.Group() | |
| const rng = mulberry32(777) | |
| // ------------------------------------------------ ancient camphor (古樟) | |
| const tb = new THREE.Vector3(TREE_POS.x, GROUND_Y - 0.4, TREE_POS.z) | |
| const camphor = growTree(rng, tb, 24, 1.25, { maxDepth: 4, spread: 0.75, lenFall: 0.72, childMin: 2, childMax: 4, up: 0.2, leafEvery: 0.7 }) | |
| // buttress roots | |
| for (let k = 0; k < 7; k++) { | |
| const a = (k / 7) * Math.PI * 2 + rng() * 0.4 | |
| const len = 3 + rng() * 2.5 | |
| const g = new THREE.CylinderGeometry(0.12, 0.55, len, 8, 1, true) | |
| const end = new THREE.Vector3(Math.cos(a) * len * 0.9, -0.55, Math.sin(a) * len * 0.9) | |
| const startP = new THREE.Vector3(Math.cos(a) * 0.6, 1.1, Math.sin(a) * 0.6) | |
| const d = end.clone().sub(startP) | |
| const q = new THREE.Quaternion().setFromUnitVectors(UP, d.clone().normalize().negate()) | |
| camphor.bark.geometry(g, new THREE.Matrix4().compose(tb.clone().add(startP).addScaledVector(d, 0.5), q, new THREE.Vector3(1, 1, 1))) | |
| } | |
| const barkMat = barkMaterial('bark') | |
| const barkMesh = new THREE.Mesh(camphor.bark.build(), barkMat) | |
| barkMesh.castShadow = true | |
| barkMesh.receiveShadow = true | |
| group.add(barkMesh) | |
| const crown = new THREE.Vector3() | |
| camphor.leaves.forEach((l) => crown.add(l.p)) | |
| crown.multiplyScalar(1 / camphor.leaves.length) | |
| { | |
| const geo = clusterGeometry(3.4) | |
| const list: { p: THREE.Vector3; s: number }[] = [] | |
| for (const l of camphor.leaves) { | |
| list.push(l) | |
| // densify around each tip | |
| for (let k = 0; k < 3; k++) list.push({ p: l.p.clone().add(new THREE.Vector3(rrange(rng, -1.6, 1.6), rrange(rng, -0.8, 1.0), rrange(rng, -1.6, 1.6))), s: 0.9 }) | |
| } | |
| const mat = leafMaterial(T.leaf, { center: crown, sway: 0.06, key: 'camphorLeaf' }) | |
| const inst = instancedClusters(geo, mat, list, rng, [0.36, 0.5, 0.22], 0.25) | |
| group.add(inst) | |
| } | |
| // ------------------------------------------------ village trees & willows | |
| const houses = buildHouses() | |
| const occupied = (x: number, z: number, r: number) => houses.some((h) => Math.hypot(h.x - x, h.z - z) < Math.max(h.w, h.d) / 2 + r) | |
| const smallBark = new Builder() | |
| const smallLeaves: { p: THREE.Vector3; s: number }[] = [] | |
| const willowStrands: { p: THREE.Vector3; s: number }[] = [] | |
| let placed = 0 | |
| for (let tries = 0; tries < 600 && placed < 46; tries++) { | |
| const s = rrange(rng, VILLAGE_S0 - 60, VILLAGE_S1 + 80) | |
| const side = rng() < 0.5 ? -1 : 1 | |
| const off = side * rrange(rng, 18, 75) | |
| const p = riverPoint(s, off) | |
| if (occupied(p.x, p.z, 3.5)) continue | |
| if (Math.hypot(p.x - TREE_POS.x, p.z - TREE_POS.z) < 22) continue | |
| const y = terrainHeight(p.x, p.z) | |
| if (y < GROUND_Y - 0.5) continue | |
| const t = growTree(rng, new THREE.Vector3(p.x, y - 0.2, p.z), rrange(rng, 9, 14), rrange(rng, 0.22, 0.38), { maxDepth: 3, spread: 0.7, lenFall: 0.7, childMin: 2, childMax: 3, up: 0.3, leafEvery: 0.6 }) | |
| smallBark.geometry(t.bark.build()) | |
| smallLeaves.push(...t.leaves) | |
| placed++ | |
| } | |
| // weeping willows on the banks just outside the houses | |
| const willowBark = new Builder() | |
| for (const [s, side] of [[VILLAGE_S0 - 40, 1], [VILLAGE_S0 - 18, -1], [VILLAGE_S1 + 12, 1], [VILLAGE_S1 + 34, -1], [VILLAGE_S1 + 60, 1], [VILLAGE_S0 - 70, 1], [VILLAGE_S0 - 95, -1]] as [number, number][]) { | |
| const w = riverHalfWidth(s) | |
| const p = riverPoint(s, side * (w + 3.5)) | |
| const y = terrainHeight(p.x, p.z) | |
| const t = growTree(rng, new THREE.Vector3(p.x, y - 0.2, p.z), 11, 0.4, { maxDepth: 2, spread: 0.9, lenFall: 0.75, childMin: 3, childMax: 4, up: 0.1, leafEvery: 0.9 }) | |
| willowBark.geometry(t.bark.build()) | |
| for (const l of t.leaves) willowStrands.push(l) | |
| } | |
| smallBark.geometry(willowBark.build()) | |
| const sbMesh = new THREE.Mesh(smallBark.build(), barkMaterial('bark2')) | |
| sbMesh.castShadow = true | |
| group.add(sbMesh) | |
| { | |
| const geo = clusterGeometry(2.8) | |
| const mat = leafMaterial(T.leaf, { sway: 0.08, key: 'treeLeaf' }) | |
| group.add(instancedClusters(geo, mat, smallLeaves, rng, [0.32, 0.46, 0.2], 0.3)) | |
| } | |
| { | |
| // willow: long hanging strands (vertical cards anchored at the top) | |
| const b = new Builder() | |
| for (let k = 0; k < 3; k++) { | |
| const a = (k / 3) * Math.PI | |
| const c = Math.cos(a) * 1.4, s = Math.sin(a) * 1.4 | |
| b.quad({ x: -c, y: -5.5, z: -s }, { x: c, y: -5.5, z: s }, { x: c, y: 0, z: s }, { x: -c, y: 0, z: -s }, [0, 0, 1, 0, 1, 1, 0, 1]) | |
| } | |
| const geo = b.build() | |
| const mat = leafMaterial(T.bambooLeaf, { sway: 0.0, key: 'willow' }) | |
| const prev = mat.onBeforeCompile | |
| mat.onBeforeCompile = (sh, r) => { | |
| prev.call(mat, sh, r) | |
| sh.vertexShader = sh.vertexShader.replace('#include <project_vertex>', ` | |
| { | |
| float hang = clamp(-position.y / 5.5, 0.0, 1.0); | |
| transformed.x += sin(uTime * 1.2 + position.z + vTint.x * 9.0) * hang * hang * 0.7 * uWind; | |
| transformed.z += cos(uTime * 0.9 + position.x) * hang * hang * 0.4 * uWind; | |
| } | |
| #include <project_vertex>`) | |
| } | |
| const list: { p: THREE.Vector3; s: number }[] = [] | |
| for (const l of willowStrands) for (let k = 0; k < 4; k++) list.push({ p: l.p.clone().add(new THREE.Vector3(rrange(rng, -1.5, 1.5), rrange(rng, -0.3, 0.6), rrange(rng, -1.5, 1.5))), s: 1 }) | |
| group.add(instancedClusters(geo, mat, list, rng, [0.42, 0.58, 0.22], 0.2, true)) | |
| } | |
| // ------------------------------------------------ bamboo groves | |
| group.add(createBamboo(rng, density)) | |
| // ------------------------------------------------ hillside forest | |
| group.add(createForest(rng, density)) | |
| // ------------------------------------------------ reeds | |
| group.add(createReeds(rng)) | |
| return { group, camphorTop: crown } | |
| } | |
| function instancedClusters(geo: THREE.BufferGeometry, mat: THREE.Material, list: { p: THREE.Vector3; s: number }[], rng: Rng, tint: [number, number, number], vary: number, upright = false) { | |
| const inst = new THREE.InstancedMesh(geo, mat, list.length) | |
| const tints = new Float32Array(list.length * 3) | |
| const m = new THREE.Matrix4(), q = new THREE.Quaternion(), e = new THREE.Euler(), sc = new THREE.Vector3() | |
| list.forEach((l, i) => { | |
| e.set(upright ? 0 : rrange(rng, -0.4, 0.4), rng() * Math.PI * 2, upright ? 0 : rrange(rng, -0.4, 0.4)) | |
| q.setFromEuler(e) | |
| const s = l.s * rrange(rng, 0.8, 1.2) | |
| sc.set(s, s, s) | |
| m.compose(l.p, q, sc) | |
| inst.setMatrixAt(i, m) | |
| const k = 1 + rrange(rng, -vary, vary) | |
| const warm = rrange(rng, -0.08, 0.1) | |
| tints[i * 3] = tint[0] * k * (1 + warm) | |
| tints[i * 3 + 1] = tint[1] * k | |
| tints[i * 3 + 2] = tint[2] * k * (1 - warm) | |
| }) | |
| geo.setAttribute('instanceTint', new THREE.InstancedBufferAttribute(tints, 3)) | |
| inst.castShadow = true | |
| inst.receiveShadow = true | |
| inst.computeBoundingSphere() | |
| return inst | |
| } | |
| function createBamboo(rng: Rng, density = 1) { | |
| const T = getTextures() | |
| const group = new THREE.Group() | |
| // one clump: culms + leaf cards | |
| const culms = new Builder() | |
| const leafAnchors: THREE.Matrix4[] = [] | |
| const clumpRng = mulberry32(31) | |
| for (let c = 0; c < 11; c++) { | |
| const a = clumpRng() * Math.PI * 2, r = Math.sqrt(clumpRng()) * 1.2 | |
| const h = 9 + clumpRng() * 5 | |
| const lean = new THREE.Vector3(Math.cos(a), 0, Math.sin(a)).multiplyScalar(0.06 + clumpRng() * 0.1) | |
| const base = new THREE.Vector3(Math.cos(a) * r, 0, Math.sin(a) * r) | |
| const segs = 4 | |
| for (let i = 0; i < segs; i++) { | |
| const f0 = i / segs, f1 = (i + 1) / segs | |
| const p0 = base.clone().add(new THREE.Vector3(lean.x * h * f0 * f0 * 2, h * f0, lean.z * h * f0 * f0 * 2)) | |
| const p1 = base.clone().add(new THREE.Vector3(lean.x * h * f1 * f1 * 2, h * f1, lean.z * h * f1 * f1 * 2)) | |
| const d = p1.clone().sub(p0) | |
| const g = new THREE.CylinderGeometry(0.045 * (1 - f1 * 0.6), 0.05 * (1 - f0 * 0.6), d.length(), 4, 1, true) | |
| culms.geometry(g, new THREE.Matrix4().compose(p0.clone().addScaledVector(d, 0.5), new THREE.Quaternion().setFromUnitVectors(UP, d.clone().normalize()), new THREE.Vector3(1, 1, 1))) | |
| if (f0 > 0.45) { | |
| for (let k = 0; k < 2; k++) { | |
| const lp = p1.clone() | |
| const la = clumpRng() * Math.PI * 2 | |
| leafAnchors.push(new THREE.Matrix4().compose(lp.add(new THREE.Vector3(Math.cos(la) * 0.7, 0, Math.sin(la) * 0.7)), new THREE.Quaternion().setFromEuler(new THREE.Euler(clumpRng() - 0.5, la, clumpRng() - 0.5)), new THREE.Vector3(1, 1, 1))) | |
| } | |
| } | |
| } | |
| } | |
| const leafCards = new Builder() | |
| const lc = clusterGeometry(2.2) | |
| for (const m of leafAnchors) leafCards.geometry(lc, m) | |
| const culmGeo = culms.build() | |
| const leafGeo = leafCards.build() | |
| // grove placement: knolls and hill feet around the village, plus behind houses | |
| const houses = buildHouses() | |
| const spots: THREE.Matrix4[] = [] | |
| const tints: number[] = [] | |
| for (let tries = 0; tries < 9000 && spots.length < Math.round(650 * density); tries++) { | |
| const x = rrange(rng, -520, 560), z = rrange(rng, -420, 380) | |
| const q = riverQuery(x, z) | |
| if (q.d < 22) continue | |
| const grove = fbm2(x * 0.012, z * 0.012, 3, 61) | |
| const nearHill = q.d > 60 | |
| if (grove < (nearHill ? 0.5 : 0.62)) continue | |
| if (terraceMask(x, z) > 0.01) continue | |
| if (houses.some((h) => Math.hypot(h.x - x, h.z - z) < Math.max(h.w, h.d) / 2 + 3)) continue | |
| if (Math.hypot(x - TREE_POS.x, z - TREE_POS.z) < 30) continue | |
| if (Math.hypot(x - PAVILION_POS.x, z - PAVILION_POS.z) < 10) continue | |
| const y = terrainHeight(x, z) | |
| if (y > 160) continue | |
| const s = rrange(rng, 0.8, 1.25) | |
| spots.push(new THREE.Matrix4().compose(new THREE.Vector3(x, y - 0.3, z), new THREE.Quaternion().setFromAxisAngle(UP, rng() * 6.28), new THREE.Vector3(s, s * rrange(rng, 0.85, 1.2), s))) | |
| const k = rrange(rng, 0.85, 1.15) | |
| tints.push(0.4 * k, 0.56 * k, 0.2 * k) | |
| } | |
| const culmMat = patch(new THREE.MeshStandardMaterial({ color: new THREE.Color(0.32, 0.4, 0.14), roughness: 0.5 }), { | |
| key: 'culm', | |
| vertex: ` | |
| #ifdef USE_INSTANCING | |
| vec3 ip = (modelMatrix * instanceMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz; | |
| #else | |
| vec3 ip = vec3(0.0); | |
| #endif | |
| float hb = max(position.y, 0.0) / 12.0; | |
| float sw = sin(uTime * 1.1 + ip.x * 0.2 + ip.z * 0.1) * 0.7 + sin(uTime * 2.3 + ip.x * 0.3) * 0.25; | |
| transformed.x += sw * hb * hb * 0.9 * uWind; | |
| transformed.z += sw * hb * hb * 0.4 * uWind; | |
| `, | |
| }) | |
| const leafMat = leafMaterial(T.bambooLeaf, { sway: 0.0, key: 'bambooLeaf' }) | |
| const prev = leafMat.onBeforeCompile | |
| leafMat.onBeforeCompile = (sh, r) => { | |
| prev.call(leafMat, sh, r) | |
| sh.vertexShader = sh.vertexShader.replace('#include <project_vertex>', ` | |
| { | |
| float hb = max(position.y, 0.0) / 12.0; | |
| float sw = sin(uTime * 1.1 + ip.x * 0.2 + ip.z * 0.1) * 0.7 + sin(uTime * 2.3 + ip.x * 0.3) * 0.25; | |
| transformed.x += sw * hb * hb * 0.9 * uWind; | |
| transformed.z += sw * hb * hb * 0.4 * uWind; | |
| } | |
| #include <project_vertex>`) | |
| } | |
| const culmInst = new THREE.InstancedMesh(culmGeo, culmMat, spots.length) | |
| const leafInst = new THREE.InstancedMesh(leafGeo, leafMat, spots.length) | |
| spots.forEach((m, i) => { culmInst.setMatrixAt(i, m); leafInst.setMatrixAt(i, m) }) | |
| leafGeo.setAttribute('instanceTint', new THREE.InstancedBufferAttribute(new Float32Array(tints), 3)) | |
| culmInst.castShadow = false | |
| leafInst.castShadow = true | |
| leafInst.receiveShadow = true | |
| culmInst.layers.set(1) | |
| leafInst.layers.set(1) | |
| culmInst.computeBoundingSphere() | |
| leafInst.computeBoundingSphere() | |
| group.add(culmInst, leafInst) | |
| return group | |
| } | |
| function createForest(rng: Rng, density = 1) { | |
| const group = new THREE.Group() | |
| // broadleaf blob + fir cone, vertex-noise deformed | |
| const blob = new THREE.IcosahedronGeometry(1, 1) | |
| { | |
| const p = blob.getAttribute('position') as THREE.BufferAttribute | |
| for (let i = 0; i < p.count; i++) { | |
| const v = new THREE.Vector3(p.getX(i), p.getY(i), p.getZ(i)) | |
| const n = fbm2(v.x * 1.7 + v.z, v.y * 1.7 + v.z * 0.5, 3, 4) | |
| v.multiplyScalar(0.75 + n * 0.55) | |
| v.y = v.y * 0.85 + 0.6 | |
| p.setXYZ(i, v.x, v.y, v.z) | |
| } | |
| blob.computeVertexNormals() | |
| } | |
| const fir = new THREE.ConeGeometry(0.55, 2.6, 7, 3) | |
| fir.translate(0, 1.3, 0) | |
| { | |
| const p = fir.getAttribute('position') as THREE.BufferAttribute | |
| for (let i = 0; i < p.count; i++) { | |
| const y = p.getY(i) | |
| const ring = Math.sin(y * 7.0) * 0.08 | |
| p.setX(i, p.getX(i) * (1 + ring)) | |
| p.setZ(i, p.getZ(i) * (1 + ring)) | |
| } | |
| fir.computeVertexNormals() | |
| } | |
| const mats = [blob, fir].map((g, gi) => patch(new THREE.MeshStandardMaterial({ roughness: 0.95, flatShading: false }), { | |
| key: 'forest' + gi, | |
| vertexPars: 'attribute vec3 instanceTint; varying vec3 vTint; varying float vLocalY;', | |
| vertex: 'vTint = instanceTint; vLocalY = position.y;', | |
| fragmentPars: 'varying vec3 vTint; varying float vLocalY;', | |
| colorFrag: 'diffuseColor.rgb = vTint * (0.7 + 0.3 * smoothstep(0.0, 1.6, vLocalY));', | |
| })) | |
| const lists: THREE.Matrix4[][] = [[], []] | |
| const tints: number[][] = [[], []] | |
| const area = { x0: -1500, x1: 1500, z0: -1300, z1: 1200 } | |
| for (let tries = 0; tries < 60000 && lists[0].length + lists[1].length < Math.round(9000 * density); tries++) { | |
| const x = rrange(rng, area.x0, area.x1), z = rrange(rng, area.z0, area.z1) | |
| const q = riverQuery(x, z) | |
| if (q.d < 70) continue | |
| if (villageFactor(q.s) > 0.2 && q.d < 140) continue | |
| if (terraceMask(x, z) > 0.02) continue | |
| const inside = x > NEAR.x0 && x < NEAR.x1 && z > NEAR.z0 && z < NEAR.z1 | |
| const y = inside ? terrainHeight(x, z) : worldHeight(x, z) | |
| if (y < 8) continue | |
| const dens = fbm2(x * 0.006, z * 0.006, 3, 13) | |
| if (dens < 0.42) continue | |
| const kind = fbm2(x * 0.003, z * 0.003, 2, 99) > 0.55 ? 1 : 0 | |
| const s = kind === 0 ? rrange(rng, 3.2, 6.5) : rrange(rng, 2.6, 4.2) | |
| const m = new THREE.Matrix4().compose(new THREE.Vector3(x, y - 0.6, z), new THREE.Quaternion().setFromAxisAngle(UP, rng() * 6.28), new THREE.Vector3(s * rrange(rng, 0.8, 1.2), s * (kind ? rrange(rng, 2.2, 3.2) : rrange(rng, 0.8, 1.1)), s * rrange(rng, 0.8, 1.2))) | |
| lists[kind].push(m) | |
| const k = rrange(rng, 0.7, 1.25) | |
| const autumn = rng() < 0.06 ? 1 : 0 | |
| tints[kind].push((kind ? 0.035 : 0.06 + autumn * 0.12) * k, (kind ? 0.07 : 0.1 + autumn * 0.04) * k, 0.035 * k) | |
| } | |
| ;[blob, fir].forEach((g, gi) => { | |
| const inst = new THREE.InstancedMesh(g, mats[gi], lists[gi].length) | |
| lists[gi].forEach((m, i) => inst.setMatrixAt(i, m)) | |
| g.setAttribute('instanceTint', new THREE.InstancedBufferAttribute(new Float32Array(tints[gi]), 3)) | |
| // distant hillside forest: main view only (no shadow / reflection passes) | |
| inst.castShadow = false | |
| inst.receiveShadow = false | |
| inst.layers.set(1) | |
| inst.computeBoundingSphere() | |
| group.add(inst) | |
| }) | |
| return group | |
| } | |
| function createReeds(rng: Rng) { | |
| const T = getTextures() | |
| const b = new Builder() | |
| for (let k = 0; k < 2; k++) { | |
| const a = (k / 2) * Math.PI | |
| const c = Math.cos(a) * 0.9, s = Math.sin(a) * 0.9 | |
| b.quad({ x: -c, y: 0, z: -s }, { x: c, y: 0, z: s }, { x: c, y: 1.9, z: s }, { x: -c, y: 1.9, z: -s }, [0.25, 0, 0.75, 0, 0.75, 1, 0.25, 1]) | |
| } | |
| const geo = b.build() | |
| const list: THREE.Matrix4[] = [] | |
| const tints: number[] = [] | |
| for (let s = 0; s < 3600; s += rrange(rng, 1.5, 4)) { | |
| const vf = villageFactor(s) | |
| if (vf > 0.05) continue | |
| for (const side of [-1, 1]) { | |
| if (rng() < 0.35) continue | |
| const w = riverHalfWidth(s) | |
| const p = riverPoint(s, side * (w + rrange(rng, -0.8, 1.6))) | |
| if (Math.abs(p.x) > 1400) continue | |
| const y = terrainHeight(p.x, p.z) | |
| const sc = rrange(rng, 0.7, 1.3) | |
| list.push(new THREE.Matrix4().compose(new THREE.Vector3(p.x, Math.max(y, -0.2), p.z), new THREE.Quaternion().setFromAxisAngle(UP, rng() * 6.28), new THREE.Vector3(sc, sc * rrange(rng, 0.8, 1.4), sc))) | |
| const k = rrange(rng, 0.8, 1.2) | |
| tints.push(0.55 * k, 0.55 * k, 0.28 * k) | |
| } | |
| } | |
| const mat = leafMaterial(T.bambooLeaf, { sway: 0.05, key: 'reed' }) | |
| const inst = new THREE.InstancedMesh(geo, mat, list.length) | |
| list.forEach((m, i) => inst.setMatrixAt(i, m)) | |
| geo.setAttribute('instanceTint', new THREE.InstancedBufferAttribute(new Float32Array(tints), 3)) | |
| inst.computeBoundingSphere() | |
| return inst | |
| } | |