# FikoYT 3D CAD Motoru - Rendering Pipeline Optimizasyon Plani

**Tarih:** 2026-03-13
**Hedef:** 60 FPS @ 10M+ triangle, <16ms frame budget, CATIA/SolidWorks seviyesi rendering kalitesi
**Mevcut Altyapi Dosya Yolu:** `src/service/fikoyt-ui/src/lib/fiko-three-js/IFikoThreeJS/fiko-performance/`

---

## MEVCUT DURUM ANALIZI

### Mevcut Performans Modulleri (fiko-performance/)

| Modul | Dosya | Durum | Notlar |
|-------|-------|-------|--------|
| BatchedMesh | FikoBatchedMeshManager.ts | Temel implementasyon | Material-key bazli gruplama, geometry instancing var |
| Dynamic Batching | FikoDynamicBatching.ts | Calisiyor | InstancedMesh bazli, runtime batching, dirty tracking |
| Static Merging | FikoDynamicBatching.ts (alt sinif) | Calisiyor | FikoStaticGeometryMerger - tam geometry birlestirme |
| Advanced LOD | FikoAdvancedLOD.ts | Calisiyor | 6 seviye (100%->5%->point), screen-space error, GPU compute ref |
| Streaming LOD | FikoStreamingLOD.ts | Mevcut | Progressive geometry loading |
| Temporal LOD | FikoTemporalLOD.ts | Mevcut | Frame-to-frame LOD gecisleri |
| View-Dependent LOD | FikoViewDependentLOD.ts | Mevcut | Kamera odakli LOD |
| HiZ Occlusion | FikoHiZOcclusionCulling.ts | Calisiyor | WebGPU shader'lar yazilmis AMA WebGL-WebGPU interop eksik, CPU fallback aktif |
| GPU Selection | FikoGPUSelection.ts | Calisiyor | WASM + WebGPU + CPU kademeli secim |
| GPU Picker | FikoGPUPicker.ts | Calisiyor | ID-based GPU picking |
| Instanced Edge | FikoInstancedEdgeRenderer.ts | Calisiyor | Single draw call, custom shader, partial update |
| Advanced Edge | FikoAdvancedEdgeDetection.ts | Calisiyor | BVH-accelerated, silhouette/crease/clip edge |
| Z-Prepass | FikoZPrepass.ts | Temel implementasyon | Depth-only pass, early rejection |
| Adaptive Quality | FikoAdaptiveQuality.ts | Calisiyor | 5 seviye (ultra->potato), FPS-based auto-adjust |
| Frame Budget | FikoRenderLoopOptimizer.ts | Calisiyor | Budget enforcement, phase-based rendering |
| Vector Pool | FikoRenderLoopOptimizer.ts | Calisiyor | Ring buffer, 128 Vec3, 16 Mat4, zero-alloc |
| Memory Pooling | FikoMemoryPooling.ts | Calisiyor | ObjectPool, TypedArrayPool, ScopedPoolAccess |
| WebGPU Renderer | FikoWebGPURenderer.ts | Temel implementasyon | Dual-mode wrapper, fallback mantigi |
| WASM Bridge | FikoWasmBridge.ts | Calisiyor | Edge detection, STP parsing, batch distance |
| Shared Memory | FikoSharedMemory.ts | Mevcut | SharedArrayBuffer, AtomicLock, RingBuffer |
| Worker Pool | FikoWorkerPool.ts | Calisiyor | Comlink-based worker management |
| Performance Integration | FikoPerformanceIntegration.ts | Mevcut | Merkezi orkestrator |

### Tespit Edilen Kritik Eksiklikler

1. **HiZ Occlusion GPU path calismiyor**: WGSL shader'lar yazili ama `buildHiZPyramidWebGPU()` dogrudan CPU fallback'e dusuyor. WebGL->WebGPU texture interop yok.
2. **LOD decimation CPU-only**: `calculateVertexImportance()` her vertex icin adjacency + curvature hesapliyor - `O(V*F)` karmasiklik.
3. **LOD gecisleri anlik**: `transitionLOD()` instant switch yapiyor, popping artefaktlari olusur.
4. **Render state sorting yok**: Three.js varsayilan siralama, opaque front-to-back optimizasyonu elle yapilmiyor.
5. **Multi-pass pipeline daginik**: Z-prepass, shadow, main, edge, post-process ayri modullerde, merkezi pipeline yok.
6. **Material atlasing yok**: Her farkli renk ayri material = ayri draw call.
7. **Edge rendering hala CPU-heavy**: `FikoAdvancedEdgeDetection` BVH kullaniyor ama GPU-side edge detection (screen-space) tam entegre degil.
8. **BatchedMesh geometry UUID bazli**: Ayni geometrinin farkli instance'lari ayri key aliyor, merge orani dusuk.

---

## 10 OPTIMIZASYON MADDESI

### 1. Draw Call Azaltma Stratejisi

**Mevcut Durum:**
- `FikoBatchedMeshManager`: Material-key bazli gruplama var (renk+metalness+roughness+opacity+side)
- `FikoDynamicBatching`: Runtime InstancedMesh olusturma, 4096 max instance/batch
- `FikoStaticGeometryMerger`: Geometry birlestirme (statik objeler icin)
- Sorun: geometry.uuid bazli key kullaniliyor, ayni seklilde farkli UUID'ler merge olmuyor

**Hedef Durum:**
- **Geometry hashing**: UUID yerine vertex count + index count + bounding box hash ile gruplama
- **Material atlasing**: Benzer material'leri (sadece renk farkli) tek material + per-instance color'a donustur
- **Multi-draw indirect**: Three.js r177 `BatchedMesh.setGeometryIdAt()` ile farkli geometrileri tek draw call'da ciz
- **Hybrid batching**: Statik objeler -> merged geometry, dinamik objeler -> instanced mesh

**Tahmini Kazanim:** Draw call'lari %80-95 azaltma (1000 draw call -> 50-200)
**Oncelik:** P0
**Bagimliliklar:** Yok

---

### 2. GPU-Driven Rendering Pipeline

**Mevcut Durum:**
- Tum culling ve sorting CPU'da yapiliyor
- `FikoOptimizedFrustumCuller`: CPU-side frustum culling + bounding sphere cache
- Three.js varsayilan render loop (CPU scene traversal)

**Hedef Durum:**
- **GPU frustum culling**: Compute shader ile tum bounding sphere'leri tek seferde test et
- **GPU indirect draw buffer**: Gorunur objeleri GPU'da filtrele, indirect draw buffer'a yaz
- **GPU sort**: Depth-based siralama GPU'da (bitonic sort veya radix sort)
- **Two-phase approach**: Phase 1 - GPU culling + sort, Phase 2 - indirect draw

**Tahmini Kazanim:** 10K+ obje sahnelerinde CPU overhead %70 azalma, GPU utilization %30 artis
**Oncelik:** P2
**Bagimliliklar:** WebGPU (#10), BatchedMesh altyapisi (#1)

---

### 3. LOD Sistemi Iyilestirmesi

**Mevcut Durum:**
- `FikoAdvancedLOD`: 6 seviye (100%, 50%, 25%, 10%, billboard, point), screen-space error metrik
- Decimation: Greedy edge collapse, curvature-based vertex importance (CPU)
- Gecis: Instant switch (popping)
- 4 LOD sistemi mevcut (Advanced, Streaming, Temporal, ViewDependent) ama entegrasyon daginik

**Hedef Durum:**
- **Meshlet-based LOD**: Nanite-style meshlet DAG (64-128 triangle cluster'lar)
- **Continuous LOD (CLOD)**: Geomorphing ile smooth gecis (vertex interpolation shader)
- **GPU decimation**: Vertex importance hesabini compute shader'a tasi
- **Unified LOD manager**: 4 LOD sistemini tek orchestrator altinda birlestir
- **Error metric iyilestirmesi**: Hausdorff distance + projected pixel error hibrit metrik

**Tahmini Kazanim:** Popping artefakti %100 eliminasyon, LOD gecis suresi 0ms->shader-based, triangle sayisi %60-80 azalma
**Oncelik:** P1
**Bagimliliklar:** Kismen #1 (merged meshler icin LOD)

---

### 4. Okluzyon Culling Upgrade

**Mevcut Durum:**
- `FikoHiZOcclusionCulling`: WGSL shader'lar yazili (mip build + batch query)
- **Kritik sorun**: WebGPU pipeline kurulu AMA `buildHiZPyramidWebGPU()` CPU fallback'e dusuyor
- CPU path: `readPixels()` + manual mip chain -> yuksek latency
- Temporal coherence: 2-frame cache var

**Hedef Durum:**
- **WebGL2 GPU path**: Depth texture'u fragment shader ile mip chain'e donustur (no readPixels)
- **PBO async readback**: `readPixels` yerine PBO (Pixel Buffer Object) ile async okuma
- **Two-pass occlusion**: Coarse (bounding box) + fine (per-triangle) iki asamali culling
- **Contribution culling**: Ekranda <2px olan objeleri tamamen atla
- **Software rasterizer fallback**: Buyuk occluder'lar icin basitlestirilmis CPU rasterizer

**Tahmini Kazanim:** Yogun sahnelerde %30-50 daha az obje renderlama, occlusion query suresi 5ms->0.5ms
**Oncelik:** P1
**Bagimliliklar:** Z-Prepass (#9) ile entegrasyon

---

### 5. Edge Rendering Optimizasyonu

**Mevcut Durum:**
- `FikoInstancedEdgeRenderer`: Single draw call, custom vertex/fragment shader, partial update
- `FikoAdvancedEdgeDetection`: BVH-accelerated, silhouette/crease/clip edge tespiti
- `FikoWasmBridge`: WASM ile edge extraction (extractMeshEdges)
- Sorun: Edge tespiti per-mesh CPU'da yapiliyor, buyuk assemblylerde yavas

**Hedef Durum:**
- **Screen-space edge detection (tam GPU)**: G-buffer'dan depth + normal discontinuity ile edge bulma
  - Depth edge: Laplacian of depth
  - Normal edge: Normal discontinuity
  - Object ID edge: ID buffer discontinuity
- **Hybrid approach**: Feature edge'ler (crease/sharp) CPU+WASM'da onceden hesapla, silhouette edge'ler GPU'da runtime
- **Edge LOD**: Uzak objelerin edge'lerini atla, yakin objelerde full edge
- **Instanced edge culling**: Frustum disindaki edge'leri GPU'da atla (visibility buffer'da)

**Tahmini Kazanim:** Edge detection suresi 5ms->0.5ms, edge rendering 1 draw call (mevcut) kalir ama veri hazirlik %80 azalir
**Oncelik:** P1
**Bagimliliklar:** G-buffer altyapisi (#9), WASM bridge (mevcut)

---

### 6. Shader Optimizasyonlari

**Mevcut Durum:**
- Her material tipi icin ayri shader (MeshStandardMaterial, ShaderMaterial, vb.)
- Custom shader'lar: edge shader, depth shader, upscale shader
- Material degisiklikleri GPU state switch'e neden oluyor

**Hedef Durum:**
- **Uber shader**: Tek shader program, #define ile feature toggle
  - `#define HAS_NORMAL_MAP`, `#define HAS_METALNESS`, `#define FLAT_SHADING`, vb.
  - Material variant'lar compile-time, runtime switch yok
- **Material variant cache**: Kullanilan kombinasyonlari onceden compile et
- **Shader warmup**: Ilk frame'de tum variant'lari bos sahne ile compile et (jank onleme)
- **Bindless textures**: Texture atlas veya texture array ile bind sayisini azalt (WebGL2 texture array)
- **Half-precision**: Color/normal hesaplamalarinda mediump kullan (mobil/low-end icin)

**Tahmini Kazanim:** GPU state switch %60 azalma, shader compile stutter eliminasyonu, %5-15 fragment throughput artisi
**Oncelik:** P2
**Bagimliliklar:** #1 (material atlasing ile birlikte)

---

### 7. Render State Sorting

**Mevcut Durum:**
- Three.js varsayilan siralama: `renderOrder` property + transparent ayirimi
- Opaque objeler belirli bir sirada cizilmiyor (front-to-back degil)
- Her material degisikligi GPU pipeline flush'a neden oluyor

**Hedef Durum:**
- **Front-to-back opaque rendering**: Depth-sorted opaque pass (early-Z rejection maximize)
- **Back-to-front transparent rendering**: Zaten Three.js yapiyor, iyilestirme gerekmez
- **Material-sorted batching**: Ayni material'deki objeleri ardisik ciz (GPU state switch minimize)
- **Sort key encoding**: 64-bit key = [material_id:16][depth:32][mesh_id:16] ile single sort
- **Stable sort**: Ayni key'deki objelerin sirasi degismez (flickering onleme)

**Tahmini Kazanim:** Overdraw %30-50 azalma (opaque), GPU state switch %40 azalma
**Oncelik:** P1
**Bagimliliklar:** #1 (batching ile entegre edilmeli)

---

### 8. Frame Budget Yonetimi

**Mevcut Durum:**
- `FikoFrameBudgetManager`: 16ms budget, adaptive quality (0.25-1.0), overdraft tracking
- `FikoAdaptiveQuality`: 5 preset (ultra->potato), resolution scaling, shadow toggle
- `FikoRenderLoopCoordinator`: Phase-based execution, budget checking
- Sorun: Phase'ler birbirinden bagimsiz, toplam budget asildiginda hangi phase kesilecegi net degil

**Hedef Durum:**
- **Priority-based phase skipping**: Her phase'e priority + minimum frequency ata
  - P0 (asla atlanmaz): Main render, UI
  - P1 (her frame): Frustum cull, LOD update
  - P2 (her 2-4 frame): Occlusion query, edge update, shadow update
  - P3 (her 8-16 frame): LOD rebuild, batch rebuild, GC
- **Time-sliced work**: Buyuk islemleri (LOD rebuild, batch update) frame'ler arasinda bol
- **GPU fence timing**: `EXT_disjoint_timer_query_webgl2` ile gercek GPU suresi ol (mevcut sadece init)
- **Predictive budgeting**: Onceki frame'in phase timings'ini kullanarak sonraki frame'i planla
- **Jank detection**: Variance-based spike detection + otomatik quality drop

**Tahmini Kazanim:** Frame time variance %50 azalma, 1% low FPS %30 iyilesme, stutter/jank eliminasyonu
**Oncelik:** P0
**Bagimliliklar:** Tum diger maddelerle entegrasyon

---

### 9. Multi-Pass Rendering Pipeline

**Mevcut Durum:**
- `FikoZPrepass`: Depth-only pass (temel implementasyon)
- `FikoScreenSpaceAO`: SSAO post-process
- `FikoTemporalAA`: TAA post-process
- Shadow: Three.js varsayilan shadow map
- Sorun: Pass'lar ayri moduller, merkezi pipeline yok, render target yonetimi daginik

**Hedef Durum:**
- **Merkezi render graph**: Pass'lari DAG olarak tanimla, render target'lari otomatik yonet
  ```
  Shadow Pass -> Z-Prepass -> HiZ Build -> Occlusion Query
       |              |                         |
       v              v                         v
  G-Buffer Pass -> Main Color Pass -> Edge Detection (screen-space)
       |                                        |
       v                                        v
  SSAO Pass -> Composite -> TAA -> Tonemap -> Output
  ```
- **G-Buffer rendering**: Position + Normal + Albedo + Material ID tek pass'ta
- **Deferred shading**: G-buffer'dan lighting hesapla (buyuk sahnelerde forward'dan hizli)
- **Render target pooling**: Frame icinde render target'lari yeniden kullan (memory azaltma)
- **Pass fusion**: Gereksiz pass'lari birlestir (Z-prepass + G-buffer ayni pass olabilir)
- **Conditional passes**: Adaptive quality'e gore pass'lari atla (SSAO, TAA, shadows)

**Tahmini Kazanim:** Toplam render suresi %20-30 azalma, memory kullanimi %15 azalma (RT pooling), overdraw eliminasyonu
**Oncelik:** P2
**Bagimliliklar:** #4 (HiZ), #5 (screen-space edges), #7 (render state sorting)

---

### 10. WebGPU Migration Path

**Mevcut Durum:**
- `FikoWebGPURenderer`: Dual-mode wrapper mevcut, WebGL fallback mantigi var
- `FikoGPUAdapter`: Unified WebGPU/WebGL2 abstraction layer
- `FikoHiZOcclusionCulling`: WGSL compute shader'lar yazili (mip build, batch query)
- `FikoGPUComputeUltra`: WebGL2 compute simulasyonu (transform feedback)
- Three.js r177 WebGPU renderer destegi mevcut (three/addons)

**Hedef Durum:**
- **Faz A - Compute-only WebGPU**: Rendering WebGL'de kalsin, compute islemleri WebGPU'da
  - Occlusion culling compute
  - LOD selection compute
  - Edge detection compute
  - Frustum culling compute
- **Faz B - Hybrid rendering**: Three.js WebGPURenderer ile main render, WebGL ile fallback
  - `three/addons/renderers/webgpu/WebGPURenderer`
  - Conditional: `navigator.gpu` varsa WebGPU, yoksa WebGL2
- **Faz C - Full WebGPU**: Tum rendering + compute WebGPU'da
  - Indirect draw buffers (native support)
  - Bindless resources
  - Multi-queue (render + compute paralel)
  - Render bundles (command recording)

**Tahmini Kazanim:** Draw call overhead %90 azalma (Faz C), compute throughput %200-500 artis (Faz A)
**Oncelik:** P3
**Bagimliliklar:** Tum diger maddeler WebGPU'dan faydalanir

---

## FAZ BAZLI IMPLEMENTASYON PLANI

### FAZ 1: Quick Wins (1-2 Hafta)

Mevcut altyapida minimum degisiklik, maksimum kazanim.

| # | Madde | Is | Tahmini Sure | Kazanim |
|---|-------|-----|-------------|---------|
| 1.1 | Material atlasing | Ayni geometry + farkli renk -> per-instance color | 2 gun | %30-50 draw call azaltma |
| 1.2 | Render state sorting | Opaque front-to-back sort key + material sort | 2 gun | %30-50 overdraw azaltma |
| 1.3 | Frame budget priority | Phase priority sistemi + time-slicing | 1 gun | Stutter/jank azaltma |
| 1.4 | LOD gecis iyilestirme | Dithered cross-fade (shader-based) | 1 gun | Popping eliminasyonu |
| 1.5 | HiZ CPU optimizasyonu | PBO async readback + mip chain WebGL fragment shader | 2 gun | Occlusion query 5ms->1ms |
| 1.6 | Contribution culling | <2px objeleri atla (ekran alan testi) | 0.5 gun | %5-10 obje culling |
| 1.7 | Shader warmup | Startup'ta tum variant'lari compile et | 0.5 gun | Ilk frame jank eliminasyonu |

**Toplam:** ~9 gun
**Beklenen Toplam Kazanim:** %40-60 frame time iyilesmesi

---

### FAZ 2: Medium Effort (2-4 Hafta)

Mevcut mimariye yeni moduller ekleme, orta seviye refactoring.

| # | Madde | Is | Tahmini Sure | Kazanim |
|---|-------|-----|-------------|---------|
| 2.1 | Screen-space edge detection | G-buffer'dan depth+normal edge shader | 3 gun | Edge detection CPU->GPU |
| 2.2 | Geometry hashing | UUID yerine geometric hash ile batching | 2 gun | %20 daha fazla merge |
| 2.3 | Unified LOD manager | 4 LOD sistemini tek orchestrator altinda birlestir | 3 gun | Kod temizligi + tutarli LOD |
| 2.4 | Multi-draw indirect | Three.js BatchedMesh ile farkli geometry'leri tek draw | 3 gun | %50 ek draw call azaltma |
| 2.5 | Uber shader v1 | MeshStandard variant'lari tek shader + #define | 4 gun | GPU state switch %60 azaltma |
| 2.6 | Render target pooling | Frame icinde RT yeniden kullanim | 2 gun | %15 memory azaltma |
| 2.7 | GPU frustum culling (WebGL2) | Transform feedback ile GPU-side frustum test | 3 gun | 10K+ obje CPU overhead %50 azaltma |
| 2.8 | Predictive frame budgeting | Onceki frame data'siyla sonraki frame planla | 2 gun | Frame time variance %30 azaltma |

**Toplam:** ~22 gun
**Beklenen Toplam Kazanim:** %60-80 frame time iyilesmesi (Faz 1 uzerine kumulatif)

---

### FAZ 3: Major Refactor (4-8 Hafta)

Mimari degisiklikler, yeni rendering paradigmalari.

| # | Madde | Is | Tahmini Sure | Kazanim |
|---|-------|-----|-------------|---------|
| 3.1 | Merkezi render graph | DAG-based pass yonetimi + otomatik RT allocation | 5 gun | Render pipeline tutarliligi |
| 3.2 | G-Buffer + Deferred shading | Position+Normal+Albedo+ID tek pass, deferred lighting | 7 gun | Buyuk sahnelerde %30 hiz |
| 3.3 | Meshlet-based LOD | 64-128 triangle cluster'lar, hierarchical DAG | 10 gun | %80 triangle azaltma, smooth LOD |
| 3.4 | WebGPU compute-only (Faz A) | Culling + LOD selection + edge detection compute | 7 gun | Compute throughput %200 artis |
| 3.5 | GPU-driven indirect draw | GPU culling -> indirect draw buffer | 5 gun | CPU overhead %90 azaltma |
| 3.6 | Continuous LOD geomorphing | Vertex interpolation shader ile smooth gecis | 3 gun | Zero-popping LOD |
| 3.7 | WebGPU hybrid rendering (Faz B) | WebGPURenderer entegrasyonu + WebGL fallback | 5 gun | Draw call overhead %90 azaltma |

**Toplam:** ~42 gun
**Beklenen Toplam Kazanim:** %80-95 frame time iyilesmesi (Faz 1+2 uzerine kumulatif)

---

## ONCELIK MATRISI

```
              Dusuk Effor  |  Yuksek Effor
           ________________|________________
Yuksek    |  1.1, 1.2,    |  2.1, 2.4,
Kazanim   |  1.5, 1.6     |  3.2, 3.3, 3.5
           |               |
           |_______________|________________
Dusuk     |  1.3, 1.4,    |  2.5, 2.6,
Kazanim   |  1.7           |  3.1, 3.6, 3.7
           |_______________|________________
```

## RISK ANALIZI

| Risk | Olasilik | Etki | Azaltma |
|------|----------|------|---------|
| WebGPU browser destegi yetersiz | Orta | Yuksek | WebGL2 fallback her zaman hazir |
| Three.js BatchedMesh API degisikligi | Dusuk | Orta | r177 API'sine baglanmak, versiyon kilidi |
| Deferred shading + transparent objeler | Yuksek | Orta | OIT (Order-Independent Transparency) veya forward pass for transparent |
| Meshlet LOD bellek kullanimi | Orta | Orta | Memory budget enforcement, streaming |
| Uber shader compile suresi | Dusuk | Dusuk | Warmup + async compile |

## OLCUM METRIKLERI

Her faz sonunda su metrikler olculur:

1. **FPS** (avg, 1% low, 0.1% low)
2. **Frame time** (avg, p95, p99)
3. **Draw calls** (per frame)
4. **Triangle count** (rendered vs total)
5. **GPU memory** (textures + geometry + render targets)
6. **CPU time** (culling, batching, upload, JS overhead)
7. **GPU time** (`EXT_disjoint_timer_query_webgl2`)
8. **Time-to-first-frame** (STEP dosya import -> ilk render)

Test sahneleri:
- Kucuk: 10K triangle, 50 parca
- Orta: 500K triangle, 500 parca
- Buyuk: 5M triangle, 5000 parca
- Extreme: 20M+ triangle, 20000+ parca

---

## ILGILI DOSYALAR

### Mevcut Performance Modulleri
- `src/service/fikoyt-ui/src/lib/fiko-three-js/IFikoThreeJS/fiko-performance/` (55+ dosya)
- Ana index: `fiko-performance/index.ts`
- Entegrasyon: `fiko-performance/FikoPerformanceIntegration.ts`
- Orkestrator: `fiko-performance/FikoUltraPerformanceManager.ts`

### Render Pipeline
- `fiko-performance/FikoRenderLoopOptimizer.ts` - Frame budget + phase management
- `fiko-performance/FikoZPrepass.ts` - Depth pre-pass
- `fiko-performance/FikoScreenSpaceAO.ts` - SSAO
- `fiko-performance/FikoTemporalAA.ts` - TAA
- `fiko-performance/FikoWebGPURenderer.ts` - WebGPU/WebGL dual renderer

### Draw Call Optimization
- `fiko-performance/FikoBatchedMeshManager.ts` - BatchedMesh wrapper
- `fiko-performance/FikoDynamicBatching.ts` - Runtime instancing + static merging
- `fiko-performance/FikoInstancedOptimizer.ts` - Instance optimization

### LOD
- `fiko-performance/FikoAdvancedLOD.ts` - Screen-space error LOD
- `fiko-performance/FikoStreamingLOD.ts` - Progressive loading
- `fiko-performance/FikoTemporalLOD.ts` - Temporal coherence
- `fiko-performance/FikoViewDependentLOD.ts` - View-dependent streaming

### Culling
- `fiko-performance/FikoHiZOcclusionCulling.ts` - HiZ occlusion (WebGPU+CPU)
- `fiko-performance/FikoRenderLoopOptimizer.ts` (FikoOptimizedFrustumCuller)

### Edge Rendering
- `fiko-performance/FikoInstancedEdgeRenderer.ts` - Instanced edge drawing
- `fiko-performance/FikoAdvancedEdgeDetection.ts` - BVH edge detection
- `fiko-performance/FikoEdgeSpatialIndex.ts` - Edge spatial indexing

### GPU Compute
- `fiko-performance/FikoGPUComputeUltra.ts` - WebGL2 GPU compute
- `fiko-performance/FikoGPUAdapter.ts` - WebGPU/WebGL2 abstraction
- `fiko-performance/FikoWebGPU.ts` - WebGPU utilities
- `fiko-performance/FikoGpuBridge.ts` - GPU bridge

### Selection
- `fiko-performance/FikoGPUSelection.ts` - WASM+GPU+CPU selection
- `fiko-performance/FikoGPUPicker.ts` - GPU ID picking
- `fiko-performance/FikoRaycastBVH.ts` - BVH raycasting

### Memory
- `fiko-performance/FikoMemoryPooling.ts` - Object pools
- `fiko-performance/FikoSharedMemory.ts` - SharedArrayBuffer
- `fiko-performance/FikoSharedBufferManager.ts` - Buffer management
- `fiko-performance/FikoVertexQuantization.ts` - Vertex compression
- `fiko-performance/FikoMeshCompressor.ts` - Mesh compression