---

name: fastedgesgeometry-architecture description: Architecture and implementation details of FastEdgesGeometry. Use when modifying FastEdgesGeometry, understanding its optimization techniques, or debugging edge generation issues.

FastEdgesGeometry Architecture

Background

FastEdgesGeometry is a performance-optimized fork of Three.js EdgesGeometry. The original EdgesGeometry had performance issues with complex geometries, leading to the creation of this optimized version.

File: src/FastEdgesGeometry.ts

Evolution History

Stage 1: Three.js EdgesGeometry (Original)

Standard Three.js EdgesGeometry implementation:

Problem: String hash generation and object key lookup are slow

Stage 2: FastEdgesGeometry (v0.7.3, 2024-11)

Replaced string hash with numeric hash:

Improvement: Numeric hash speeds up edge lookup (~3-4x faster) Remaining issues: Function call overhead, object allocation, dynamic arrays

Stage 3: FastEdgesGeometry (v0.7.4+, 2026-01)

Applied further optimizations:

Improvement: Function inlining, Typed Arrays, object allocation avoidance (~30% faster)

Optimization Mapping

Stage 2 → Stage 3 Optimization Details

Code Structure Mapping

Inline Hash Function

The computeHash() function (lines 94-100) is an inline expansion of hybridtaus():

Copy// hybridtaus() static method (preserved for public API):
static hybridtaus(x, y, z, seed = 255) {
  x = FastEdgesGeometry.taus(x, 13, 19, 12, 0xfffffffe);
  y = FastEdgesGeometry.taus(y, 2, 25, 4, 0xfffffff8);
  z = FastEdgesGeometry.taus(z, 3, 11, 17, 0xfffffff0);
  seed = u32(seed * 1664525 + 1013904223);
  return u32(x ^ y ^ z ^ seed);
}

// Inlined as computeHash() with pre-transformed seed:
const transformedSeed = (seed * 1664525 + 1013904223) >>> 0;
const computeHash = (x, y, z) => {
  x = (((x & 0xfffffffe) << 13) ^ (((x << 19) ^ x) >>> 12)) >>> 0;
  y = (((y & 0xfffffff8) << 2) ^ (((y << 25) ^ y) >>> 4)) >>> 0;
  z = (((z & 0xfffffff0) << 3) ^ (((z << 11) ^ z) >>> 17)) >>> 0;
  return (x ^ y ^ z ^ transformedSeed) >>> 0;
};

The magic numbers (0xfffffffe, 0xfffffff8, 0xfffffff0) and bit shifts come from the Tausworthe random number generator algorithm (GPU Gems 3, Chapter 37).

Performance Results

Benchmark comparison (Chrome, macOS):

Optimization Principles Applied

1. Inline function calls - Eliminate call stack overhead in hot loops
2. Pre-allocate fixed arrays - Replace dynamic push() with typed array indexing
3. Avoid high-level abstractions - Use primitives instead of objects/classes
4. Pre-compute constants - Move invariant calculations outside loops

Trade-offs

• Readability: Code is more complex and harder to understand
• Maintainability: Changes require understanding the optimization mapping
• Justification: Edge geometry generation directly impacts user experience (frame drops during scene initialization)

Future Optimization Considerations

If further optimization is needed:

• WebGPU Compute Shader (parallel processing on GPU)
• Web Workers (limited benefit due to data transfer overhead)
• Only practical for geometries with 100k+ triangles