video / src /jiangnan /engine /textures.ts
Ethscriptions's picture
暮归江南 · 步骤2-3:渲染引擎、村落与道具
2b0432b verified
Raw History Blame Contribute Delete
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
}