Line data Source code
1 : import * as THREE from 'three'
2 :
3 : export interface ModelStats {
4 : vertices: number
5 : edges: number
6 : triangles: number
7 : }
8 :
9 24 : const EMPTY_STATS: ModelStats = {
10 : vertices: 0,
11 : edges: 0,
12 : triangles: 0
13 : }
14 :
15 24 : const CHUNK_SIZE = 50_000
16 :
17 0 : async function yieldToEventLoop(signal?: AbortSignal): Promise<void> {
18 0 : await new Promise<void>((resolve) => setTimeout(resolve, 0))
19 0 : signal?.throwIfAborted()
20 : }
21 :
22 17 : async function weldByPosition(
23 : position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute,
24 : signal?: AbortSignal
25 : ): Promise<{ remap: Uint32Array; uniqueCount: number }> {
26 17 : const ids = new Map<string, number>()
27 17 : const remap = new Uint32Array(position.count)
28 17 : for (let i = 0; i < position.count; i++) {
29 546 : if (i > 0 && i % CHUNK_SIZE === 0) await yieldToEventLoop(signal)
30 546 : const key = `${position.getX(i)},${position.getY(i)},${position.getZ(i)}`
31 546 : const existing = ids.get(key)
32 546 : if (existing === undefined) {
33 126 : remap[i] = ids.size
34 126 : ids.set(key, ids.size)
35 : } else {
36 420 : remap[i] = existing
37 : }
38 : }
39 17 : return { remap, uniqueCount: ids.size }
40 : }
41 :
42 17 : async function countTopology(
43 : cornerIndices: ArrayLike<number>,
44 : remap: Uint32Array,
45 : vertexCount: number,
46 : signal?: AbortSignal
47 : ): Promise<{ edges: number; triangles: number }> {
48 17 : const edges = new Set<number>()
49 17 : const triangles = new Set<string>()
50 17 : const cornerTriangles = Math.floor(cornerIndices.length / 3)
51 17 : for (let t = 0; t < cornerTriangles; t++) {
52 182 : if (t > 0 && t % CHUNK_SIZE === 0) await yieldToEventLoop(signal)
53 182 : const corners = [
54 : remap[cornerIndices[t * 3]],
55 : remap[cornerIndices[t * 3 + 1]],
56 : remap[cornerIndices[t * 3 + 2]]
57 : ].sort((a, b) => a - b)
58 182 : const [a, b, c] = corners
59 : const isDegenerate = a === b || b === c
60 182 : if (isDegenerate) continue
61 182 : const triangleKey = corners.join(',')
62 182 : if (triangles.has(triangleKey)) continue
63 182 : triangles.add(triangleKey)
64 182 : edges.add(a * vertexCount + b)
65 182 : edges.add(b * vertexCount + c)
66 182 : edges.add(a * vertexCount + c)
67 : }
68 182 : return { edges: edges.size, triangles: triangles.size }
69 : }
70 :
71 17 : function sequentialCorners(count: number): Uint32Array {
72 17 : return Uint32Array.from({ length: count }, (_, i) => i)
73 : }
74 :
75 17 : async function meshStats(
76 : mesh: THREE.Mesh,
77 : signal?: AbortSignal
78 : ): Promise<ModelStats> {
79 17 : if (!mesh.geometry.hasAttribute('position')) return EMPTY_STATS
80 : const position = mesh.geometry.getAttribute('position')
81 :
82 17 : const { remap, uniqueCount } = await weldByPosition(position, signal)
83 : const corners = mesh.geometry.index?.array ?? sequentialCorners(remap.length)
84 17 : const { edges, triangles } = await countTopology(
85 : corners,
86 : remap,
87 : uniqueCount,
88 : signal
89 : )
90 17 : const instances = mesh instanceof THREE.InstancedMesh ? mesh.count : 1
91 :
92 17 : return {
93 : vertices: uniqueCount * instances,
94 : edges: edges * instances,
95 : triangles: triangles * instances
96 : }
97 : }
98 :
99 0 : function pointsStats(points: THREE.Points): ModelStats {
100 0 : const { geometry } = points
101 0 : const vertices = geometry.hasAttribute('position')
102 : ? geometry.getAttribute('position').count
103 : : 0
104 0 : return { ...EMPTY_STATS, vertices }
105 : }
106 :
107 17 : function addStats(a: ModelStats, b: ModelStats): ModelStats {
108 17 : return {
109 : vertices: a.vertices + b.vertices,
110 : edges: a.edges + b.edges,
111 : triangles: a.triangles + b.triangles
112 : }
113 : }
114 :
115 17 : export async function computeModelStats(
116 : root: THREE.Object3D,
117 : signal?: AbortSignal
118 : ): Promise<ModelStats> {
119 17 : signal?.throwIfAborted()
120 17 : const meshes: THREE.Mesh[] = []
121 17 : let total = EMPTY_STATS
122 17 : root.traverse((child) => {
123 34 : if (child instanceof THREE.Mesh) {
124 17 : meshes.push(child)
125 17 : } else if (child instanceof THREE.Points) {
126 0 : total = addStats(total, pointsStats(child))
127 : }
128 : })
129 17 : for (const mesh of meshes) {
130 17 : const stats = await meshStats(mesh, signal)
131 17 : signal?.throwIfAborted()
132 17 : total = addStats(total, stats)
133 : }
134 17 : return total
135 : }
136 :
137 18 : export function hasGeometry(stats: ModelStats): boolean {
138 18 : return stats.vertices > 0
139 : }
|