Spaces:
Paused
Paused
Download src/jiangnan/engine/textures.ts from Ethscriptions/video: direct link, hf CLI and curl.
- Browser
- Download file 16.6 kB
-
https://huggingface.co/spaces/Ethscriptions/video/resolve/main/src/jiangnan/engine/textures.ts
- Command line
-
hf download hf://spaces/Ethscriptions/video/src/jiangnan/engine/textures.ts
-
curl -L -o textures.ts https://huggingface.co/spaces/Ethscriptions/video/resolve/main/src/jiangnan/engine/textures.ts
16.6 kB
| // Every texture in the film is painted procedurally at load time. | |
| import * as THREE from 'three' | |
| import { fbm2, mulberry32, valueNoise2 } from './rng' | |
| function canvas(w: number, h: number) { | |
| const c = document.createElement('canvas') | |
| c.width = w | |
| c.height = h | |
| const g = c.getContext('2d', { willReadFrequently: true })! | |
| return { c, g } | |
| } | |
| function tex(c: HTMLCanvasElement, srgb = true, repeat = true) { | |
| const t = new THREE.CanvasTexture(c) | |
| if (srgb) t.colorSpace = THREE.SRGBColorSpace | |
| if (repeat) t.wrapS = t.wrapT = THREE.RepeatWrapping | |
| t.anisotropy = 8 | |
| t.needsUpdate = true | |
| return t | |
| } | |
| /** Tileable value noise sampled on a torus so textures repeat seamlessly. */ | |
| function tnoise(x: number, y: number, period: number, seed: number) { | |
| const ax = (x / period) * Math.PI * 2, ay = (y / period) * Math.PI * 2 | |
| const R = period / (Math.PI * 2) | |
| return valueNoise2(Math.cos(ax) * R + Math.sin(ay) * R * 0.37 + 50, Math.sin(ax) * R + Math.cos(ay) * R + 91, seed) | |
| } | |
| function tfbm(x: number, y: number, period: number, seed: number, oct = 4) { | |
| let s = 0, a = 0.5, n = 0, f = 1 | |
| for (let i = 0; i < oct; i++) { | |
| s += a * tnoise(x * f, y * f, period * f, seed + i * 13) | |
| n += a | |
| a *= 0.5 | |
| f *= 2 | |
| } | |
| return s / n | |
| } | |
| function heightToNormal(hf: Float32Array, w: number, h: number, strength: number) { | |
| const { c, g } = canvas(w, h) | |
| const img = g.createImageData(w, h) | |
| for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) { | |
| const xl = hf[y * w + ((x - 1 + w) % w)], xr = hf[y * w + ((x + 1) % w)] | |
| const yu = hf[((y - 1 + h) % h) * w + x], yd = hf[((y + 1) % h) * w + x] | |
| let nx = (xl - xr) * strength, ny = (yd - yu) * strength, nz = 1 | |
| const l = Math.hypot(nx, ny, nz) | |
| nx /= l; ny /= l; nz /= l | |
| const i = (y * w + x) * 4 | |
| img.data[i] = (nx * 0.5 + 0.5) * 255 | |
| img.data[i + 1] = (ny * 0.5 + 0.5) * 255 | |
| img.data[i + 2] = (nz * 0.5 + 0.5) * 255 | |
| img.data[i + 3] = 255 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return tex(c, false) | |
| } | |
| export interface Textures { | |
| wall: THREE.Texture; wallN: THREE.Texture | |
| roof: THREE.Texture; roofN: THREE.Texture | |
| slab: THREE.Texture; slabN: THREE.Texture | |
| stone: THREE.Texture; stoneN: THREE.Texture | |
| wood: THREE.Texture | |
| cloth: THREE.Texture[] | |
| leaf: THREE.Texture; bambooLeaf: THREE.Texture | |
| puff: THREE.Texture | |
| lantern: THREE.Texture | |
| basket: THREE.Texture | |
| ground: THREE.Texture | |
| bark: THREE.Texture; barkN: THREE.Texture | |
| glow: THREE.Texture | |
| lattice: THREE.Texture | |
| } | |
| function wallTexture() { | |
| // u wraps every 6 m of wall, v spans ground (0) -> eave (1) | |
| const W = 512, H = 512 | |
| const { c, g } = canvas(W, H) | |
| const img = g.createImageData(W, H) | |
| const hf = new Float32Array(W * H) | |
| const r = mulberry32(7) | |
| const streakX: number[] = [] | |
| for (let i = 0; i < 70; i++) streakX.push(r() * W) | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const v = 1 - y / H // 1 at top | |
| const n = tfbm(x, y, W, 3, 5) | |
| const fine = tnoise(x * 4, y * 4, W * 4, 9) | |
| // rain streaks running down from under the eaves | |
| let streak = 0 | |
| for (let k = 0; k < streakX.length; k++) { | |
| const dx = Math.abs(((x - streakX[k] + W * 1.5) % W) - W / 2) | |
| const len = 0.25 + (k % 7) * 0.09 | |
| if (dx < 6 + (k % 3) * 5 && v > 1 - len) streak += (1 - dx / (6 + (k % 3) * 5)) * Math.pow((v - (1 - len)) / len, 1.5) * 0.18 | |
| } | |
| const topGrime = Math.pow(Math.max(0, v - 0.86) / 0.14, 2) * 0.25 | |
| const damp = Math.pow(Math.max(0, 0.22 - v) / 0.22, 1.6) * (0.35 + 0.4 * n) | |
| const patch = Math.max(0, n - 0.62) * 1.6 | |
| let l = 0.92 - streak - topGrime * 0.8 - patch * 0.25 + (fine - 0.5) * 0.04 | |
| l = Math.max(0.25, l) | |
| const i = (y * W + x) * 4 | |
| // warm white lime plaster; damp areas greenish grey | |
| img.data[i] = Math.min(255, (l * 236 - damp * 70)) | |
| img.data[i + 1] = Math.min(255, (l * 232 - damp * 56)) | |
| img.data[i + 2] = Math.min(255, (l * 222 - damp * 60)) | |
| img.data[i + 3] = 255 | |
| hf[y * W + x] = n * 0.6 + fine * 0.5 - patch * 0.6 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return { map: tex(c), normal: heightToNormal(hf, W, H, 1.2) } | |
| } | |
| function roofTexture() { | |
| // one texture repeat = 1.2 m across (6 tile channels) x 1.2 m down slope | |
| const W = 256, H = 256 | |
| const { c, g } = canvas(W, H) | |
| const img = g.createImageData(W, H) | |
| const hf = new Float32Array(W * H) | |
| const cols = 6, courses = 8 | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const u = (x / W) * cols | |
| const ci = Math.floor(u), fu = u - ci | |
| // alternating concave pan (阴瓦) and convex cover (阳瓦) | |
| const cover = ci % 2 === 0 | |
| const prof = Math.sin(fu * Math.PI) | |
| const vv = (y / H) * courses + (cover ? 0.5 : 0) | |
| const fv = vv - Math.floor(vv) | |
| const overlap = Math.pow(fv, 3) * 0.6 // each tile edge lips over the next | |
| const hgt = (cover ? prof * 1.0 : -prof * 0.5 + 0.2) + overlap * 0.4 | |
| const n = tfbm(x, y, W, 21, 4) | |
| const ti = Math.floor(vv) * 7 + ci * 13 | |
| const tileVar = valueNoise2(ti, ti * 0.37, 5) | |
| let l = 0.2 + tileVar * 0.07 + n * 0.08 + (cover ? prof * 0.06 : -prof * 0.03) - (1 - fv) * 0.015 | |
| // occasional moss / lichen | |
| const moss = Math.max(0, n - 0.68) * 2.5 | |
| l = Math.max(0.06, l) | |
| const i = (y * W + x) * 4 | |
| img.data[i] = (l * 0.92 + moss * 0.03) * 255 | |
| img.data[i + 1] = (l * 0.96 + moss * 0.06) * 255 | |
| img.data[i + 2] = (l * 1.05) * 255 | |
| img.data[i + 3] = 255 | |
| hf[y * W + x] = hgt + n * 0.15 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return { map: tex(c), normal: heightToNormal(hf, W, H, 3.2) } | |
| } | |
| function slabTexture() { | |
| // blue-stone street slabs, one repeat = 4 m | |
| const W = 512, H = 512 | |
| const { c, g } = canvas(W, H) | |
| const img = g.createImageData(W, H) | |
| const hf = new Float32Array(W * H) | |
| const rows = 6 | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const vv = (y / H) * rows | |
| const ri = Math.floor(vv) | |
| const lenScale = 2 + (ri % 3) | |
| const off = valueNoise2(ri, 3, 2) * 3 | |
| const uu = (x / W) * lenScale + off | |
| const ci = Math.floor(uu) | |
| const fu = uu - ci, fv = vv - ri | |
| const edge = Math.min(fu, 1 - fu, fv * 0.7, (1 - fv) * 0.7) | |
| const gap = edge < 0.02 ? 1 : 0 | |
| const id = ri * 17 + ((ci % lenScale) + lenScale) % lenScale * 5 | |
| const sv = valueNoise2(id, id * 0.3, 11) | |
| const n = tfbm(x, y, W, 33, 5) | |
| const worn = Math.pow(Math.min(1, edge / 0.08), 0.5) | |
| let l = 0.34 + sv * 0.12 + (n - 0.5) * 0.12 | |
| if (gap) l *= 0.45 | |
| const i = (y * W + x) * 4 | |
| img.data[i] = l * 0.93 * 255 | |
| img.data[i + 1] = l * 0.98 * 255 | |
| img.data[i + 2] = l * 1.04 * 255 | |
| img.data[i + 3] = 255 | |
| hf[y * W + x] = (gap ? -0.6 : 0) + worn * 0.4 + n * 0.25 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return { map: tex(c), normal: heightToNormal(hf, W, H, 2.4) } | |
| } | |
| function stoneTexture() { | |
| // dressed granite blocks (bridge, embankment), repeat = 3 m | |
| const W = 512, H = 512 | |
| const { c, g } = canvas(W, H) | |
| const img = g.createImageData(W, H) | |
| const hf = new Float32Array(W * H) | |
| const rows = 8 | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const vv = (y / H) * rows | |
| const ri = Math.floor(vv) | |
| const uu = (x / W) * 4 + (ri % 2) * 0.5 + valueNoise2(ri, 1, 4) * 0.3 | |
| const ci = Math.floor(uu) | |
| const fu = uu - ci, fv = vv - ri | |
| const edge = Math.min(fu * 2, (1 - fu) * 2, fv, 1 - fv) | |
| const id = ri * 31 + (((ci % 4) + 4) % 4) * 7 | |
| const sv = valueNoise2(id, id * 0.71, 8) | |
| const n = tfbm(x, y, W, 44, 5) | |
| const speck = tnoise(x * 8, y * 8, W * 8, 2) | |
| const moss = Math.max(0, tfbm(x, y, W, 71, 3) - 0.58) * 2 * (1 - y / H * 0.3) | |
| let l = 0.42 + sv * 0.1 + (n - 0.5) * 0.14 + (speck - 0.5) * 0.06 | |
| if (edge < 0.04) l *= 0.5 | |
| const i = (y * W + x) * 4 | |
| img.data[i] = (l * 0.96 - moss * 0.12) * 255 | |
| img.data[i + 1] = (l * 0.95 - moss * 0.02) * 255 | |
| img.data[i + 2] = (l * 0.9 - moss * 0.1) * 255 | |
| img.data[i + 3] = 255 | |
| hf[y * W + x] = (edge < 0.04 ? -0.5 : Math.min(1, edge * 6) * 0.3) + n * 0.3 + speck * 0.05 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return { map: tex(c), normal: heightToNormal(hf, W, H, 2.0) } | |
| } | |
| function woodTexture() { | |
| const W = 256, H = 256 | |
| const { c, g } = canvas(W, H) | |
| const img = g.createImageData(W, H) | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const n = tfbm(x * 0.25, y * 3, W, 5, 4) | |
| const grain = Math.sin((x / W) * 60 + n * 14) * 0.5 + 0.5 | |
| const l = 0.2 + grain * 0.06 + n * 0.08 | |
| const i = (y * W + x) * 4 | |
| img.data[i] = l * 1.25 * 255 | |
| img.data[i + 1] = l * 0.86 * 255 | |
| img.data[i + 2] = l * 0.6 * 255 | |
| img.data[i + 3] = 255 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return tex(c) | |
| } | |
| function barkTexture() { | |
| const W = 256, H = 512 | |
| const { c, g } = canvas(W, H) | |
| const img = g.createImageData(W, H) | |
| const hf = new Float32Array(W * H) | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const n = tfbm(x * 2, y * 0.35, W * 2, 15, 5) | |
| const ridge = Math.abs(Math.sin((x / W) * Math.PI * 14 + n * 9)) | |
| const l = 0.13 + ridge * 0.1 + n * 0.08 | |
| const moss = Math.max(0, tfbm(x, y, W, 88, 3) - 0.55) * 1.5 | |
| const i = (y * W + x) * 4 | |
| img.data[i] = (l * 1.1 - moss * 0.05) * 255 | |
| img.data[i + 1] = (l * 0.95 + moss * 0.08) * 255 | |
| img.data[i + 2] = (l * 0.8) * 255 | |
| img.data[i + 3] = 255 | |
| hf[y * W + x] = ridge * 0.8 + n * 0.4 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return { map: tex(c), normal: heightToNormal(hf, W, H, 3) } | |
| } | |
| function clothTexture(variant: number) { | |
| // 蓝印花布: indigo cotton with resist-printed white motifs | |
| const W = 256, H = 512 | |
| const { c, g } = canvas(W, H) | |
| const r = mulberry32(100 + variant) | |
| g.fillStyle = variant % 2 ? '#1c2f63' : '#213a72' | |
| g.fillRect(0, 0, W, H) | |
| // dyed fabric unevenness | |
| const img = g.getImageData(0, 0, W, H) | |
| for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) { | |
| const n = tfbm(x, y, W, 60 + variant, 3) | |
| const i = (y * W + x) * 4 | |
| const k = 0.85 + n * 0.3 | |
| img.data[i] *= k; img.data[i + 1] *= k; img.data[i + 2] *= k | |
| } | |
| g.putImageData(img, 0, 0) | |
| g.fillStyle = '#e8ecf2' | |
| g.strokeStyle = '#e8ecf2' | |
| // border bands of dots | |
| for (let y = 10; y < H; y += 12) { | |
| for (const x of [10, W - 10]) { g.beginPath(); g.arc(x, y, 2.6, 0, Math.PI * 2); g.fill() } | |
| } | |
| g.lineWidth = 2 | |
| g.strokeRect(20, 6, W - 40, H - 12) | |
| // floral medallions | |
| const flower = (cx: number, cy: number, s: number, petals: number) => { | |
| for (let p = 0; p < petals; p++) { | |
| const a = (p / petals) * Math.PI * 2 | |
| g.beginPath() | |
| g.ellipse(cx + Math.cos(a) * s * 0.55, cy + Math.sin(a) * s * 0.55, s * 0.42, s * 0.2, a, 0, Math.PI * 2) | |
| g.fill() | |
| } | |
| g.fillStyle = variant % 2 ? '#1c2f63' : '#213a72' | |
| g.beginPath(); g.arc(cx, cy, s * 0.2, 0, Math.PI * 2); g.fill() | |
| g.fillStyle = '#e8ecf2' | |
| g.beginPath(); g.arc(cx, cy, s * 0.09, 0, Math.PI * 2); g.fill() | |
| } | |
| const step = variant % 2 ? 64 : 80 | |
| for (let y = 40; y < H - 20; y += step) for (let x = 56; x < W - 30; x += step * 0.9) { | |
| const off = (Math.floor(y / step) % 2) * step * 0.45 | |
| flower(x + off * (x + off < W - 40 ? 1 : 0), y, 20 + r() * 6, variant % 2 ? 6 : 8) | |
| // small dots around | |
| for (let k = 0; k < 6; k++) { | |
| const a = r() * Math.PI * 2 | |
| g.beginPath(); g.arc(x + Math.cos(a) * 34, y + Math.sin(a) * 34, 2, 0, Math.PI * 2); g.fill() | |
| } | |
| } | |
| return tex(c, true, false) | |
| } | |
| function leafTexture(bamboo: boolean) { | |
| // alpha-tested cluster of leaves, white-ish albedo modulated by instance colour | |
| const W = 512, H = 512 | |
| const { c, g } = canvas(W, H) | |
| g.clearRect(0, 0, W, H) | |
| const r = mulberry32(bamboo ? 5 : 3) | |
| const N = bamboo ? 140 : 420 | |
| for (let i = 0; i < N; i++) { | |
| // denser toward the centre, rounded cluster silhouette | |
| const a = r() * Math.PI * 2 | |
| const rad = Math.pow(r(), 0.6) * (W * 0.46) | |
| const x = W / 2 + Math.cos(a) * rad, y = H / 2 + Math.sin(a) * rad * (bamboo ? 0.8 : 0.9) | |
| const len = bamboo ? 34 + r() * 26 : 11 + r() * 8 | |
| const wid = bamboo ? 5 + r() * 2 : 6 + r() * 3 | |
| const ang = bamboo ? a + (r() - 0.5) * 0.9 + Math.PI * 0.5 * (r() < 0.5 ? 1 : 0) : r() * Math.PI * 2 | |
| const shade = 0.55 + r() * 0.45 | |
| const hue = r() | |
| g.save() | |
| g.translate(x, y) | |
| g.rotate(ang) | |
| g.fillStyle = `rgb(${Math.round((150 + hue * 40) * shade)},${Math.round((200 + hue * 30) * shade)},${Math.round((110 + hue * 20) * shade)})` | |
| g.beginPath() | |
| g.ellipse(0, 0, len, wid, 0, 0, Math.PI * 2) | |
| g.fill() | |
| g.strokeStyle = `rgba(40,60,20,0.35)` | |
| g.lineWidth = 1 | |
| g.beginPath(); g.moveTo(-len, 0); g.lineTo(len, 0); g.stroke() | |
| g.restore() | |
| } | |
| const t = tex(c, true, false) | |
| t.generateMipmaps = true | |
| return t | |
| } | |
| function puffTexture() { | |
| const W = 128 | |
| const { c, g } = canvas(W, W) | |
| const img = g.createImageData(W, W) | |
| for (let y = 0; y < W; y++) for (let x = 0; x < W; x++) { | |
| const dx = (x - W / 2) / (W / 2), dy = (y - W / 2) / (W / 2) | |
| const d = Math.hypot(dx, dy) | |
| const n = fbm2(x * 0.06, y * 0.06, 4, 12) | |
| const a = Math.max(0, 1 - d * (1.1 - n * 0.5)) ** 1.6 | |
| const i = (y * W + x) * 4 | |
| img.data[i] = img.data[i + 1] = img.data[i + 2] = 255 | |
| img.data[i + 3] = a * 255 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return tex(c, false, false) | |
| } | |
| function glowTexture() { | |
| const W = 128 | |
| const { c, g } = canvas(W, W) | |
| const grd = g.createRadialGradient(W / 2, W / 2, 0, W / 2, W / 2, W / 2) | |
| grd.addColorStop(0, 'rgba(255,255,255,1)') | |
| grd.addColorStop(0.15, 'rgba(255,255,255,0.55)') | |
| grd.addColorStop(0.45, 'rgba(255,255,255,0.12)') | |
| grd.addColorStop(1, 'rgba(255,255,255,0)') | |
| g.fillStyle = grd | |
| g.fillRect(0, 0, W, W) | |
| return tex(c, false, false) | |
| } | |
| function lanternTexture() { | |
| const W = 256, H = 256 | |
| const { c, g } = canvas(W, H) | |
| const grd = g.createLinearGradient(0, 0, 0, H) | |
| grd.addColorStop(0, '#5a0d08') | |
| grd.addColorStop(0.12, '#c4231a') | |
| grd.addColorStop(0.5, '#e8382a') | |
| grd.addColorStop(0.88, '#c4231a') | |
| grd.addColorStop(1, '#5a0d08') | |
| g.fillStyle = grd | |
| g.fillRect(0, 0, W, H) | |
| g.strokeStyle = 'rgba(70,10,5,0.55)' | |
| g.lineWidth = 2 | |
| for (let x = 0; x < W; x += 16) { g.beginPath(); g.moveTo(x, 0); g.lineTo(x, H); g.stroke() } | |
| g.fillStyle = '#d9a63a' | |
| g.fillRect(0, 0, W, 10) | |
| g.fillRect(0, H - 10, W, 10) | |
| // 福 character (painted, gold-ish black) | |
| g.fillStyle = 'rgba(30,8,4,0.85)' | |
| g.font = 'bold 92px serif' | |
| g.textAlign = 'center' | |
| g.textBaseline = 'middle' | |
| g.fillText('福', W * 0.25, H / 2) | |
| g.fillText('福', W * 0.75, H / 2) | |
| return tex(c, true, true) | |
| } | |
| function basketTexture() { | |
| const W = 128, H = 128 | |
| const { c, g } = canvas(W, H) | |
| g.fillStyle = '#8a6a3a' | |
| g.fillRect(0, 0, W, H) | |
| for (let y = 0; y < H; y += 8) for (let x = 0; x < W; x += 8) { | |
| const odd = ((x + y) / 8) % 2 | |
| g.fillStyle = odd ? '#b08a4e' : '#7a5a2e' | |
| g.fillRect(x + 1, y + 1, 6, 6) | |
| } | |
| return tex(c) | |
| } | |
| function groundTexture() { | |
| const W = 256 | |
| const { c, g } = canvas(W, W) | |
| const img = g.createImageData(W, W) | |
| for (let y = 0; y < W; y++) for (let x = 0; x < W; x++) { | |
| const n = tfbm(x, y, W, 90, 5) | |
| const f = tnoise(x * 6, y * 6, W * 6, 3) | |
| const l = 0.75 + (n - 0.5) * 0.5 + (f - 0.5) * 0.25 | |
| const i = (y * W + x) * 4 | |
| img.data[i] = img.data[i + 1] = img.data[i + 2] = Math.max(0, Math.min(255, l * 255)) | |
| img.data[i + 3] = 255 | |
| } | |
| g.putImageData(img, 0, 0) | |
| return tex(c, false) | |
| } | |
| function latticeTexture() { | |
| // wooden window lattice (冰裂 / 方格) for the window panes; alpha = paper | |
| const W = 128, H = 128 | |
| const { c, g } = canvas(W, H) | |
| g.fillStyle = '#ffffff' | |
| g.fillRect(0, 0, W, H) | |
| g.strokeStyle = '#000000' | |
| g.lineWidth = 7 | |
| g.strokeRect(0, 0, W, H) | |
| g.lineWidth = 4 | |
| for (let i = 1; i < 4; i++) { | |
| g.beginPath(); g.moveTo((i * W) / 4, 0); g.lineTo((i * W) / 4, H); g.stroke() | |
| g.beginPath(); g.moveTo(0, (i * H) / 4); g.lineTo(W, (i * H) / 4); g.stroke() | |
| } | |
| return tex(c, false, true) | |
| } | |
| let cache: Textures | null = null | |
| export function getTextures(): Textures { | |
| if (cache) return cache | |
| const wall = wallTexture(), roof = roofTexture(), slab = slabTexture(), stone = stoneTexture(), bark = barkTexture() | |
| cache = { | |
| wall: wall.map, wallN: wall.normal, | |
| roof: roof.map, roofN: roof.normal, | |
| slab: slab.map, slabN: slab.normal, | |
| stone: stone.map, stoneN: stone.normal, | |
| wood: woodTexture(), | |
| cloth: [0, 1, 2].map(clothTexture), | |
| leaf: leafTexture(false), bambooLeaf: leafTexture(true), | |
| puff: puffTexture(), glow: glowTexture(), | |
| lantern: lanternTexture(), basket: basketTexture(), ground: groundTexture(), | |
| bark: bark.map, barkN: bark.normal, | |
| lattice: latticeTexture(), | |
| } | |
| return cache | |
| } | |