update

frontend/src/pipelines/building.rs

@@ -0,0 +1,95 @@
+//! Building render pipeline
+
+use super::common::Vertex;
+
+pub fn create_building_pipeline(
+    device: &wgpu::Device, 
+    format: &wgpu::TextureFormat,
+    bind_group_layout: &wgpu::BindGroupLayout
+) -> wgpu::RenderPipeline {
+    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: None,
+        source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(r#"
+            struct CameraUniform {
+                params: vec4<f32>,
+                theme: vec4<f32>,
+            };
+            @group(0) @binding(0)
+            var<uniform> camera: CameraUniform;
+
+            struct VertexInput {
+                @location(0) position: vec2<f32>,
+            };
+
+            struct VertexOutput {
+                @builtin(position) clip_position: vec4<f32>,
+            };
+
+            @vertex
+            fn vs_main(
+                model: VertexInput,
+            ) -> VertexOutput {
+                var out: VertexOutput;
+                
+                let world_pos = model.position;
+                
+                let x = world_pos.x * camera.params.x + camera.params.z;
+                let y = world_pos.y * camera.params.y + camera.params.w;
+
+                // Globe Effect: Spherize
+                // let r2 = x*x + y*y;
+                // let w = 1.0 + r2 * 0.5;
+                
+                out.clip_position = vec4<f32>(x, y, 0.0, 1.0);
+                return out;
+            }
+
+            @fragment
+            fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+                // Buildings: Light: #d9d9d9 (0.85), Dark: #333333 (0.2)
+                let is_dark = camera.theme.x;
+                let color = mix(vec3<f32>(0.85, 0.85, 0.85), vec3<f32>(0.2, 0.2, 0.2), is_dark);
+                return vec4<f32>(color, 1.0);
+            }
+        "#)),
+    });
+
+    let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: Some("Building Pipeline Layout"),
+        bind_group_layouts: &[bind_group_layout],
+        push_constant_ranges: &[],
+    });
+
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: None,
+        layout: Some(&pipeline_layout),
+        vertex: wgpu::VertexState {
+            module: &shader,
+            entry_point: "vs_main",
+            buffers: &[
+                Vertex::desc(),
+            ],
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: &shader,
+            entry_point: "fs_main",
+            targets: &[Some(wgpu::ColorTargetState {
+                format: *format,
+                blend: Some(wgpu::BlendState::REPLACE),
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        primitive: wgpu::PrimitiveState {
+            topology: wgpu::PrimitiveTopology::TriangleList,
+            strip_index_format: None,
+            front_face: wgpu::FrontFace::Ccw,
+            cull_mode: None,
+            unclipped_depth: false,
+            polygon_mode: wgpu::PolygonMode::Fill,
+            conservative: false,
+        },
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState::default(),
+        multiview: None,
+    })
+}