# FikoYT 3D CAD Master Mimari Plan

**Tarih:** 2026-03-13
**Versiyon:** 1.0
**Hedef:** Endustri seviyesi web CAD + dokum simulasyonu platformu

---

## A. MEVCUT DURUM ANALiZi

### A.1 Kod Tabanı Envanteri

| Katman | Dosya Sayısı | Toplam Satır | Durum |
|--------|-------------|-------------|-------|
| 3D Motor (fiko-three-js/) | 537 TS dosyası | ~120.000+ | Aktif, olgun |
| Performans Modulleri (fiko-performance/) | 57 TS dosyası | ~42.666 | Agresif optimize |
| WASM Motor (fikoyt-wasm/) | 12 Rust dosyası | ~8.454 | Temel altyapı hazır |
| SPH Sıvı Simulasyonu (fiko-sph-sivi/) | 17+ dosya (GPU WGSL dahil) | ~5.000+ | Prototip |
| Dokum Simulasyonu (dokum/) | 4 Rust dosyası | ~1.500+ | CPU fallback hazır |
| Shader/NPR | 5 dosya | ~1.000+ | Temel |

### A.2 Mevcut Optimizasyon Katmanları (Uygulanmış)

**Secim Sistemi (FikoSecililer.ts - 7.451 satır):**
- 3 katmanlı cascading: WASM -> GPU -> CPU
- Pre-allocated static Vector3/Matrix4 buffer'ları (sıfır-allokasyon)
- BVH raycast (O(log n))
- GPU picking (FikoGPUPicker)
- WebGPU native raycast (FikoWebGPURaycast - double-buffered async)
- Memory pooling (FikoMemoryPooling - CATIA seviyesi)
- Edge spatial index (O(1) arama)
- Lazy geometry clone (UI freeze onleme)

**STEP Import (FikoImporter.STP.ts - 4.566 satır):**
- Buffer array caching (LRU, 50 boyut)
- Zero-copy default arrays
- OpenCascade bridge (occt-import-js)
- WASM topoloji parse (stp_parser.rs)
- GPU import pipeline
- Time-sliced executor (UI thread bloklama onleme)
- Batched mesh manager

**Rendering Pipeline:**
- Instanced edge rendering (tek draw call)
- Advanced LOD (GPU-accelerated decimation)
- Hi-Z occlusion culling
- Dynamic resolution scaling
- Temporal AA
- Screen-space AO
- Z-prepass
- NPR shader'ları (Gooch, Hatching, Silhouette, Toon)
- View-dependent LOD

**WASM Modulleri (Rust):**
- GPU: thickness, edge_detector, frustum_culler, surface_recognizer (SIMD fallback)
- Dokum: thermal_cpu (Fourier), lbm_cpu (D3Q19 LBM), niyama (curuma kriteri)
- section_cutting, stp_parser

**SPH Akıskan Simulasyonu:**
- 3 solver: DFSPH, PBF, PCISPH
- 11 WebGPU compute shader (WGSL)
- Malzeme kutuphanesi, parametre yonetimi
- SDF, termal, gaz, sensor shader'ları

### A.3 Tespit Edilen Eksiklikler ve Darbogazlar

1. **WASM Kapsamı Dar:** 8.454 satır Rust - thickness/edge/frustum/surface + dokum CPU. STEP parsing, mesh boolean, tessellation gibi agır islemler hala JS.
2. **WebGPU Adaptasyonu Kısmı:** FikoWebGPU altyapısı var ama Three.js hala WebGL2 renderer kullanıyor. WebGPU renderer (FikoWebGPURenderer.ts) mevcut ama entegrasyon eksik.
3. **Worker Pipeline Fragmentasyonu:** FikoWorkerPool, FikoComlinkWorkerPool, FikoComputeWorkerPool, geometry worker'ları ayrı ayrı yonetiliyor. Unified pipeline yok.
4. **SharedArrayBuffer Kullanılmıyor:** Worker'lar arası veri kopyalama var, zero-copy SAB transfer yok.
5. **LOD Sistemi Dagınık:** FikoAdvancedLOD, FikoStreamingLOD, FikoTemporalLOD, FikoViewDependentLOD, FikoAggressiveLOD - 5 ayrı LOD implementasyonu.
6. **Simülasyon GPU-CPU Kopuklugu:** SPH GPU shader'ları hazır ama CPU fallback Rust ile. Ortak veri yapısı/pipeline yok.
7. **Bellek Yonetimi:** FikoResourceManager ve FikoMemoryPooling var ama unified memory budget yok.
8. **Profiling/Benchmark:** FikoPerformanceManager ve HUD var ama otomatik regression testi yok.

---

## B. MiMARi ViZYON

### B.1 Hedef Seviye

| Benchmark | Onshape | Shapr3D | FikoYT (Hedef) |
|-----------|---------|---------|-----------------|
| Max triangle | 500K | 2M | 1M+ (2M stretch) |
| Max part | 500 | 1000 | 1000+ |
| Ilk render | 3-5s | 2-3s | <2s |
| Secim yanıt | 10-20ms | 5-10ms | <5ms |
| Frame rate | 30-60 | 60 | 60 FPS (30 @1M+) |
| STEP import | 15-30s | 5-10s | <10s (50MB) |

### B.2 Mimari Katman Diyagramı

```
┌──────────────────────────────────────────────────────────────┐
│                    ANGULAR 20 UI LAYER                        │
│  Components | Ng-Zorro | Signals | OnPush ChangeDetection    │
├──────────────────────────────────────────────────────────────┤
│                 CAD APPLICATION LAYER                         │
│  FikoSecililer | FikoImporter | FikoCizim | FikoOlcum        │
│  FikoAnnotation | FikoBrep | FikoDFM | FikoCMM               │
├──────────────────────────────────────────────────────────────┤
│              RENDERING ENGINE LAYER                           │
│  ┌─────────────┐  ┌──────────────┐  ┌────────────────────┐  │
│  │ Three.js    │  │ WebGPU       │  │ NPR/Post-          │  │
│  │ WebGL2      │→ │ Renderer     │  │ processing          │  │
│  │ (current)   │  │ (migration)  │  │ Pipeline            │  │
│  └─────────────┘  └──────────────┘  └────────────────────┘  │
├──────────────────────────────────────────────────────────────┤
│             COMPUTE ENGINE LAYER                              │
│  ┌──────────┐ ┌──────────────┐ ┌────────────────────────┐   │
│  │ WASM     │ │ WebGPU       │ │ Worker Pool            │   │
│  │ (Rust)   │ │ Compute      │ │ (SAB Pipeline)         │   │
│  │ SIMD     │ │ Shaders      │ │ Comlink + Transfer     │   │
│  └──────────┘ └──────────────┘ └────────────────────────┘   │
├──────────────────────────────────────────────────────────────┤
│            SIMULATION ENGINE LAYER                            │
│  ┌──────────┐ ┌──────────────┐ ┌────────────────────────┐   │
│  │ Thermal  │ │ LBM Flow     │ │ SPH Fluid              │   │
│  │ (Fourier)│ │ (D3Q19)      │ │ (DFSPH/PBF/PCISPH)     │   │
│  └──────────┘ └──────────────┘ └────────────────────────┘   │
├──────────────────────────────────────────────────────────────┤
│            MEMORY & RESOURCE MANAGEMENT                       │
│  Unified Memory Budget | Buffer Pool | LOD Manager            │
│  Geometry Cache | Texture Atlas | GPU Buffer Reuse            │
└──────────────────────────────────────────────────────────────┘
```

### B.3 Teknoloji Stack Evrimi

```
MEVCUT                          HEDEF (9 ay)
─────────                       ───────────
Three.js 0.177 WebGL2       →   Three.js WebGPU Renderer
CPU raycast (fallback)       →   GPU-only raycast (BVH)
Fragmented workers           →   Unified SAB Worker Pipeline
5x LOD impl                  →   Single Adaptive LOD Manager
8K sat WASM                  →   25K+ sat WASM (mesh ops, tessellation)
SPH prototip                →   Uretim-hazır dokum simulasyonu
JS STEP parse               →   WASM STEP parse + streaming
Per-frame alloc (bazı)       →   Zero-alloc render loop (tamamı)
```

---

## C. PERFORMANS HEDEFLERi ve METRiKLER

### C.1 Katmanlı Hedefler

| Metrik | Mevcut (Tahmini) | Faz 1 | Faz 2 | Faz 3 | Faz 5 (Final) |
|--------|-----------------|-------|-------|-------|----------------|
| Ilk render (1M tri) | ~5s | <3s | <2.5s | <2s | <1.5s |
| Secim yanıt | ~8ms | <5ms | <3ms | <1ms | <1ms |
| Frame rate (100K tri) | 55-60 | 60 | 60 | 60 | 60 |
| Frame rate (1M tri) | 20-30 | 30 | 45 | 60 | 60 |
| JS heap (1M tri) | ~1.5GB | <1.2GB | <1GB | <800MB | <700MB |
| GPU VRAM (1M tri) | ~2GB | <1.8GB | <1.5GB | <1.2GB | <1GB |
| STEP import (50MB) | ~20s | <15s | <12s | <10s | <8s |
| Edge hover (10K edge) | ~10ms | <5ms | <3ms | <1ms | <0.5ms |
| Dokum sim (64^3) | N/A | N/A | CPU 2s/step | GPU 50ms/step | GPU 20ms/step |

### C.2 Benchmark Test Modelleri

| Model | Triangles | Parts | Dosya Boyutu | Kullanım |
|-------|-----------|-------|-------------|----------|
| Basit Bolum | 5K | 1 | 500KB | Smoke test |
| Orta Assembly | 50K | 20 | 5MB | Gunluk performans |
| Buyuk Assembly | 200K | 100 | 20MB | Stres testi |
| Mega Assembly | 1M | 500 | 50MB | Uç durum testi |
| Ultra Assembly | 2M | 1000 | 100MB | Stretch hedef |

### C.3 Otomatik Performans Regression Testi

```typescript
// Hedef: CI/CD pipeline'da her merge'de otomatik performans testi
interface PerformansRapor {
  model: string;
  ilkRenderMs: number;
  secimYanitMs: number;
  ortalamaFPS: number;
  jsHeapMB: number;
  gpuVramMB: number;
  stepImportMs: number;
  gectiMi: boolean; // Hedef metriklerle karsilastir
}
```

---

## D. iMPLEMENTASYON FAZLARI

### FAZ 1: QUICK WINS (2 Hafta)

**Risk:** Dusuk | **Etki:** Orta-Yuksek | **Breaking Change:** Yok

#### D.1.1 LOD Konsolidasyonu (3 gun)

**Problem:** 5 ayrı LOD sistemi (Advanced, Streaming, Temporal, ViewDependent, Aggressive) birbirinden bagimsız calısiyor. Hangi LOD'un ne zaman aktif olacagi belirlenemiyor.

**Cozum:**
```
Dosya: fiko-performance/FikoUnifiedLOD.ts (YENi)

Sorumluluk:
- Tek LOD karar noktası (facade pattern)
- Kamera mesafesi + ekran kapladıgı alan + GPU budget'a gore LOD seviyesi sec
- Mevcut 5 LOD'u internal strategy olarak kullan, disariya tek API sun
- Gereksiz LOD update'lerini throttle et (her 4 frame zaten var, bunu adaptive yap)

API:
  class FikoUnifiedLOD {
    setCamera(camera: Camera): void
    setGPUBudget(triangleBudget: number): void  // ornegin 500K
    registerObject(obj: Object3D, baseMesh: Mesh): void
    update(deltaTime: number): void  // her frame cagirilir
    getStats(): { activeTriangles, lodDistribution, decimationTime }
  }

Uygulama:
  1. FikoAdvancedLOD'u birincil strateji yap (GPU decimation)
  2. FikoViewDependentLOD'u kamera mesafe hesabı icin kullan
  3. FikoStreamingLOD'u buyuk modeller icin lazy-load mekanizması yap
  4. FikoTemporalLOD ve FikoAggressiveLOD'u ozel durumlar icin tut
  5. Mevcut consumer kodunu FikoUnifiedLOD'a yonlendir
```

**Olculebilir Hedef:** 1M triangle sahnede LOD ile aktif triangle sayısını 300K'ya dusur. Frame rate 20-30 FPS -> 45+ FPS.

#### D.1.2 Render Loop Sıfır-Allokasyon Denetimi (2 gun)

**Problem:** Cogu hot path optimize edilmis ama bazı kenar durumlar hala allokasyon yapıyor olabilir.

**Cozum:**
```
Dosya: Mevcut dosyalarda audit

Kontrol Listesi:
  [ ] FikoSecililer.ts - mouseMove handler'ında tum Vector3 static mi?
  [ ] FikoGrup.ts - traverse callback'lerinde closure allokasyonu var mı?
  [ ] FikoImporter.STP.ts - import sırasında gereksiz array kopyası var mı?
  [ ] FikoOrbitKontrol.ts - update loop'unda geçici obje var mı?
  [ ] FikoSahne.ts - render loop'unda any new() cagırısı var mı?
  [ ] FikoEtiketler.ts - CSS2D update'de DOM thrashing var mı?

Arac: Chrome DevTools Allocation Timeline + Memory profiler
Hedef: render loop basına 0 allokasyon (GC pause = 0ms)
```

**Olculebilir Hedef:** Chrome DevTools'ta 60 saniyelik profil'de render loop icinde 0 minor GC.

#### D.1.3 Geometry Merging / Batching Genisletme (3 gun)

**Problem:** FikoBatchedMeshManager var ama sadece import sırasında calısiyor. Statik assembly parcaları runtime'da tek draw call'a merge edilmiyor.

**Cozum:**
```
Dosya: fiko-performance/FikoBatchedMeshManager.ts (GUNCELLE)

Eklenti:
  - mergeStaticGeometry(objects: Mesh[]): BatchedMesh
  - Material atlas olusturma (ayni material'li parcaları birlestir)
  - Bounding box pre-compute (merge sonrası BVH yenileme)
  - Draw call sayacı: hedef <50 draw call (1000 part assembly)

Kural: Sadece statik (hareket etmeyen) parcalar merge edilir.
       Secilmis/hareket eden parcalar merge'den cikarilir.
```

**Olculebilir Hedef:** 500 part assembly'de draw call sayısı 500 -> <50. GPU overhead %80 azalma.

#### D.1.4 Frustum Culling Optimizasyonu (2 gun)

**Problem:** FikoRaycastBVH grid-based spatial partitioning kullanıyor. Buyuk sahnelerde grid hucresi sayısı patlıyor.

**Cozum:**
```
Dosya: fiko-performance/FikoRaycastBVH.ts (GUNCELLE)
       fiko-performance/FikoHiZOcclusionCulling.ts (GUNCELLE)

Iyilestirmeler:
  1. Octree-based spatial partitioning (grid yerine)
  2. Hi-Z occlusion culling'i varsayılan yap (mevcut ama opsiyonel)
  3. WASM frustum culler entegrasyonu (SimdFrustumCuller zaten var, baglantı eksik)
  4. Temporal coherence: onceki frame'in visible set'ini baslangıc noktası yap

Entegrasyon:
  - SimdFrustumCuller (Rust WASM) -> FikoRaycastBVH.frustumCull() icinde cagir
  - 1M obje icin hedef: <5ms frustum cull (mevcut ~50ms CPU)
```

**Olculebilir Hedef:** 1M obje sahnede frustum cull suresi 50ms -> <5ms (WASM SIMD).

#### D.1.5 Texture/Material Birlestirme (2 gun)

**Problem:** Her parca icin ayrı material instance olusturuluyor. GPU state change maliyeti yuksek.

**Cozum:**
```
Dosya: FikoCADMaterial.ts (GUNCELLE)

Material Pool:
  - Renk + roughness + metalness hash'ine gore material cache
  - Ayni parametreli material'leri paylastir (reference counting)
  - CAD modellerde genellikle 5-10 unique material var, 1000 degil
  - Material atlas: kucuk texture'ları tek buyuk texture'a birlestir
```

**Olculebilir Hedef:** 500 part assembly'de unique material sayısı 500 -> <20. GPU state switch %95 azalma.

---

### FAZ 2: CORE UPGRADES (1 Ay)

**Risk:** Orta | **Etki:** Yuksek | **Breaking Change:** Internal API degisiklik (disarı yansımaz)

#### D.2.1 WASM Motor Genisletme (2 hafta)

**Mevcut Durum:** 8.454 satır Rust. Thickness, edge, frustum, surface, section cutting, STP parse, dokum CPU.

**Genisletme Planı:**

```rust
// Yeni moduller (hedef: 25K+ satır)

// 1. mesh_boolean.rs (~2000 satır)
// CSG islemleri: union, intersect, subtract
// Kullanım: Kesit gorunumu, interference check
pub fn mesh_boolean_union(mesh_a: &[f32], mesh_b: &[f32]) -> Vec<f32>;
pub fn mesh_boolean_subtract(mesh_a: &[f32], mesh_b: &[f32]) -> Vec<f32>;

// 2. tessellation.rs (~1500 satır)
// NURBS -> Triangle tessellation (occt-import-js yedegi)
// Adaptive tessellation: duz yuzeyler az triangle, egriler cok
pub fn tessellate_nurbs(
  control_points: &[f32], knots_u: &[f32], knots_v: &[f32],
  degree_u: u32, degree_v: u32, tolerance: f32
) -> Vec<f32>;

// 3. mesh_simplification.rs (~1500 satır)
// QEM (Quadric Error Metrics) mesh decimation
// GPU LOD'un CPU fallback'i ve ilk LOD seviyesi ureticisi
pub fn simplify_mesh(
  vertices: &[f32], indices: &[u32],
  target_ratio: f32, preserve_boundaries: bool
) -> (Vec<f32>, Vec<u32>);

// 4. bvh_builder.rs (~1000 satır)
// SAH (Surface Area Heuristic) BVH agac kurulumu
// JS'deki FikoRaycastBVH icin hızlı BVH build
pub fn build_bvh_sah(
  aabbs: &[f32], // 6 floats per AABB
  max_leaf_size: u32
) -> Vec<u32>; // flattened node array

// 5. point_cloud.rs (~800 satır)
// Nokta bulutu islemleri: voxel downsampling, normal estimation
pub fn voxel_downsample(points: &[f32], voxel_size: f32) -> Vec<f32>;
pub fn estimate_normals(points: &[f32], k_neighbors: u32) -> Vec<f32>;

// 6. measurement.rs (~600 satır)
// Hassas olcum: min distance, angle, curve length
pub fn min_distance_mesh_mesh(mesh_a: &[f32], mesh_b: &[f32]) -> f64;
pub fn measure_angle(v1: &[f32], v2: &[f32], origin: &[f32]) -> f64;
```

**Build Süreci:** Mevcut `build.sh` pipeline'ına eklenir. Toplam WASM boyutu hedef: <300KB (wasm-opt ile).

#### D.2.2 Unified Worker Pipeline (1 hafta)

**Problem:** 3 ayrı worker pool (FikoWorkerPool, FikoComlinkWorkerPool, geometry worker) koordinasyonsuz calısiyor.

**Cozum:**
```
Dosya: fiko-performance/FikoUnifiedWorkerPipeline.ts (YENi)

Mimari:
  ┌─────────────────────────────────────────┐
  │         FikoUnifiedWorkerPipeline        │
  │                                          │
  │  ┌──────────┐ ┌──────────┐ ┌─────────┐ │
  │  │ Import   │ │ Compute  │ │ Render  │ │
  │  │ Workers  │ │ Workers  │ │ Workers │ │
  │  │ (STEP)   │ │ (BVH,    │ │ (LOD,   │ │
  │  │          │ │  Mesh)   │ │  Atlas) │ │
  │  └──────────┘ └──────────┘ └─────────┘ │
  │        ↕ SharedArrayBuffer ↕            │
  │  ┌──────────────────────────────────┐   │
  │  │     Shared Memory Manager        │   │
  │  │  (Geometry buffer, BVH tree,     │   │
  │  │   LOD levels, Index data)        │   │
  │  └──────────────────────────────────┘   │
  └─────────────────────────────────────────┘

Ozellikler:
  - navigator.hardwareConcurrency'ye gore worker sayısı (default: 4)
  - Task priority queue (import > compute > render)
  - SharedArrayBuffer ile zero-copy veri paylasımı
  - Transferable objects (ArrayBuffer ownership transfer)
  - Worker ısınma (idle worker'ı onceden WASM yukle)
  - Graceful degradation (SAB yoksa postMessage fallback)

SAB Gereksinimleri (HTTP header):
  Cross-Origin-Opener-Policy: same-origin
  Cross-Origin-Embedder-Policy: require-corp
```

**Olculebilir Hedef:** STEP import suresi %30 azalma (paralel mesh isleme). Worker kurulum suresi <100ms (pre-warm).

#### D.2.3 Streaming STEP Import (1 hafta)

**Problem:** 50MB STEP dosyası tamamen yuklenmeden parse baslamıyor. Kullanıcı uzun sure bekliyor.

**Cozum:**
```
Dosya: FikoImporter.STP.ts (GUNCELLE)
       fiko-performance/FikoStreamingImporter.ts (YENi)

Pipeline:
  1. fetch() ile ReadableStream al
  2. Her 1MB chunk'ı worker'a gonder
  3. Worker: STEP entity'leri incremental parse et
  4. Tamamlanan entity'leri hemen tessellate et
  5. Sahneye progressive render (parcalar birer birer gorunur)

Kullanıcı Deneyimi:
  - Ilk parca <2s icinde gorunur (50MB dosyada bile)
  - Progress bar: "145/500 parca yuklendi"
  - Iptal butonu (streaming durdurulabilir)
  - Oncelik: gorunen parcalar once tessellate edilir (frustum-based)

Teknik:
  - TextDecoder ile streaming UTF-8 decode
  - STEP entity sınırları: ";" ile biter, "#" ile baslar
  - Partial entity buffer: chunk sınırında kalan entity'leri birlestir
```

**Olculebilir Hedef:** 50MB STEP dosyasında ilk parca gorunme suresi: <2s (mevcut: tum dosya yuklenmeli ~20s).

#### D.2.4 Bellek Butcesi Yonetimi (3 gun)

**Problem:** GPU VRAM ve JS heap icin sabit limit yok. Buyuk modellerde tarayıcı crash olabiliyor.

**Cozum:**
```
Dosya: fiko-performance/FikoMemoryBudget.ts (YENi)

class FikoMemoryBudget {
  // Sabit limitler
  static JS_HEAP_BUDGET = 1024; // MB
  static GPU_VRAM_BUDGET = 1536; // MB

  // Dinamik izleme
  getJSHeapUsage(): number  // performance.memory.usedJSHeapSize
  getGPUVRAMEstimate(): number  // texture + geometry buffer toplam

  // Butce asılınca
  onBudgetExceeded(callback: () => void): void

  // Otomatik aksiyon
  autoEvict(): void {
    // 1. En uzak LOD'ları dusur
    // 2. Gorulmeyen geometry'leri dispose et
    // 3. Texture mipmap'leri dusur
    // 4. Edge geometry'leri kaldir (hover'da yeniden olustur)
  }

  // Rapor
  getMemoryReport(): {
    jsHeapMB: number,
    gpuVramMB: number,
    geometryCount: number,
    textureCount: number,
    bufferCount: number,
    largestObjects: { name: string, sizeMB: number }[]
  }
}
```

**Olculebilir Hedef:** 1M triangle model'de JS heap <1GB, GPU VRAM <1.5GB. Tarayıcı crash oranı: 0.

---

### FAZ 3: GPU PIPELINE (2 Ay)

**Risk:** Yuksek | **Etki:** Cok Yuksek | **Breaking Change:** Renderer degisiklik (abstraction ile gizlenir)

#### D.3.1 Three.js WebGPU Renderer Gecisi (3 hafta)

**Mevcut Durum:** Three.js 0.177 WebGL2 renderer kullanılıyor. FikoWebGPU.ts ve FikoWebGPURaycast.ts mevcut ama rendering degil, sadece compute icin.

**Strateji: Progressif Gecis (Buyuk Patlama Degil)**

```
Hafta 1: Renderer Abstraction Layer
  Dosya: fiko-performance/FikoRendererAbstraction.ts (YENi)

  interface IFikoRenderer {
    init(canvas: HTMLCanvasElement, options: RendererOptions): Promise<void>
    render(scene: Scene, camera: Camera): void
    dispose(): void
    getCapabilities(): RendererCapabilities
    isWebGPU(): boolean
  }

  class FikoWebGL2Renderer implements IFikoRenderer { ... }  // Mevcut wrap
  class FikoWebGPURendererAdapter implements IFikoRenderer { ... }  // Three.js WebGPU

  // Factory: Tarayıcı destegine gore sec
  function createRenderer(canvas): IFikoRenderer {
    if (navigator.gpu && prefersWebGPU) return new FikoWebGPURendererAdapter(canvas);
    return new FikoWebGL2Renderer(canvas);
  }

Hafta 2-3: Three.js WebGPU Renderer Entegrasyon
  - three/examples/jsm/renderers/webgpu/WebGPURenderer import
  - Material migration: MeshStandardMaterial -> NodeMaterial (shader graph)
  - Mevcut custom shader'ları (Gooch, Toon, Hatching) TSL'ye (Three Shading Language) port et
  - Postprocessing pipeline: EffectComposer -> WebGPU pass manager

  Fallback: WebGPU destegi yoksa otomatik WebGL2'ye doner
  Feature flag: localStorage.setItem('fikoyt_renderer', 'webgpu' | 'webgl2')
```

**Dikkat Noktaları:**
- Three.js WebGPU renderer hala development'ta (r177'de experimental)
- Custom ShaderMaterial'ler TSL'ye donusturulmeli
- EffectComposer postprocessing chain'i yeniden yazılmalı
- Line2/LineMaterial WebGPU uyumlulugu kontrol edilmeli

**Olculebilir Hedef:** WebGPU renderer ile ayni sahne %20-30 daha hızlı render. Multi-draw-indirect ile draw call overhead sıfıra yakin.

#### D.3.2 GPU-Driven Rendering Pipeline (3 hafta)

**Problem:** CPU her frame'de ne cizilecegini belirliyor (CPU-bound). GPU bos bekliyor.

**Cozum:**
```
Dosya: fiko-performance/FikoGPUDrivenPipeline.ts (YENi)

GPU-Driven Rendering:
  1. Tum mesh instance verileri GPU buffer'da
  2. Compute shader: frustum cull + LOD select + sort
  3. Indirect draw: GPU kendi cizim komutlarını olusturur
  4. CPU sadece kamera matrisini gonderir

Pipeline:
  CPU (her frame):
    - Kamera matrisi upload (64 byte)
    - Dispatch compute shader
    - 0 draw call (GPU indirect draw)

  GPU Compute Shader (WGSL):
    @compute @workgroup_size(256)
    fn cull_and_lod(
      @builtin(global_invocation_id) id: vec3<u32>
    ) {
      let instance = instances[id.x];
      let mvp = camera.viewProj * instance.model;

      // Frustum cull
      if (!frustum_test(instance.bounds, mvp)) { return; }

      // LOD select
      let screen_size = compute_screen_size(instance.bounds, mvp);
      let lod = select_lod(screen_size);

      // Indirect draw command append
      let cmd_idx = atomicAdd(&draw_count, 1);
      draw_commands[cmd_idx] = DrawIndirectCommand {
        vertex_count: lod_vertex_counts[lod],
        instance_count: 1,
        first_vertex: lod_offsets[lod],
        first_instance: id.x
      };
    }

Beklenen Kazanım:
  - 1000 part: CPU frame time 5ms -> 0.1ms
  - Draw call: 1000 -> 1 (multi-draw-indirect)
  - Frustum cull: GPU'da 0.1ms (CPU'da 5ms)
```

**Olculebilir Hedef:** 1000 part assembly'de CPU frame time <0.5ms. Render pipeline tamamen GPU-bound.

#### D.3.3 Compute Shader Pipeline Genisletme (2 hafta)

**Mevcut:** FikoGPUComputeUltra, FikoWebGPU, SPH shader'ları.

**Genisletme:**
```
Yeni Compute Shader'lar:

1. mesh-simplification.wgsl
   - GPU-parallel QEM decimation
   - Vertex importance hesabi (curvature-based)
   - LOD mesh olusturma GPU'da (CPU'dan 50x hızlı)

2. bvh-update.wgsl
   - Hareket eden parcalar icin BVH incremental update
   - Full rebuild yerine local refit (10x hızlı)

3. edge-detection-compute.wgsl
   - Dihedral angle hesabi GPU'da
   - Feature edge extraction (sharp, boundary, crease)
   - Mevcut SimdEdgeDetector'un GPU versiyonu

4. measurement-compute.wgsl
   - Min distance (mesh-mesh, point-mesh)
   - GPU parallel BVH traversal
   - Sonuc: <1ms (CPU'da 50ms)

5. section-plane-compute.wgsl
   - Kesit duzlemi mesh intersection
   - Gercek zamanlı kesit gorunumu (slider ile)
   - Mevcut section_cutting.rs'nin GPU versiyonu
```

**Olculebilir Hedef:** Kesit gorunumu guncelleme <2ms (mevcut ~50ms CPU). LOD olusturma <5ms (mevcut ~200ms GPU, ~2s CPU).

#### D.3.4 WebGPU Render-to-Texture Pipeline (1 hafta)

**Problem:** GPU picking hala color buffer readback kullanıyor (GPU stall).

**Cozum:**
```
Dosya: fiko-performance/FikoGPUPicker.ts (GUNCELLE)

Mevcut: readPixels() -> GPU-CPU sync stall (1-5ms)
Yeni: Compute shader + storage buffer -> async readback (0 stall)

Pipeline:
  1. Render pass: Her obje unique ID ile render (mevcut)
  2. Compute pass: Mouse pozisyonundaki pixel'i oku (YENi)
  3. Async buffer map: mapAsync() ile sonraki frame'de oku
  4. 1 frame latency ama 0 stall

Fallback: Eski readPixels (WebGPU yoksa)
```

**Olculebilir Hedef:** GPU picking stall suresi 5ms -> 0ms (1 frame latency ile).

---

### FAZ 4: SiMULASYON (3 Ay)

**Risk:** Yuksek | **Etki:** Rekabet avantajı | **Breaking Change:** Yok (yeni modul)

#### D.4.1 Dokum Simulasyonu Uretim Hazırlıgı (6 hafta)

**Mevcut Durum:**
- Thermal CPU (Fourier): Rust WASM'da, calısiyor
- LBM Flow (D3Q19): Rust WASM'da, calısiyor
- Niyama Kriteri: Rust WASM'da, calısiyor
- SPH: TypeScript + WebGPU WGSL shader'ları, prototip

**Hedef Mimari:**
```
┌───────────────────────────────────────────────────┐
│              DOKUM SiMULASYON MOTORU               │
│                                                    │
│  ┌────────────┐  ┌────────────┐  ┌─────────────┐ │
│  │ Voksel     │  │ Sınır      │  │ Malzeme     │ │
│  │ Grid       │  │ Kosulları  │  │ Veritabanı  │ │
│  │ Yonetimi   │  │ Yonetimi   │  │             │ │
│  └────────────┘  └────────────┘  └─────────────┘ │
│        │               │               │          │
│  ┌─────────────────────────────────────────────┐  │
│  │          Compute Dispatcher                  │  │
│  │  WebGPU (birincil) | WASM CPU (yedek)       │  │
│  └─────────────────────────────────────────────┘  │
│        │               │               │          │
│  ┌────────────┐  ┌────────────┐  ┌─────────────┐ │
│  │ Termal     │  │ Akıs       │  │ Katılasma   │ │
│  │ Solver     │  │ Solver     │  │ Analiz      │  │
│  │ (Fourier)  │  │ (LBM/SPH) │  │ (Niyama)    │ │
│  └────────────┘  └────────────┘  └─────────────┘ │
│                                                    │
│  ┌─────────────────────────────────────────────┐  │
│  │     Gorsellestirme (Volume Rendering)       │  │
│  │  Isı haritası | Akıs vektorleri | Curuma    │  │
│  └─────────────────────────────────────────────┘  │
└───────────────────────────────────────────────────┘
```

**Uygulama Adımları:**

```
Hafta 1-2: Voksel Grid Yonetimi
  Dosya: fiko-similasyon/FikoDokumGrid.ts (YENi)

  - CAD mesh -> voksel grid donusumu (GPU compute)
  - Adaptive grid: ince duvarlarda yuksek cozunurluk
  - Malzeme atama: metal, kalıp, yolluk, sogutucu
  - Grid boyutları: 64^3 (hızlı), 128^3 (orta), 256^3 (detaylı)
  - Bellek: 64^3 = 262K voksel x 32 byte = 8MB
            128^3 = 2M voksel x 32 byte = 64MB
            256^3 = 16M voksel x 32 byte = 512MB

Hafta 3-4: GPU Solver Entegrasyonu
  Dosya: fiko-similasyon/FikoDokumGPUSolver.ts (YENi)

  WebGPU Compute Shader'lar:
  - dokum-thermal.wgsl: Isı iletimi (6-komsulu Laplacian)
  - dokum-lbm.wgsl: D3Q19 LBM akıs (BGK collision + streaming)
  - dokum-solidification.wgsl: Katılasma (latent heat + solid fraction)
  - dokum-niyama.wgsl: Niyama curuma kriteri

  CPU Fallback: Mevcut Rust WASM fonksiyonları (thermal_step_cpu, lbm_step_cpu)

  Performans Hedefi:
    64^3 grid: GPU <50ms/step, CPU (WASM) <500ms/step
    128^3 grid: GPU <200ms/step, CPU: cok yavas (uyarı goster)

Hafta 5-6: Gorsellestirme
  Dosya: fiko-similasyon/FikoDokumRenderer.ts (YENi)

  - Volume rendering (ray marching shader)
  - Isı haritası renk skalası (mavi-kırmızı)
  - Akıs vektorleri (arrow glyph instancing)
  - Katılasma front animasyonu
  - Curuma bolgesi highlight (Niyama < 1.0)
  - Kesit gorunumu (XY/XZ/YZ duzlemleri)
  - Zaman slider'ı (simulasyon adımları arası gecis)
```

**Olculebilir Hedef:** 64^3 grid'de 100 adım simulasyon <5 saniye (GPU). Gorsellestirme 60 FPS.

#### D.4.2 Termal Analiz (2 hafta)

```
Kullanıcı Akısı:
  1. CAD model yukle
  2. Malzeme ata (dokum celigi, aluminyum, pirinc...)
  3. Kalıp malzemesi sec (kum, metal kalıp, seramik)
  4. Dokum sıcaklıgı gir
  5. Sogutucu/riser yerlestir
  6. Simulasyonu baslat
  7. Sonuclari incele:
     - Isı dagılımı animasyonu
     - Son katılasan bolge (riser boyutlandırma)
     - Curuma riski haritası
     - Gecis suresi raporu

Malzeme Veritabanı:
  interface DokumMalzeme {
    isim: string;                // "GG25 Dokme Demir"
    isiIletkenlik: number;       // W/mK
    ozgulIsi: number;            // J/kgK
    yogunluk: number;            // kg/m3
    erimeSicakligi: number;      // C (solidus)
    donmeSicakligi: number;      // C (liquidus)
    gizliIsi: number;            // J/kg
    renk: string;                // "#B87333"
  }

  // On tanımlı malzemeler: GG25, GGG40, AlSi7Mg, CuZn, St37
```

#### D.4.3 Akıs Simulasyonu (4 hafta)

**Mevcut LBM + SPH altyapısını birlestirme:**

```
Strateji: LBM birincil (bulk flow), SPH ikincil (splash/surface)

LBM Avantajları:
  - GPU'ya cok uygun (regular grid)
  - Dusuk viskoziteli akıslar icin stabil
  - Buyuk hacimler icin verimli

SPH Avantajları:
  - Serbest yuzey takibi
  - Splash/fragmentation
  - Kucuk olcekli detaylar

Hibrit Yaklasım:
  1. Dolum: LBM (bulk) + fill fraction tracking
  2. Yuzey: SPH parcacıkları (estetik gorsellestirme)
  3. Hava kapanı: LBM voxel'lerde hava takibi
  4. Turbulans: LBM LES modeli
```

---

### FAZ 5: POLISH & BENCHMARK (1 Ay)

**Risk:** Dusuk | **Etki:** Uzun vadeli kalite | **Breaking Change:** Yok

#### D.5.1 Otomatik Performans Benchmark Suite (1 hafta)

```
Dosya: scripts/benchmark/ (YENi KLASOR)

benchmark-runner.ts:
  - Playwright ile headless Chrome/Edge aç
  - Test modellerini sırayla yukle
  - Her model icin olc:
    * Ilk render suresi (DOMContentLoaded -> ilk frame)
    * 60 saniyelik ortalama FPS
    * JS heap peak
    * GPU VRAM (WebGPU API veya tahmin)
    * Secim yanıt suresi (sentetik click event)
    * STEP import suresi
  - JSON rapor cıktısı
  - Onceki sonuclarla karsilastir (regression tespiti)
  - %10'dan fazla gerileme -> CI fail

benchmark-models/:
  - simple-part.stp (5K tri)
  - medium-assembly.stp (50K tri)
  - large-assembly.stp (200K tri)
  - stress-test.stp (1M tri) [opsiyonel, CI'da skip]
```

**Olculebilir Hedef:** Her PR'da otomatik performans raporu. Regression %10'dan fazla ise merge engellenir.

#### D.5.2 Profiling Dashboard (3 gun)

```
Dosya: fiko-performance/fiko-performance-monitor.component.ts (GUNCELLE)

Mevcut HUD'a Eklentiler:
  - Flame chart: Frame icinde hangi islem ne kadar suruyor
  - GPU timeline: Draw call, compute dispatch, buffer transfer
  - Memory trend: Son 60 frame'in heap/VRAM grafigi
  - Bottleneck detector: "GPU-bound" / "CPU-bound" / "Memory-bound" etiketi
  - Export: JSON olarak kaydet (destek talebi icin)
```

#### D.5.3 Kullanıcı Deneyimi Ince Ayar (1 hafta)

```
Progressive Enhancement:
  1. Ilk yukleme: Dusuk LOD + wireframe (anında gorunum)
  2. 2. pass: Orta LOD + basic shading
  3. 3. pass: Full LOD + shadows + AO
  4. Arka plan: Edge hesaplama, BVH kurulumu

Algılanan Performans:
  - Skeleton loading (model yukleniyor animasyonu)
  - Parcalar birer birer belirme animasyonu
  - Progress indicator (STEP import %)
  - "Yuksek performans modu" toggle (shadow, AO, edge kapatır)
```

#### D.5.4 Tarayıcı Uyumluluk Matrix (2 gun)

```
Test Matrix:
  ┌──────────────┬────────┬────────┬────────┬────────┐
  │              │ Chrome │ Edge   │ Firefox│ Safari │
  ├──────────────┼────────┼────────┼────────┼────────┤
  │ WebGL2       │   ✓    │   ✓    │   ✓    │   ✓    │
  │ WebGPU       │   ✓    │   ✓    │  flag  │  ✓*    │
  │ WASM SIMD    │   ✓    │   ✓    │   ✓    │   ✓    │
  │ SAB          │   ✓    │   ✓    │   ✓    │   ✓    │
  │ OffscreenCnv │   ✓    │   ✓    │   ✓    │   ✗    │
  └──────────────┴────────┴────────┴────────┴────────┘
  * Safari WebGPU: 17.4+ (sınırlı)

Fallback Zinciri:
  WebGPU Compute → WebGL2 Transform Feedback → WASM SIMD → JS CPU
  WebGPU Render  → WebGL2 Render (Three.js otomatik)
  SAB Workers    → postMessage Workers (kopyalama ile)
  OffscreenCanvas → Main thread render
```

---

## E. RiSK ANALiZi

### E.1 Teknik Riskler

| Risk | Olasılık | Etki | Onlem |
|------|----------|------|-------|
| WebGPU API degisikligi (Three.js r178+) | Orta | Yuksek | Renderer abstraction layer, version pinning |
| WASM boyut sismesi (>500KB) | Dusuk | Orta | wasm-opt aggressive, code splitting, lazy load |
| SAB COOP/COEP header gerekliligi | Kesin | Dusuk | Server header'ları zaten ayarlanmis, test et |
| GPU bellek tasması (2GB+ VRAM) | Orta | Yuksek | Memory budget sistemi, otomatik LOD dusurme |
| Three.js WebGPU renderer bug'ları | Yuksek | Orta | WebGL2 fallback her zaman calısır durumda tut |
| Dokum simulasyonu numerik instabilite | Orta | Yuksek | CFL condition check, adaptive time step |
| Worker deadlock (SAB + atomics) | Dusuk | Yuksek | Timeout mekanizması, watchdog thread |

### E.2 Performans Regression Riskleri

| Senaryo | Onlem |
|---------|-------|
| LOD konsolidasyonu sırasında frame drop | A/B test: eski LOD ve yeni LOD paralel calistir, performans karsilastir |
| WebGPU renderer gecisinde shader hataları | Feature flag ile kademeli rollout, %10 kullanıcıda test |
| WASM boyut artısı ilk yukleme yavaslatır | Code splitting: core WASM (100KB) + simulation WASM (200KB) lazy load |
| Worker pipeline overhead (mesajlasma maliyeti) | Benchmark: postMessage vs SAB. SAB 10x hızlıysa SAB kullan |

### E.3 Breaking Change Yonetimi

```
Kural: Hicbir faz disarıya (component API) breaking change yaratmaz.

Strateji:
  1. Adapter/Facade pattern: Ic degisiklikler disarıya yansımaz
  2. Feature flag: Yeni ozellikler flag arkasında baslar
  3. Deprecation cycle: Eski API 1 faz boyunca calısır, sonra kalkar
  4. Integration test: Her faz sonunda tum CAD islemleri test et
     - Model yukle ✓
     - Parca sec ✓
     - Olcum al ✓
     - Kesit gorunumu ✓
     - Annotation ekle ✓
     - PDF export ✓
```

---

## F. ZAMAN CiZELGESi

```
2026 Mart    Nisan       Mayıs       Haziran     Temmuz      Agustos     Eylul-Kasım
─────────────────────────────────────────────────────────────────────────────────────
FAZ 1        FAZ 2                   FAZ 3                               FAZ 5
[2 hafta]    [1 ay]                  [2 ay]                              [1 ay]
LOD konsol.  WASM genislet           WebGPU renderer                     Benchmark
Alloc audit  Worker pipeline         GPU-driven pipeline                 Profiling
Batching     Streaming import        Compute shader genislet             UX polish
Frustum opt  Memory budget           GPU picking upgrade                 Uyumluluk
Material                                                     FAZ 4
                                                             [3 ay]
                                                             Dokum sim
                                                             Termal
                                                             Akıs sim
                                                             Gorsellestirme
```

**Not:** Faz 4 (Simulasyon) Faz 3 ile paralel baslar. Simulasyon GPU compute altyapısı Faz 3'e bagımlı.

---

## G. BASARI KRiTERLERi

### Faz 1 Tamamlanma Kriterleri
- [ ] Tek LOD API'si calısiyor, 1M tri sahnede 45+ FPS
- [ ] Render loop'ta 0 GC pause (60s profil)
- [ ] 500 part assembly'de <50 draw call
- [ ] WASM frustum cull entegre, <5ms
- [ ] Material pool aktif, <20 unique material

### Faz 2 Tamamlanma Kriterleri
- [ ] WASM'da mesh simplification + BVH builder calısiyor
- [ ] Unified worker pipeline, STEP import %30 hızlı
- [ ] 50MB STEP'te ilk parca <2s gorunuyor (streaming)
- [ ] Memory budget sistemi aktif, crash oranı 0

### Faz 3 Tamamlanma Kriterleri
- [ ] WebGPU renderer calısiyor (feature flag ile)
- [ ] GPU-driven pipeline: 1000 part CPU frame time <0.5ms
- [ ] GPU picking 0 stall (async readback)
- [ ] Kesit gorunumu GPU compute <2ms

### Faz 4 Tamamlanma Kriterleri
- [ ] 64^3 grid termal simulasyon GPU <50ms/step
- [ ] LBM akıs simulasyonu calısiyor
- [ ] Niyama curuma analizi gorsellestirme tamam
- [ ] 5 malzeme icin veritabanı tamam

### Faz 5 Tamamlanma Kriterleri
- [ ] Otomatik benchmark suite CI'da calısiyor
- [ ] Profiling dashboard tum metrikleri gosteriyor
- [ ] Progressive loading UX tamam
- [ ] 4 tarayıcıda tum ozellikler test edildi

---

## H. DOSYA HARiTASI (Mevcut -> Hedef)

```
src/service/fikoyt-ui/src/lib/fiko-three-js/
├── IFikoThreeJS/
│   ├── fiko-performance/
│   │   ├── FikoUnifiedLOD.ts              [YENi - Faz 1]
│   │   ├── FikoMemoryBudget.ts            [YENi - Faz 2]
│   │   ├── FikoUnifiedWorkerPipeline.ts   [YENi - Faz 2]
│   │   ├── FikoStreamingImporter.ts       [YENi - Faz 2]
│   │   ├── FikoRendererAbstraction.ts     [YENi - Faz 3]
│   │   ├── FikoGPUDrivenPipeline.ts       [YENi - Faz 3]
│   │   ├── FikoAdvancedLOD.ts             [GUNCELLE - Faz 1]
│   │   ├── FikoRaycastBVH.ts              [GUNCELLE - Faz 1]
│   │   ├── FikoBatchedMeshManager.ts      [GUNCELLE - Faz 1]
│   │   ├── FikoGPUPicker.ts               [GUNCELLE - Faz 3]
│   │   ├── FikoGPUSelection.ts            [GUNCELLE - Faz 1]
│   │   ├── FikoWasmBridge.ts              [GUNCELLE - Faz 2]
│   │   └── ... (mevcut dosyalar korunur)
│   ├── fiko-similasyon/
│   │   ├── FikoDokumGrid.ts               [YENi - Faz 4]
│   │   ├── FikoDokumGPUSolver.ts          [YENi - Faz 4]
│   │   ├── FikoDokumRenderer.ts           [YENi - Faz 4]
│   │   └── ... (mevcut dosyalar korunur)
│   ├── FikoCADMaterial.ts                 [GUNCELLE - Faz 1]
│   ├── FikoImporter.STP.ts               [GUNCELLE - Faz 2]
│   └── FikoSecililer.ts                   [GUNCELLE - Faz 1]
│
fikoyt-wasm/src/
├── mesh_boolean.rs                        [YENi - Faz 2]
├── tessellation.rs                        [YENi - Faz 2]
├── mesh_simplification.rs                 [YENi - Faz 2]
├── bvh_builder.rs                         [YENi - Faz 2]
├── point_cloud.rs                         [YENi - Faz 2]
├── measurement.rs                         [YENi - Faz 2]
├── lib.rs                                 [GUNCELLE - Faz 2]
└── ... (mevcut dosyalar korunur)

scripts/benchmark/                          [YENi - Faz 5]
├── benchmark-runner.ts
├── benchmark-report.ts
└── models/ (test STEP dosyaları)
```

---

## I. SONUC

Bu plan 537 TypeScript dosyası, 12 Rust dosyası ve 17+ WebGPU shader'dan olusan mevcut FikoYT 3D CAD motorunu endustri seviyesine tasımayı hedefler. 5 faz, 9 aylık surecte:

- **Faz 1** mevcut kodda dusuk riskli %30-50 performans artısı saglar
- **Faz 2** WASM ve worker altyapısını guclendirerek temel kapasiteyi artırır
- **Faz 3** WebGPU ile nesil atlayarak GPU-driven rendering'e gecer
- **Faz 4** dokum simulasyonu ile rekabet avantajı olusturur
- **Faz 5** surekli kalite ve performans izleme altyapısı kurar

Her fazın somut, olculebilir basarı kriterleri vardır. Her faz bagimsız olarak deger uretir - herhangi bir noktada plan durdurulsa bile o ana kadar yapılan iyilestirmeler kaybolmaz.