gizmo_renderer/
renderer.rs

1use std::sync::Arc;
2use wgpu::{util::DeviceExt, Device, Queue, Surface, SurfaceConfiguration};
3use winit::window::Window;
4
5pub use crate::gpu_types::{
6    InstanceRaw, LightData, PostProcessUniforms, SceneUniforms, ShadowVsUniform, Vertex,
7};
8pub use crate::pipeline::SceneState;
9pub use crate::post_process::PostProcessState;
10
11// ============================================================
12//  RenderContext — wgpu detaylarını kullanıcıdan gizler
13// ============================================================
14
15/// Kullanıcı kodunun doğrudan `wgpu::CommandEncoder` veya `wgpu::TextureView`
16/// görmesine gerek kalmadan render işlemi yapmasını sağlayan bağlam nesnesi.
17///
18/// ```ignore
19/// fn render(world: &mut World, _state: &GameState, ctx: &mut RenderContext) {
20///     ctx.disable_gpu_compute();           // GPU Compute kapalı
21///     ctx.default_render(world);           // Varsayılan render pipeline
22/// }
23/// ```
24pub struct RenderContext<'a> {
25    pub(crate) encoder: &'a mut wgpu::CommandEncoder,
26    pub(crate) view: &'a wgpu::TextureView,
27    pub(crate) renderer: &'a mut Renderer,
28    pub(crate) light_time: f32,
29}
30
31impl<'a> RenderContext<'a> {
32    /// Yeni bir RenderContext oluşturur (motor tarafından dahili olarak çağrılır).
33    pub fn new(
34        encoder: &'a mut wgpu::CommandEncoder,
35        view: &'a wgpu::TextureView,
36        renderer: &'a mut Renderer,
37        light_time: f32,
38    ) -> Self {
39        Self {
40            encoder,
41            view,
42            renderer,
43            light_time,
44        }
45    }
46
47    /// GPU Compute alt sistemlerini devre dışı bırakır (fluid, particles, physics).
48    /// Basit sahnelerde gereksiz GPU iş yükünü sıfırlar.
49    pub fn disable_gpu_compute(&mut self) {
50        self.renderer.gpu_fluid = None;
51        self.renderer.gpu_particles = None;
52        self.renderer.gpu_physics = None;
53    }
54
55    /// Mevcut sahne ışık zamanını döndürür (saniye).
56    pub fn light_time(&self) -> f32 {
57        self.light_time
58    }
59
60    /// Renderer'a doğrudan erişim (ileri düzey kullanım).
61    pub fn renderer(&self) -> &Renderer {
62        self.renderer
63    }
64
65    /// Renderer'a mutable erişim (ileri düzey kullanım).
66    pub fn renderer_mut(&mut self) -> &mut Renderer {
67        self.renderer
68    }
69
70    /// İleri düzey kullanım: ham wgpu encoder'a erişim.
71    pub fn encoder(&mut self) -> &mut wgpu::CommandEncoder {
72        self.encoder
73    }
74
75    /// İleri düzey kullanım: çıkış texture view'ına erişim.
76    pub fn output_view(&self) -> &wgpu::TextureView {
77        self.view
78    }
79
80    /// Dahili bileşenlere eşzamanlı erişim — `default_render_pass` gibi
81    /// fonksiyonlara geçirmek için kullanılır.
82    pub fn parts_mut(&mut self) -> (&mut wgpu::CommandEncoder, &wgpu::TextureView, &mut Renderer) {
83        (self.encoder, self.view, self.renderer)
84    }
85}
86
87pub struct Renderer {
88    // === TEMEL WGPU KAYNAKLARI ===
89    pub surface: Surface<'static>,
90    pub device: Device,
91    pub queue: Queue,
92    pub config: SurfaceConfiguration,
93    pub size: winit::dpi::PhysicalSize<u32>,
94    pub depth_texture_view: wgpu::TextureView,
95
96    // === SAHNE (Scene) — Pipeline'lar, Shadow, Skeleton ===
97    pub scene: SceneState,
98
99    // === POST-PROCESSING — HDR, Bloom, Blur, Composite ===
100    pub post: PostProcessState,
101
102    // === PARTİKÜL SİSTEMİ ===
103    pub gpu_particles: Option<crate::gpu_particles::GpuParticleSystem>,
104
105    pub gpu_physics: Option<crate::gpu_physics::GpuPhysicsSystem>,
106
107    // === GPU SIVI SİSTEMİ ===
108    pub gpu_fluid: Option<crate::gpu_fluid::GpuFluidSystem>,
109
110    // === DEFERRED RENDERING — G-Buffer + Lighting pass ===
111    pub deferred: Option<crate::deferred::DeferredState>,
112
113    // === GPU-DRIVEN MESH CULLING — Compute frustum cull + indirect draw ===
114    pub gpu_cull: Option<crate::gpu_cull::GpuCullState>,
115
116    // === SSAO — Screen-Space Ambient Occlusion ===
117    pub ssao: Option<crate::ssao::SsaoState>,
118
119    // === SSR — Screen-Space Reflections ===
120    pub ssr: Option<crate::ssr::SsrState>,
121
122    // === SSGI — Screen-Space Global Illumination ===
123    pub ssgi: Option<crate::ssgi::SsgiState>,
124
125    // === Volumetric Lighting (God Rays) ===
126    pub volumetric: Option<crate::volumetric::VolumetricState>,
127
128    // === DEFERRED DECALS ===
129    pub decal: Option<crate::decal::DecalState>,
130
131    // === TAA — Temporal Anti-Aliasing (ping-pong history + Halton jitter) ===
132    pub taa: Option<crate::taa::TaaState>,
133
134    // === FXAA — Fast Approximate Anti-Aliasing (son post-process pass) ===
135    pub fxaa: Option<crate::fxaa::FxaaState>,
136
137    // === GIZMO HATA AYIKLAMA (Debug Lines) ===
138    pub debug_renderer: Option<crate::debug_renderer::GizmoRendererSystem>,
139
140    // === DAHİLİ ASSET YÖNETİCİSİ (Kolaylık metodları için cache) ===
141    pub asset_manager: std::sync::RwLock<crate::asset::AssetManager>,
142
143    // === WEB PROFİLİ — Platform bazlı GPU kaynak yönetimi ===
144    pub web_profile: crate::web_profile::WebProfile,
145}
146
147impl Renderer {
148    pub fn load_shader(
149        device: &wgpu::Device,
150        file_path: &str,
151        fallback_src: &str,
152        label: &str,
153    ) -> wgpu::ShaderModule {
154        let source =
155            std::fs::read_to_string(file_path).unwrap_or_else(|_| fallback_src.to_string());
156        device.create_shader_module(wgpu::ShaderModuleDescriptor {
157            label: Some(label),
158            source: wgpu::ShaderSource::Wgsl(source.into()),
159        })
160    }
161
162    pub async fn new(window: Arc<Window>) -> Self {
163        let mut size = window.inner_size();
164        // WASM'da canvas boyutu 0x0 olabilir, en az 1x1 garanti et
165        if size.width == 0 || size.height == 0 {
166            size = winit::dpi::PhysicalSize::new(1280, 720);
167        }
168
169        #[cfg(target_arch = "wasm32")]
170        {
171            // Web'de 4K/Retina ekranlarda devasa çözünürlükler performansı katleder.
172            // Internal rendering çözünürlüğünü 1280x720'ye (veya aspect ratio'ya göre) caple.
173            if size.width > 640 || size.height > 360 {
174                let aspect = size.width as f32 / size.height as f32;
175                if aspect > 1.0 {
176                    size.width = 640;
177                    size.height = (640.0 / aspect) as u32;
178                } else {
179                    size.height = 360;
180                    size.width = (360.0 * aspect) as u32;
181                }
182            }
183        }
184
185        #[cfg(target_arch = "wasm32")]
186        let backends = wgpu::Backends::BROWSER_WEBGPU | wgpu::Backends::GL;
187        #[cfg(not(target_arch = "wasm32"))]
188        let backends = wgpu::Backends::all();
189
190        log::info!("[Renderer] Window size: {}x{}", size.width, size.height);
191        log::info!("[Renderer] Backends: {:?}", backends);
192
193        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
194            backends,
195            ..Default::default()
196        });
197
198        // Enumerate available adapters for diagnostic info
199        #[cfg(not(target_arch = "wasm32"))]
200        {
201            let adapters = instance.enumerate_adapters(backends);
202            log::info!("[Renderer] {} adapter bulundu", adapters.len());
203            for (i, a) in adapters.iter().enumerate() {
204                let info = a.get_info();
205                log::info!(
206                    "[Renderer]   Adapter {}: {} ({:?}, {:?})",
207                    i,
208                    info.name,
209                    info.backend,
210                    info.device_type
211                );
212            }
213        }
214
215        let surface = instance
216            .create_surface(window.clone())
217            .expect("Surface oluşturulamadı!");
218
219        log::info!("[Renderer] Surface oluşturuldu, adapter aranıyor...");
220
221        let adapter = instance
222            .request_adapter(&wgpu::RequestAdapterOptions {
223                power_preference: wgpu::PowerPreference::default(),
224                compatible_surface: Some(&surface),
225                force_fallback_adapter: false,
226            })
227            .await;
228
229        let adapter = match adapter {
230            Some(a) => {
231                let info = a.get_info();
232                log::info!(
233                    "[Renderer] Adapter bulundu: {} ({:?})",
234                    info.name,
235                    info.backend
236                );
237                a
238            }
239            None => {
240                log::warn!(
241                    "[Renderer] Surface uyumlu adapter bulunamadı, surface'siz deneniyor..."
242                );
243                // Surface'siz adapter dene
244                match instance
245                    .request_adapter(&wgpu::RequestAdapterOptions {
246                        power_preference: wgpu::PowerPreference::default(),
247                        compatible_surface: None,
248                        force_fallback_adapter: false,
249                    })
250                    .await
251                {
252                    Some(a) => {
253                        let info = a.get_info();
254                        log::info!(
255                            "[Renderer] Surface'siz adapter bulundu: {} ({:?})",
256                            info.name,
257                            info.backend
258                        );
259                        a
260                    }
261                    None => {
262                        log::error!(
263                            "[Renderer] Hiçbir adapter bulunamadı! Backends: {:?}",
264                            backends
265                        );
266                        panic!(
267                            "GPU adapter bulunamadı! Backends: {:?}, Window size: {}x{}",
268                            backends, size.width, size.height
269                        );
270                    }
271                }
272            }
273        };
274
275        #[cfg(not(target_arch = "wasm32"))]
276        let (device, queue) = adapter
277            .request_device(
278                &wgpu::DeviceDescriptor {
279                    required_features: wgpu::Features::POLYGON_MODE_LINE,
280                    required_limits: wgpu::Limits {
281                        max_bind_groups: 6,
282                        max_storage_buffers_per_shader_stage: 8,
283                        max_storage_buffer_binding_size: 256 << 20, // 256 MB buffer limit
284                        ..wgpu::Limits::default()
285                    },
286                    label: None,
287                },
288                None,
289            )
290            .await
291            .unwrap();
292
293        #[cfg(target_arch = "wasm32")]
294        let (device, queue) = adapter
295            .request_device(
296                &wgpu::DeviceDescriptor {
297                    required_features: wgpu::Features::empty(),
298                    required_limits: wgpu::Limits {
299                        max_bind_groups: 4,
300                        max_storage_buffers_per_shader_stage: 8,
301                        max_storage_buffer_binding_size: 128 << 20, // 128 MB
302                        ..wgpu::Limits::downlevel_webgl2_defaults()
303                            .using_resolution(adapter.limits())
304                    },
305                    label: None,
306                },
307                None,
308            )
309            .await
310            .unwrap();
311
312        let surface_caps = surface.get_capabilities(&adapter);
313        let surface_format = surface_caps
314            .formats
315            .iter()
316            .copied()
317            .find(|f| f.is_srgb())
318            .unwrap_or(surface_caps.formats[0]);
319
320        let config = wgpu::SurfaceConfiguration {
321            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
322            format: surface_format,
323            width: size.width,
324            height: size.height,
325            // VSync tercihi: Mailbox (uncapped FPS) varsa kullan, yoksa Fifo (VSync)
326            present_mode: wgpu::PresentMode::AutoNoVsync,
327            alpha_mode: surface_caps.alpha_modes[0],
328            view_formats: vec![],
329            desired_maximum_frame_latency: 2,
330        };
331        surface.configure(&device, &config);
332
333        let depth_texture_view = Self::create_depth_texture(&device, config.width, config.height);
334
335        let scene = crate::pipeline::build_scene_pipelines(&device);
336        let post_res = crate::post_process::build_post_process_resources(
337            &device,
338            surface_format,
339            config.width,
340            config.height,
341            &depth_texture_view,
342        );
343
344        // GPU particle buffer boyutu — ihtiyaca göre ayarlanabilir
345        #[cfg(not(target_arch = "wasm32"))]
346        let gpu_particles = {
347            let max_particles: u32 = 100_000;
348            Some(crate::gpu_particles::GpuParticleSystem::new(
349                &device,
350                max_particles,
351                &scene.global_bind_group_layout,
352                wgpu::TextureFormat::Rgba16Float,
353            ))
354        };
355        #[cfg(target_arch = "wasm32")]
356        let gpu_particles: Option<crate::gpu_particles::GpuParticleSystem> = None;
357
358        #[cfg(not(target_arch = "wasm32"))]
359        let gpu_physics = {
360            let max_physics_spheres: u32 = 50_000;
361            Some(crate::gpu_physics::GpuPhysicsSystem::new(
362                &device,
363                max_physics_spheres,
364                &scene.global_bind_group_layout,
365                wgpu::TextureFormat::Rgba16Float,
366                wgpu::TextureFormat::Depth32Float,
367            ))
368        };
369        #[cfg(target_arch = "wasm32")]
370        let gpu_physics: Option<crate::gpu_physics::GpuPhysicsSystem> = None;
371
372        #[cfg(not(target_arch = "wasm32"))]
373        let gpu_fluid = Some(crate::gpu_fluid::GpuFluidSystem::new(
374            &device,
375            &queue,
376            100_000,
377            &scene.global_bind_group_layout,
378            post_res.hdr_texture.format(),
379            config.width,
380            config.height,
381        ));
382        #[cfg(target_arch = "wasm32")]
383        let gpu_fluid: Option<crate::gpu_fluid::GpuFluidSystem> = None;
384        let debug_renderer = Some(crate::debug_renderer::GizmoRendererSystem::new(
385            &device,
386            &scene.global_bind_group_layout,
387            wgpu::TextureFormat::Rgba16Float,
388            wgpu::TextureFormat::Depth32Float,
389        ));
390
391        let scene_state = SceneState {
392            render_pipeline: scene.render_pipeline,
393            render_double_sided_pipeline: scene.render_double_sided_pipeline,
394            wireframe_pipeline: scene.wireframe_pipeline,
395            unlit_pipeline: scene.unlit_pipeline,
396            sky_pipeline: scene.sky_pipeline,
397            water_pipeline: scene.water_pipeline,
398            shadow_pipeline: scene.shadow_pipeline,
399            transparent_pipeline: scene.transparent_pipeline,
400            grid_pipeline: scene.grid_pipeline,
401            shadow_texture_view: scene.shadow_texture_view,
402            shadow_cascade_layer_views: scene.shadow_cascade_layer_views,
403            shadow_depth_texture: scene.shadow_depth_texture,
404            shadow_pass_bind_group_layout: scene.shadow_pass_bind_group_layout,
405            shadow_cascade_uniform_buffers: scene.shadow_cascade_uniform_buffers,
406            shadow_pass_bind_groups: scene.shadow_pass_bind_groups,
407            global_uniform_buffer: scene.global_uniform_buffer,
408            global_bind_group_layout: scene.global_bind_group_layout,
409            global_bind_group: scene.global_bind_group,
410            shadow_bind_group_layout: scene.shadow_bind_group_layout,
411            shadow_bind_group: scene.shadow_bind_group,
412            texture_bind_group_layout: scene.texture_bind_group_layout,
413            skeleton_bind_group_layout: scene.skeleton_bind_group_layout,
414            dummy_skeleton_bind_group: scene.dummy_skeleton_bind_group,
415            instance_bind_group_layout: scene.instance_bind_group_layout,
416            instance_buffer: scene.instance_buffer,
417            instance_bind_group: scene.instance_bind_group,
418            instance_capacity: scene.instance_capacity,
419        };
420
421        #[cfg(not(target_arch = "wasm32"))]
422        let deferred = Some(crate::deferred::DeferredState::new(
423            &device,
424            &scene_state,
425            size.width,
426            size.height,
427        ));
428        #[cfg(target_arch = "wasm32")]
429        let deferred: Option<crate::deferred::DeferredState> = None;
430
431        #[cfg(not(target_arch = "wasm32"))]
432        let gpu_cull = Some(crate::gpu_cull::GpuCullState::new(
433            &device,
434            &scene_state,
435            scene_state.instance_capacity as u32,
436        ));
437        #[cfg(target_arch = "wasm32")]
438        let gpu_cull: Option<crate::gpu_cull::GpuCullState> = None;
439
440        let ssao = deferred.as_ref().map(|def| {
441            crate::ssao::SsaoState::new(&device, &queue, &scene_state, def, size.width, size.height)
442        });
443
444        let ssr = deferred.as_ref().map(|def| {
445            crate::ssr::SsrState::new(
446                &device,
447                &scene_state,
448                def,
449                &post_res.hdr_texture_view,
450                size.width,
451                size.height,
452            )
453        });
454
455        let ssgi = deferred.as_ref().map(|def| {
456            crate::ssgi::SsgiState::new(
457                &device,
458                &scene_state,
459                def,
460                &post_res.hdr_texture_view,
461                size.width,
462                size.height,
463            )
464        });
465
466        let volumetric = deferred.as_ref().map(|def| {
467            crate::volumetric::VolumetricState::new(
468                &device,
469                &scene_state,
470                def,
471                size.width,
472                size.height,
473            )
474        });
475
476        let decal = deferred
477            .as_ref()
478            .map(|def| crate::decal::DecalState::new(&device, &scene_state, def));
479
480        let taa = if let Some(ref def) = deferred {
481            Some(crate::taa::TaaState::new(
482                &device,
483                &post_res.hdr_texture_view,
484                &def.world_position_view,
485                size.width,
486                size.height,
487            ))
488        } else {
489            None
490        };
491
492        let post_state = PostProcessState {
493            hdr_texture: post_res.hdr_texture,
494            hdr_texture_view: post_res.hdr_texture_view,
495            hdr_bind_group: post_res.hdr_bind_group,
496            bloom_extract_texture_view: post_res.bloom_extract_texture_view,
497            bloom_extract_bind_group: post_res.bloom_extract_bind_group,
498            bloom_blur_texture_view: post_res.bloom_blur_texture_view,
499            bloom_blur_bind_group: post_res.bloom_blur_bind_group,
500            post_bind_group_layout: post_res.post_bind_group_layout,
501            bloom_extract_pipeline: post_res.bloom_extract_pipeline,
502            bloom_blur_pipeline: post_res.bloom_blur_pipeline,
503            composite_pipeline: post_res.composite_pipeline,
504            blur_params_buffer: post_res.blur_params_buffer,
505            blur_params_bind_group_layout: post_res.blur_params_bind_group_layout,
506            blur_h_bind_group: post_res.blur_h_bind_group,
507            blur_v_bind_group: post_res.blur_v_bind_group,
508            composite_bloom_bind_group_layout: post_res.composite_bloom_bind_group_layout,
509            composite_bloom_bind_group: post_res.composite_bloom_bind_group,
510            post_params_buffer: post_res.post_params_buffer,
511            post_params_bind_group_layout: post_res.post_params_bind_group_layout,
512            post_params_bind_group: post_res.post_params_bind_group,
513        };
514
515        // === FXAA Başlatma ===
516        let fxaa = Some(crate::fxaa::FxaaState::new(
517            &device,
518            config.format,
519            size.width,
520            size.height,
521        ));
522
523        Self {
524            surface,
525            device,
526            queue,
527            config,
528            size,
529            depth_texture_view,
530            scene: scene_state,
531            post: post_state,
532            deferred,
533            gpu_cull,
534            ssao,
535            ssr,
536            ssgi,
537            volumetric,
538            decal,
539            taa,
540            fxaa,
541            gpu_particles,
542            gpu_physics,
543            gpu_fluid,
544            debug_renderer,
545            asset_manager: std::sync::RwLock::new(crate::asset::AssetManager::new()),
546            web_profile: crate::web_profile::WebProfile::auto(),
547        }
548    }
549
550    pub fn rebuild_shaders(&mut self) {
551        tracing::info!("🚀 Rebuilding Shaders Pipeline...");
552        crate::pipeline::rebuild_pipelines(self);
553    }
554
555    pub fn ensure_instance_capacity(&mut self, needed: usize) -> bool {
556        self.scene.ensure_instance_capacity(&self.device, needed)
557    }
558
559    pub fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
560        if new_size.width > 0 && new_size.height > 0 {
561            self.size = new_size;
562            self.config.width = new_size.width;
563            self.config.height = new_size.height;
564            self.surface.configure(&self.device, &self.config);
565
566            self.depth_texture_view =
567                Self::create_depth_texture(&self.device, new_size.width, new_size.height);
568
569            if let Some(ref mut def) = self.deferred {
570                def.resize(&self.device, new_size.width, new_size.height);
571                if let Some(ref mut decal) = self.decal {
572                    decal.resize(&self.device, def);
573                }
574            }
575
576            let sampler = self.device.create_sampler(&wgpu::SamplerDescriptor {
577                address_mode_u: wgpu::AddressMode::ClampToEdge,
578                address_mode_v: wgpu::AddressMode::ClampToEdge,
579                mag_filter: wgpu::FilterMode::Linear,
580                min_filter: wgpu::FilterMode::Linear,
581                ..Default::default()
582            });
583            let (hdr_t, hdr_tv, hdr_bg, be_tv, be_bg, bb_tv, bb_bg, cb_bg) =
584                crate::post_process::create_post_textures(
585                    &self.device,
586                    &self.post.post_bind_group_layout,
587                    &self.post.composite_bloom_bind_group_layout,
588                    &sampler,
589                    new_size.width,
590                    new_size.height,
591                    &self.depth_texture_view,
592                );
593            self.post.hdr_texture = hdr_t;
594            self.post.hdr_texture_view = hdr_tv;
595            self.post.hdr_bind_group = hdr_bg;
596            self.post.bloom_extract_texture_view = be_tv;
597            self.post.bloom_extract_bind_group = be_bg;
598            self.post.bloom_blur_texture_view = bb_tv;
599            self.post.bloom_blur_bind_group = bb_bg;
600            self.post.composite_bloom_bind_group = cb_bg;
601
602            let (buf, h_bg, v_bg) = crate::post_process::create_blur_buffers(
603                &self.device,
604                &self.post.blur_params_bind_group_layout,
605                new_size.width,
606                new_size.height,
607            );
608            self.post.blur_params_buffer = buf;
609            self.post.blur_h_bind_group = h_bg;
610            self.post.blur_v_bind_group = v_bg;
611
612            // TAA history textures + bind groups (needs fresh hdr_view + position_view)
613            if let (Some(ref mut taa), Some(ref def)) = (&mut self.taa, &self.deferred) {
614                taa.resize(
615                    &self.device,
616                    &self.post.hdr_texture_view,
617                    &def.world_position_view,
618                    new_size.width,
619                    new_size.height,
620                );
621            }
622            if let (Some(ref mut ssgi), Some(ref def)) = (&mut self.ssgi, &self.deferred) {
623                ssgi.resize(
624                    &self.device,
625                    def,
626                    &self.post.hdr_texture_view,
627                    new_size.width,
628                    new_size.height,
629                );
630            }
631            if let (Some(ref mut ssao), Some(ref def)) = (&mut self.ssao, &self.deferred) {
632                ssao.resize(
633                    &self.device,
634                    def,
635                    new_size.width,
636                    new_size.height,
637                );
638            }
639            if let (Some(ref mut vol), Some(ref def)) = (&mut self.volumetric, &self.deferred) {
640                vol.resize(
641                    &self.device,
642                    def,
643                    new_size.width,
644                    new_size.height,
645                );
646            }
647            // FXAA resize
648            if let Some(ref mut fxaa) = self.fxaa {
649                fxaa.resize(&self.device, &self.queue, self.config.format, new_size.width, new_size.height);
650            }
651        }
652    }
653
654    // ==========================================================
655    //  Kolaylık Metodları — Asset Oluşturma
656    //  Kullanıcı `AssetManager` oluşturmak zorunda kalmadan
657    //  doğrudan `renderer.create_cube()` gibi çağırabilir.
658    // ==========================================================
659
660    /// Küp mesh oluşturur.
661    pub fn create_cube(&self) -> crate::components::Mesh {
662        crate::asset::AssetManager::create_cube(&self.device)
663    }
664
665    /// Küre mesh oluşturur.
666    pub fn create_sphere(&self, radius: f32, stacks: u32, slices: u32) -> crate::components::Mesh {
667        crate::asset::AssetManager::create_sphere(&self.device, radius, stacks, slices)
668    }
669
670    /// Düzlem mesh oluşturur.
671    pub fn create_plane(&self, size: f32) -> crate::components::Mesh {
672        crate::asset::AssetManager::create_plane(&self.device, size)
673    }
674
675    /// Dama dokusu (checkerboard) oluşturur — test materyalleri için idealdir.
676    /// Cache'lenir: aynı doku tekrar oluşturulmaz.
677    pub fn create_checkerboard_texture(&self) -> Arc<wgpu::BindGroup> {
678        self.asset_manager
679            .write()
680            .unwrap()
681            .create_checkerboard_texture(
682                &self.device,
683                &self.queue,
684                &self.scene.texture_bind_group_layout,
685            )
686    }
687
688    /// Düz beyaz doku — varsayılan materyal için.
689    /// Cache'lenir: aynı doku tekrar oluşturulmaz.
690    pub fn create_white_texture(&self) -> Arc<wgpu::BindGroup> {
691        self.asset_manager.write().unwrap().create_white_texture(
692            &self.device,
693            &self.queue,
694            &self.scene.texture_bind_group_layout,
695        )
696    }
697
698    /// Diskten doku yükler (BC7 pipeline dahil).
699    /// Cache'lenir: aynı dosya yolu tekrar yüklenmez.
700    pub fn load_texture(&self, path: &str) -> Result<Arc<wgpu::BindGroup>, String> {
701        self.asset_manager.write().unwrap().load_material_texture(
702            &self.device,
703            &self.queue,
704            &self.scene.texture_bind_group_layout,
705            path,
706        )
707    }
708
709    /// Diskten bir GLTF (veya GLB) modelini senkron olarak yükler.
710    pub fn load_gltf(&self, path: &str) -> Result<crate::asset::loaders::GltfSceneAsset, String> {
711        let white_tex = self.create_white_texture();
712        self.asset_manager.write().unwrap().load_gltf_scene(
713            &self.device,
714            &self.queue,
715            &self.scene.texture_bind_group_layout,
716            white_tex,
717            path,
718        )
719    }
720
721    pub fn create_skeleton(
722        &self,
723        hierarchy: std::sync::Arc<crate::animation::SkeletonHierarchy>,
724    ) -> crate::components::Skeleton {
725        use wgpu::util::DeviceExt;
726
727        // İlk local_poses'u her kemiğin orijinal local_bind_transform'undan al.
728        let local_poses: Vec<gizmo_math::Mat4> = hierarchy
729            .joints
730            .iter()
731            .map(|j| j.local_bind_transform)
732            .collect();
733
734        // Global matrislerden doğru joint_matrices hesapla (bind-pose)
735        let global_matrices = hierarchy.calculate_global_matrices(&local_poses);
736        let mut joint_matrices = vec![gizmo_math::Mat4::IDENTITY; 128];
737        for (i, joint) in hierarchy.joints.iter().enumerate() {
738            if i < 128 {
739                joint_matrices[i] = global_matrices[i] * joint.inverse_bind_matrix;
740            }
741        }
742
743        let buffer = self
744            .device
745            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
746                label: Some("Skeleton Joint Buffer"),
747                contents: bytemuck::cast_slice(&joint_matrices),
748                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
749            });
750
751        let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
752            label: Some("Skeleton Bind Group"),
753            layout: &self.scene.skeleton_bind_group_layout,
754            entries: &[wgpu::BindGroupEntry {
755                binding: 0,
756                resource: buffer.as_entire_binding(),
757            }],
758        });
759
760        crate::components::Skeleton::new(
761            std::sync::Arc::new(bind_group),
762            std::sync::Arc::new(buffer),
763            hierarchy,
764            local_poses,
765        )
766    }
767
768    pub fn run_post_processing(
769        &self,
770        encoder: &mut wgpu::CommandEncoder,
771        output_view: &wgpu::TextureView,
772    ) {
773        if let Some(ref fxaa) = self.fxaa {
774            if fxaa.enabled {
775                // Composite → FXAA input texture → FXAA → output_view
776                crate::post_process::run_post_processing(self, encoder, &fxaa.input_texture_view);
777                crate::fxaa::run_fxaa_pass(fxaa, encoder, output_view);
778                return;
779            }
780        }
781        // FXAA kapalıysa doğrudan output'a yaz
782        crate::post_process::run_post_processing(self, encoder, output_view);
783    }
784
785    pub fn update_post_process(&self, queue: &wgpu::Queue, params: PostProcessUniforms) {
786        queue.write_buffer(
787            &self.post.post_params_buffer,
788            0,
789            bytemuck::cast_slice(&[params]),
790        );
791    }
792
793    pub fn create_mesh(&self, vertices: &[Vertex]) -> wgpu::Buffer {
794        self.device
795            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
796                label: Some("Mesh Vertex Buffer"),
797                contents: bytemuck::cast_slice(vertices),
798                usage: wgpu::BufferUsages::VERTEX,
799            })
800    }
801
802    pub fn create_texture(&self, rgba_bytes: &[u8], width: u32, height: u32) -> wgpu::BindGroup {
803        let mip_level_count = width.max(height).ilog2() + 1;
804        let size = wgpu::Extent3d {
805            width,
806            height,
807            depth_or_array_layers: 1,
808        };
809        let texture = self.device.create_texture(&wgpu::TextureDescriptor {
810            label: Some("Game Texture"),
811            size,
812            mip_level_count,
813            sample_count: 1,
814            dimension: wgpu::TextureDimension::D2,
815            format: wgpu::TextureFormat::Rgba8UnormSrgb,
816            usage: wgpu::TextureUsages::TEXTURE_BINDING
817                | wgpu::TextureUsages::COPY_DST
818                | wgpu::TextureUsages::RENDER_ATTACHMENT,
819            view_formats: &[],
820        });
821        self.queue.write_texture(
822            wgpu::ImageCopyTexture {
823                texture: &texture,
824                mip_level: 0,
825                origin: wgpu::Origin3d::ZERO,
826                aspect: wgpu::TextureAspect::All,
827            },
828            rgba_bytes,
829            wgpu::ImageDataLayout {
830                offset: 0,
831                bytes_per_row: Some(4 * width),
832                rows_per_image: Some(height),
833            },
834            size,
835        );
836
837        Self::generate_mipmaps(
838            &self.device,
839            &self.queue,
840            &texture,
841            wgpu::TextureFormat::Rgba8UnormSrgb,
842            mip_level_count,
843        );
844        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
845        let sampler = self.device.create_sampler(&wgpu::SamplerDescriptor {
846            address_mode_u: wgpu::AddressMode::Repeat,
847            address_mode_v: wgpu::AddressMode::Repeat,
848            address_mode_w: wgpu::AddressMode::Repeat,
849            mag_filter: wgpu::FilterMode::Linear,
850            min_filter: wgpu::FilterMode::Linear,
851            mipmap_filter: wgpu::FilterMode::Linear,
852            ..Default::default()
853        });
854        self.device.create_bind_group(&wgpu::BindGroupDescriptor {
855            layout: &self.scene.texture_bind_group_layout,
856            entries: &[
857                wgpu::BindGroupEntry {
858                    binding: 0,
859                    resource: wgpu::BindingResource::TextureView(&view),
860                },
861                wgpu::BindGroupEntry {
862                    binding: 1,
863                    resource: wgpu::BindingResource::Sampler(&sampler),
864                },
865            ],
866            label: Some("texture_bind_group"),
867        })
868    }
869
870    fn create_depth_texture(device: &wgpu::Device, width: u32, height: u32) -> wgpu::TextureView {
871        let tex = device.create_texture(&wgpu::TextureDescriptor {
872            label: Some("Depth Texture"),
873            size: wgpu::Extent3d {
874                width,
875                height,
876                depth_or_array_layers: 1,
877            },
878            mip_level_count: 1,
879            sample_count: 1,
880            dimension: wgpu::TextureDimension::D2,
881            format: wgpu::TextureFormat::Depth32Float,
882            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
883            view_formats: &[],
884        });
885        tex.create_view(&wgpu::TextureViewDescriptor::default())
886    }
887
888    fn generate_mipmaps(
889        device: &wgpu::Device,
890        queue: &wgpu::Queue,
891        texture: &wgpu::Texture,
892        format: wgpu::TextureFormat,
893        mip_level_count: u32,
894    ) {
895        if mip_level_count <= 1 {
896            return;
897        }
898
899        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
900            label: Some("Mipmap Blit Shader"),
901            source: wgpu::ShaderSource::Wgsl(include_str!("shaders/mipmap.wgsl").into()),
902        });
903
904        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
905            label: Some("Mipmap Blit Pipeline"),
906            layout: None,
907            vertex: wgpu::VertexState {
908                module: &shader,
909                entry_point: "vs_main",
910                compilation_options: Default::default(),
911                buffers: &[],
912            },
913            fragment: Some(wgpu::FragmentState {
914                module: &shader,
915                entry_point: "fs_main",
916                compilation_options: Default::default(),
917                targets: &[Some(wgpu::ColorTargetState {
918                    format,
919                    blend: None,
920                    write_mask: wgpu::ColorWrites::ALL,
921                })],
922            }),
923            primitive: wgpu::PrimitiveState {
924                topology: wgpu::PrimitiveTopology::TriangleList,
925                ..Default::default()
926            },
927            depth_stencil: None,
928            multisample: wgpu::MultisampleState::default(),
929            multiview: None,
930        });
931
932        let bind_group_layout = pipeline.get_bind_group_layout(0);
933        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
934            address_mode_u: wgpu::AddressMode::ClampToEdge,
935            address_mode_v: wgpu::AddressMode::ClampToEdge,
936            address_mode_w: wgpu::AddressMode::ClampToEdge,
937            mag_filter: wgpu::FilterMode::Linear,
938            min_filter: wgpu::FilterMode::Linear,
939            mipmap_filter: wgpu::FilterMode::Nearest,
940            ..Default::default()
941        });
942
943        let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
944            label: Some("Mipmap Encoder"),
945        });
946
947        let views: Vec<wgpu::TextureView> = (0..mip_level_count)
948            .map(|mip| {
949                texture.create_view(&wgpu::TextureViewDescriptor {
950                    label: Some(&format!("Mip {}", mip)),
951                    format: None,
952                    dimension: None,
953                    aspect: wgpu::TextureAspect::All,
954                    base_mip_level: mip,
955                    mip_level_count: Some(1),
956                    base_array_layer: 0,
957                    array_layer_count: None,
958                })
959            })
960            .collect();
961
962        for target_mip in 1..mip_level_count as usize {
963            let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
964                layout: &bind_group_layout,
965                entries: &[
966                    wgpu::BindGroupEntry {
967                        binding: 0,
968                        resource: wgpu::BindingResource::TextureView(&views[target_mip - 1]),
969                    },
970                    wgpu::BindGroupEntry {
971                        binding: 1,
972                        resource: wgpu::BindingResource::Sampler(&sampler),
973                    },
974                ],
975                label: None,
976            });
977
978            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
979                label: None,
980                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
981                    view: &views[target_mip],
982                    resolve_target: None,
983                    ops: wgpu::Operations {
984                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
985                        store: wgpu::StoreOp::Store,
986                    },
987                })],
988                depth_stencil_attachment: None,
989                timestamp_writes: None,
990                occlusion_query_set: None,
991            });
992            pass.set_pipeline(&pipeline);
993            pass.set_bind_group(0, &bind_group, &[]);
994            pass.draw(0..3, 0..1);
995        }
996
997        queue.submit(Some(encoder.finish()));
998    }
999}
1000
1001#[cfg(test)]
1002mod tests {
1003    use super::*;
1004
1005    #[test]
1006    fn test_mipmap_level_calculation() {
1007        let width = 4096u32;
1008        let height = 2048u32;
1009        let mip_level_count = width.max(height).ilog2() + 1;
1010        assert_eq!(mip_level_count, 13); // 4096 -> 2^12. Level count is 13 (with level 0)
1011
1012        let width2 = 512u32;
1013        let height2 = 512u32;
1014        assert_eq!(width2.max(height2).ilog2() + 1, 10);
1015    }
1016
1017    #[test]
1018    fn test_headless_mipmap_generation() {
1019        pollster::block_on(async {
1020            let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
1021                backends: wgpu::Backends::all(),
1022                ..Default::default()
1023            });
1024
1025            let adapter = instance
1026                .request_adapter(&wgpu::RequestAdapterOptions {
1027                    power_preference: wgpu::PowerPreference::LowPower,
1028                    compatible_surface: None,
1029                    force_fallback_adapter: false,
1030                })
1031                .await;
1032
1033            let adapter = match adapter {
1034                Some(a) => a,
1035                None => {
1036                    tracing::info!(
1037                        "No suitable GPU adapter found for headless test. Skipping wgpu test."
1038                    );
1039                    return;
1040                }
1041            };
1042
1043            let (device, queue) = adapter
1044                .request_device(
1045                    &wgpu::DeviceDescriptor {
1046                        required_features: wgpu::Features::empty(),
1047                        required_limits: wgpu::Limits::downlevel_defaults(),
1048                        label: None,
1049                    },
1050                    None,
1051                )
1052                .await
1053                .unwrap();
1054
1055            let width = 256u32;
1056            let height = 256u32;
1057            let mip_level_count = width.max(height).ilog2() + 1;
1058
1059            let texture = device.create_texture(&wgpu::TextureDescriptor {
1060                label: Some("Test Texture"),
1061                size: wgpu::Extent3d {
1062                    width,
1063                    height,
1064                    depth_or_array_layers: 1,
1065                },
1066                mip_level_count,
1067                sample_count: 1,
1068                dimension: wgpu::TextureDimension::D2,
1069                format: wgpu::TextureFormat::Rgba8UnormSrgb,
1070                usage: wgpu::TextureUsages::TEXTURE_BINDING
1071                    | wgpu::TextureUsages::COPY_DST
1072                    | wgpu::TextureUsages::RENDER_ATTACHMENT,
1073                view_formats: &[],
1074            });
1075
1076            // This should compile the WGSL and execute without panicking or creating wgpu validation errors
1077            Renderer::generate_mipmaps(
1078                &device,
1079                &queue,
1080                &texture,
1081                wgpu::TextureFormat::Rgba8UnormSrgb,
1082                mip_level_count,
1083            );
1084
1085            device.poll(wgpu::Maintain::Wait);
1086        });
1087    }
1088}
gizmo_renderer/renderer.rs

gizmo_renderer/
renderer.rs
