Shade with vertex normals in the renderer, and add crease-angle normal smoothing so turned objects stop banding.
This commit is contained in:
parent
02c0711442
commit
91847838ed
4 changed files with 130 additions and 7 deletions
|
|
@ -36,6 +36,7 @@ import {
|
||||||
jitter,
|
jitter,
|
||||||
latheGeometry,
|
latheGeometry,
|
||||||
mergeColoured,
|
mergeColoured,
|
||||||
|
smoothNormals,
|
||||||
type Level,
|
type Level,
|
||||||
} from '../core/index.ts'
|
} from '../core/index.ts'
|
||||||
|
|
||||||
|
|
@ -115,8 +116,12 @@ export function createModel(overrides: Partial<CeramicVaseConfig> = {}) {
|
||||||
),
|
),
|
||||||
]
|
]
|
||||||
|
|
||||||
|
// Smoothed at 40 degrees. The wall is a curve and reads as one; the
|
||||||
|
// lip, the foot and the base cap all turn through more than that and
|
||||||
|
// stay as edges. Flat shading put a visible band at every level of the
|
||||||
|
// profile, which on a glazed white surface is the first thing you see.
|
||||||
return {
|
return {
|
||||||
body: { slot: 'ceramic' as const, geometry: mergeColoured(pieces) },
|
body: { slot: 'ceramic' as const, geometry: smoothNormals(mergeColoured(pieces), 40) },
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
}, overrides)
|
}, overrides)
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,4 @@
|
||||||
import { BufferAttribute, BufferGeometry, Color } from 'three'
|
import { BufferAttribute, BufferGeometry, Color, Vector3 } from 'three'
|
||||||
import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js'
|
import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js'
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
@ -6,8 +6,14 @@ import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js'
|
||||||
*
|
*
|
||||||
* Everything is generated NON-INDEXED. The reason: on non-indexed geometry
|
* Everything is generated NON-INDEXED. The reason: on non-indexed geometry
|
||||||
* computeVertexNormals() gives every triangle its own normal, so flat shading
|
* computeVertexNormals() gives every triangle its own normal, so flat shading
|
||||||
* becomes a natural consequence of the geometry — no material flag is needed.
|
* becomes a natural consequence of the geometry and no material flag is needed.
|
||||||
* In lowpoly that is exactly what we want.
|
*
|
||||||
|
* That was the whole answer in a kit with a lowpoly budget, where a barrel is
|
||||||
|
* meant to read as staves. This kit has no such budget and is full of turned
|
||||||
|
* and pressed objects that are genuinely smooth: a kettle, a basin, a mug, a
|
||||||
|
* bollard, a traffic cone. Flat shading those puts visible bands across every
|
||||||
|
* curve, so `smoothNormals` below is the way out, applied per object rather
|
||||||
|
* than globally, because the choice belongs to the object.
|
||||||
*
|
*
|
||||||
* Position frame: point(a, r, y) = (sin a · r, y, cos a · r)
|
* Position frame: point(a, r, y) = (sin a · r, y, cos a · r)
|
||||||
* So a = 0 → the +Z direction; as a grows it turns toward +X.
|
* So a = 0 → the +Z direction; as a grows it turns toward +X.
|
||||||
|
|
@ -868,3 +874,75 @@ export function mottleGeometry(
|
||||||
colour.needsUpdate = true
|
colour.needsUpdate = true
|
||||||
return geometry
|
return geometry
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Averages normals across edges that are not creases, in place.
|
||||||
|
*
|
||||||
|
* Non-indexed geometry has no idea which triangles are neighbours, so this
|
||||||
|
* finds out the only way available: vertices at the same POSITION belong
|
||||||
|
* together. Positions are quantised before comparison because two triangles
|
||||||
|
* that share an edge were generated from the same numbers and land on the same
|
||||||
|
* point to the last bit, while anything merely close is a different corner.
|
||||||
|
*
|
||||||
|
* The crease angle is what makes it usable. Averaging every shared vertex
|
||||||
|
* would round the rim of the vase into the wall and the foot into the table,
|
||||||
|
* which is how a smoothed lowpoly object turns to soap. Only faces that agree
|
||||||
|
* to within the crease angle are averaged with each other, so a curve comes
|
||||||
|
* out smooth and an edge stays an edge, with no hand-marked smoothing groups.
|
||||||
|
*
|
||||||
|
* @param crease Degrees. 30 keeps chamfers crisp; 60 smooths all but hard
|
||||||
|
* corners; above about 80 everything melts together.
|
||||||
|
*/
|
||||||
|
export function smoothNormals(geometry: BufferGeometry, crease = 40): BufferGeometry {
|
||||||
|
const position = geometry.getAttribute('position')
|
||||||
|
if (!position || geometry.getIndex()) return geometry
|
||||||
|
const count = position.count
|
||||||
|
const limit = Math.cos((crease * Math.PI) / 180)
|
||||||
|
|
||||||
|
// Face normal per triangle, computed once.
|
||||||
|
const faceNormal = new Float32Array((count / 3) * 3)
|
||||||
|
const ax = new Vector3(), bx = new Vector3(), cx = new Vector3()
|
||||||
|
const e1 = new Vector3(), e2 = new Vector3(), n = new Vector3()
|
||||||
|
for (let f = 0; f < count / 3; f += 1) {
|
||||||
|
ax.fromBufferAttribute(position, f * 3)
|
||||||
|
bx.fromBufferAttribute(position, f * 3 + 1)
|
||||||
|
cx.fromBufferAttribute(position, f * 3 + 2)
|
||||||
|
n.copy(e1.subVectors(bx, ax)).cross(e2.subVectors(cx, ax))
|
||||||
|
if (n.lengthSq() > 0) n.normalize()
|
||||||
|
faceNormal[f * 3] = n.x; faceNormal[f * 3 + 1] = n.y; faceNormal[f * 3 + 2] = n.z
|
||||||
|
}
|
||||||
|
|
||||||
|
// Which faces meet at each position.
|
||||||
|
const at = new Map<string, number[]>()
|
||||||
|
const key = (i: number): string => {
|
||||||
|
const x = Math.round(position.getX(i) * 1e5)
|
||||||
|
const y = Math.round(position.getY(i) * 1e5)
|
||||||
|
const z = Math.round(position.getZ(i) * 1e5)
|
||||||
|
return `${x},${y},${z}`
|
||||||
|
}
|
||||||
|
for (let i = 0; i < count; i += 1) {
|
||||||
|
const k = key(i)
|
||||||
|
const list = at.get(k)
|
||||||
|
if (list) list.push(Math.floor(i / 3))
|
||||||
|
else at.set(k, [Math.floor(i / 3)])
|
||||||
|
}
|
||||||
|
|
||||||
|
const out = new Float32Array(count * 3)
|
||||||
|
const sum = new Vector3()
|
||||||
|
for (let i = 0; i < count; i += 1) {
|
||||||
|
const face = Math.floor(i / 3)
|
||||||
|
n.set(faceNormal[face * 3]!, faceNormal[face * 3 + 1]!, faceNormal[face * 3 + 2]!)
|
||||||
|
sum.set(0, 0, 0)
|
||||||
|
for (const other of at.get(key(i)) ?? [face]) {
|
||||||
|
const m = new Vector3(faceNormal[other * 3]!, faceNormal[other * 3 + 1]!, faceNormal[other * 3 + 2]!)
|
||||||
|
// Only neighbours on the same side of the crease contribute. A face
|
||||||
|
// beyond it keeps its own normal and the edge survives.
|
||||||
|
if (m.dot(n) >= limit) sum.add(m)
|
||||||
|
}
|
||||||
|
if (sum.lengthSq() === 0) sum.copy(n)
|
||||||
|
sum.normalize()
|
||||||
|
out[i * 3] = sum.x; out[i * 3 + 1] = sum.y; out[i * 3 + 2] = sum.z
|
||||||
|
}
|
||||||
|
geometry.setAttribute('normal', new BufferAttribute(out, 3))
|
||||||
|
return geometry
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -14,6 +14,7 @@ export {
|
||||||
prismGeometry,
|
prismGeometry,
|
||||||
roughenGeometry,
|
roughenGeometry,
|
||||||
staveGeometry,
|
staveGeometry,
|
||||||
|
smoothNormals,
|
||||||
taperedBoxGeometry,
|
taperedBoxGeometry,
|
||||||
} from './geometry.ts'
|
} from './geometry.ts'
|
||||||
export type { Level, MottleOptions, RoughenOptions, SheetLevel, Vec3 } from './geometry.ts'
|
export type { Level, MottleOptions, RoughenOptions, SheetLevel, Vec3 } from './geometry.ts'
|
||||||
|
|
|
||||||
|
|
@ -20,6 +20,7 @@ import { deflateSync } from 'node:zlib'
|
||||||
|
|
||||||
import {
|
import {
|
||||||
Box3,
|
Box3,
|
||||||
|
Matrix3,
|
||||||
Mesh,
|
Mesh,
|
||||||
PerspectiveCamera,
|
PerspectiveCamera,
|
||||||
Sphere,
|
Sphere,
|
||||||
|
|
@ -44,6 +45,17 @@ interface Triangle {
|
||||||
/** Unlit surface (flame). The vertex colour is the result directly. */
|
/** Unlit surface (flame). The vertex colour is the result directly. */
|
||||||
readonly unlit: boolean
|
readonly unlit: boolean
|
||||||
readonly opacity: number
|
readonly opacity: number
|
||||||
|
/**
|
||||||
|
* Vertex normals, when the geometry carries ones that differ from the face.
|
||||||
|
*
|
||||||
|
* Null on flat-shaded geometry, which is most of it: these models are
|
||||||
|
* non-indexed and `computeVertexNormals` then hands every triangle its own
|
||||||
|
* normal, so interpolating three copies of the same vector would be work
|
||||||
|
* for nothing.
|
||||||
|
*/
|
||||||
|
readonly na: Vector3 | null
|
||||||
|
readonly nb: Vector3 | null
|
||||||
|
readonly nc: Vector3 | null
|
||||||
}
|
}
|
||||||
|
|
||||||
function collect(root: Object3D): Triangle[] {
|
function collect(root: Object3D): Triangle[] {
|
||||||
|
|
@ -68,20 +80,34 @@ function collect(root: Object3D): Triangle[] {
|
||||||
const unlit = material.isMeshBasicMaterial === true
|
const unlit = material.isMeshBasicMaterial === true
|
||||||
const opacity = material.transparent ? (material.opacity ?? 1) : 1
|
const opacity = material.transparent ? (material.opacity ?? 1) : 1
|
||||||
|
|
||||||
const vertex = (i: number): { p: Vector3; c: [number, number, number] } => {
|
const normals = geometry.getAttribute('normal')
|
||||||
|
// Rotation only: a normal is a direction, so the translation in the world
|
||||||
|
// matrix must not move it.
|
||||||
|
const rotation = new Matrix3().getNormalMatrix(object.matrixWorld)
|
||||||
|
|
||||||
|
const vertex = (i: number): { p: Vector3; c: [number, number, number]; n: Vector3 | null } => {
|
||||||
const v = index ? index.getX(i) : i
|
const v = index ? index.getX(i) : i
|
||||||
const p = new Vector3().fromBufferAttribute(position, v).applyMatrix4(object.matrixWorld)
|
const p = new Vector3().fromBufferAttribute(position, v).applyMatrix4(object.matrixWorld)
|
||||||
const c: [number, number, number] = colour
|
const c: [number, number, number] = colour
|
||||||
? [colour.getX(v), colour.getY(v), colour.getZ(v)]
|
? [colour.getX(v), colour.getY(v), colour.getZ(v)]
|
||||||
: [0.8, 0.8, 0.8]
|
: [0.8, 0.8, 0.8]
|
||||||
return { p, c }
|
const n = normals
|
||||||
|
? new Vector3().fromBufferAttribute(normals, v).applyMatrix3(rotation).normalize()
|
||||||
|
: null
|
||||||
|
return { p, c, n }
|
||||||
}
|
}
|
||||||
|
|
||||||
for (let i = 0; i < count; i += 3) {
|
for (let i = 0; i < count; i += 3) {
|
||||||
const a = vertex(i), b = vertex(i + 1), c = vertex(i + 2)
|
const a = vertex(i), b = vertex(i + 1), c = vertex(i + 2)
|
||||||
|
// Only worth interpolating when the three actually disagree. On flat
|
||||||
|
// geometry they are identical and the face normal is both cheaper and
|
||||||
|
// exactly as correct.
|
||||||
|
const smooth = a.n !== null && b.n !== null && c.n !== null
|
||||||
|
&& (a.n.dot(b.n) < 0.9995 || a.n.dot(c.n) < 0.9995)
|
||||||
out.push({
|
out.push({
|
||||||
a: a.p, b: b.p, c: c.p,
|
a: a.p, b: b.p, c: c.p,
|
||||||
ca: a.c, cb: b.c, cc: c.c,
|
ca: a.c, cb: b.c, cc: c.c,
|
||||||
|
na: smooth ? a.n : null, nb: smooth ? b.n : null, nc: smooth ? c.n : null,
|
||||||
metalness: material.metalness ?? 0,
|
metalness: material.metalness ?? 0,
|
||||||
roughness: material.roughness ?? 0.8,
|
roughness: material.roughness ?? 0.8,
|
||||||
unlit,
|
unlit,
|
||||||
|
|
@ -256,7 +282,20 @@ function raster(frame: Frame, camera: PerspectiveCamera, triangles: readonly Tri
|
||||||
tri.ca[1] * w1 + tri.cb[1] * w2 + tri.cc[1] * w0,
|
tri.ca[1] * w1 + tri.cb[1] * w2 + tri.cc[1] * w0,
|
||||||
tri.ca[2] * w1 + tri.cb[2] * w2 + tri.cc[2] * w0,
|
tri.ca[2] * w1 + tri.cb[2] * w2 + tri.cc[2] * w0,
|
||||||
]
|
]
|
||||||
const rgb = shade(tri, normal, albedo)
|
// Interpolate the normal across the face when the geometry asked for
|
||||||
|
// smooth shading. Without this the renderer is flat by construction
|
||||||
|
// and cannot show the difference between a faceted vase and a turned
|
||||||
|
// one, which makes it useless for judging exactly the objects this
|
||||||
|
// kit is full of.
|
||||||
|
let shadingNormal = normal
|
||||||
|
if (tri.na && tri.nb && tri.nc) {
|
||||||
|
shadingNormal = new Vector3(
|
||||||
|
tri.na.x * w1 + tri.nb.x * w2 + tri.nc.x * w0,
|
||||||
|
tri.na.y * w1 + tri.nb.y * w2 + tri.nc.y * w0,
|
||||||
|
tri.na.z * w1 + tri.nb.z * w2 + tri.nc.z * w0,
|
||||||
|
).normalize()
|
||||||
|
}
|
||||||
|
const rgb = shade(tri, shadingNormal, albedo)
|
||||||
const i = at * 3
|
const i = at * 3
|
||||||
const alpha = tri.opacity
|
const alpha = tri.opacity
|
||||||
frame.colour[i] = frame.colour[i]! * (1 - alpha) + rgb[0] * alpha
|
frame.colour[i] = frame.colour[i]! * (1 - alpha) + rgb[0] * alpha
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue