@bornengine/engine 0.4.16

package/native/shared/src/picking.rs

@@ -0,0 +1,298 @@
+//! Scene graph picking — raycast from screen coordinates against scene nodes.
+//!
+//! Converts 2D screen position to a 3D world ray via inverse VP matrix,
+//! then tests against all visible scene node triangles using Moller-Trumbore.
+
+use crate::scene::SceneGraph;
+
+/// Result of a scene pick operation.
+#[derive(Clone, Debug)]
+pub struct PickResult {
+    pub hit: bool,
+    pub handle: f64,       // scene node handle that was hit
+    pub distance: f32,
+    pub point: [f32; 3],   // world-space hit point
+    pub normal: [f32; 3],  // face normal at hit point
+}
+
+impl PickResult {
+    pub fn miss() -> Self {
+        Self {
+            hit: false,
+            handle: 0.0,
+            distance: 0.0,
+            point: [0.0; 3],
+            normal: [0.0; 3],
+        }
+    }
+}
+
+/// Unproject screen coordinates to a world-space ray.
+/// screen_x, screen_y: pixel coordinates (0,0 = top-left)
+/// width, height: viewport dimensions
+/// inv_vp: inverse view-projection matrix
+/// camera_pos: camera world position
+pub fn screen_to_ray(
+    screen_x: f32, screen_y: f32,
+    width: f32, height: f32,
+    inv_vp: &[[f32; 4]; 4],
+    _camera_pos: &[f32; 3],
+) -> ([f32; 3], [f32; 3]) {
+    // Convert screen coords to NDC (-1 to 1)
+    let ndc_x = (screen_x / width) * 2.0 - 1.0;
+    let ndc_y = 1.0 - (screen_y / height) * 2.0; // flip Y
+
+    // Unproject near point (z = -1 in NDC)
+    let near_ndc = [ndc_x, ndc_y, -1.0, 1.0];
+    let near_world = mat4_mul_vec4(inv_vp, &near_ndc);
+
+    // Unproject far point (z = 1 in NDC)
+    let far_ndc = [ndc_x, ndc_y, 1.0, 1.0];
+    let far_world = mat4_mul_vec4(inv_vp, &far_ndc);
+
+    // Perspective divide
+    let near = [
+        near_world[0] / near_world[3],
+        near_world[1] / near_world[3],
+        near_world[2] / near_world[3],
+    ];
+    let far = [
+        far_world[0] / far_world[3],
+        far_world[1] / far_world[3],
+        far_world[2] / far_world[3],
+    ];
+
+    // Ray direction
+    let dx = far[0] - near[0];
+    let dy = far[1] - near[1];
+    let dz = far[2] - near[2];
+    let len = (dx * dx + dy * dy + dz * dz).sqrt();
+    let dir = if len > 1e-8 {
+        [dx / len, dy / len, dz / len]
+    } else {
+        [0.0, 0.0, -1.0]
+    };
+
+    (near, dir)
+}
+
+/// Raycast against all visible scene nodes. Returns the closest hit.
+pub fn raycast_scene(
+    scene: &SceneGraph,
+    origin: &[f32; 3],
+    direction: &[f32; 3],
+) -> PickResult {
+    let mut best = PickResult::miss();
+    let mut best_dist = f32::MAX;
+
+    for (handle, node) in scene.nodes.iter() {
+        if !node.visible || node.indices.is_empty() {
+            continue;
+        }
+
+        // Transform ray into node's local space via inverse transform
+        let inv_transform = mat4_inverse_local(&node.transform);
+        let local_origin = mat4_transform_point(&inv_transform, origin);
+        let local_dir = mat4_transform_dir(&inv_transform, direction);
+
+        // Test against all triangles
+        for tri in node.indices.chunks(3) {
+            if tri.len() < 3 { continue; }
+            let v0 = &node.vertices[tri[0] as usize];
+            let v1 = &node.vertices[tri[1] as usize];
+            let v2 = &node.vertices[tri[2] as usize];
+
+            if let Some((t, u, v)) = ray_triangle_intersection(
+                &local_origin, &local_dir,
+                &v0.position, &v1.position, &v2.position,
+            ) {
+                if t > 0.0 && t < best_dist {
+                    best_dist = t;
+
+                    // Compute hit point in world space
+                    let hit_local = [
+                        local_origin[0] + local_dir[0] * t,
+                        local_origin[1] + local_dir[1] * t,
+                        local_origin[2] + local_dir[2] * t,
+                    ];
+                    let hit_world = mat4_transform_point(&node.transform, &hit_local);
+
+                    // Interpolate normal
+                    let w = 1.0 - u - v;
+                    let normal = [
+                        v0.normal[0] * w + v1.normal[0] * u + v2.normal[0] * v,
+                        v0.normal[1] * w + v1.normal[1] * u + v2.normal[1] * v,
+                        v0.normal[2] * w + v1.normal[2] * u + v2.normal[2] * v,
+                    ];
+                    let nl = (normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]).sqrt();
+                    let normal = if nl > 1e-6 {
+                        [normal[0]/nl, normal[1]/nl, normal[2]/nl]
+                    } else {
+                        [0.0, 1.0, 0.0]
+                    };
+
+                    best = PickResult {
+                        hit: true,
+                        handle,
+                        distance: t,
+                        point: hit_world,
+                        normal,
+                    };
+                }
+            }
+        }
+    }
+
+    best
+}
+
+/// Q6: Raycast against all visible scene nodes. Returns ALL hits sorted by distance.
+/// Used by editors for alt-click cycling through occluded objects.
+pub fn raycast_scene_all(
+    scene: &SceneGraph,
+    origin: &[f32; 3],
+    direction: &[f32; 3],
+    max_results: usize,
+) -> Vec<PickResult> {
+    let mut results: Vec<PickResult> = Vec::new();
+
+    for (handle, node) in scene.nodes.iter() {
+        if !node.visible || node.indices.is_empty() {
+            continue;
+        }
+
+        let inv_transform = mat4_inverse_local(&node.transform);
+        let local_origin = mat4_transform_point(&inv_transform, origin);
+        let local_dir = mat4_transform_dir(&inv_transform, direction);
+
+        let mut node_best_dist = f32::MAX;
+        let mut node_best: Option<PickResult> = None;
+
+        for tri in node.indices.chunks(3) {
+            if tri.len() < 3 { continue; }
+            let v0 = &node.vertices[tri[0] as usize];
+            let v1 = &node.vertices[tri[1] as usize];
+            let v2 = &node.vertices[tri[2] as usize];
+
+            if let Some((t, u, v)) = ray_triangle_intersection(
+                &local_origin, &local_dir,
+                &v0.position, &v1.position, &v2.position,
+            ) {
+                if t > 0.0 && t < node_best_dist {
+                    node_best_dist = t;
+                    let hit_local = [
+                        local_origin[0] + local_dir[0] * t,
+                        local_origin[1] + local_dir[1] * t,
+                        local_origin[2] + local_dir[2] * t,
+                    ];
+                    let hit_world = mat4_transform_point(&node.transform, &hit_local);
+                    let w = 1.0 - u - v;
+                    let normal = [
+                        v0.normal[0] * w + v1.normal[0] * u + v2.normal[0] * v,
+                        v0.normal[1] * w + v1.normal[1] * u + v2.normal[1] * v,
+                        v0.normal[2] * w + v1.normal[2] * u + v2.normal[2] * v,
+                    ];
+                    let nl = (normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2]).sqrt();
+                    let normal = if nl > 1e-6 {
+                        [normal[0]/nl, normal[1]/nl, normal[2]/nl]
+                    } else {
+                        [0.0, 1.0, 0.0]
+                    };
+                    node_best = Some(PickResult {
+                        hit: true,
+                        handle,
+                        distance: t,
+                        point: hit_world,
+                        normal,
+                    });
+                }
+            }
+        }
+
+        if let Some(result) = node_best {
+            results.push(result);
+        }
+    }
+
+    // Sort by distance (closest first).
+    results.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap_or(std::cmp::Ordering::Equal));
+    results.truncate(max_results);
+    results
+}
+
+// ============================================================
+// Moller-Trumbore ray-triangle intersection
+// ============================================================
+
+fn ray_triangle_intersection(
+    origin: &[f32; 3], dir: &[f32; 3],
+    v0: &[f32; 3], v1: &[f32; 3], v2: &[f32; 3],
+) -> Option<(f32, f32, f32)> {
+    const EPSILON: f32 = 1e-7;
+
+    let e1 = [v1[0]-v0[0], v1[1]-v0[1], v1[2]-v0[2]];
+    let e2 = [v2[0]-v0[0], v2[1]-v0[1], v2[2]-v0[2]];
+
+    let h = cross(dir, &e2);
+    let a = dot(&e1, &h);
+    if a.abs() < EPSILON { return None; }
+
+    let f = 1.0 / a;
+    let s = [origin[0]-v0[0], origin[1]-v0[1], origin[2]-v0[2]];
+    let u = f * dot(&s, &h);
+    if u < 0.0 || u > 1.0 { return None; }
+
+    let q = cross(&s, &e1);
+    let v = f * dot(dir, &q);
+    if v < 0.0 || u + v > 1.0 { return None; }
+
+    let t = f * dot(&e2, &q);
+    if t > EPSILON {
+        Some((t, u, v))
+    } else {
+        None
+    }
+}
+
+fn cross(a: &[f32; 3], b: &[f32; 3]) -> [f32; 3] {
+    [
+        a[1]*b[2] - a[2]*b[1],
+        a[2]*b[0] - a[0]*b[2],
+        a[0]*b[1] - a[1]*b[0],
+    ]
+}
+
+fn dot(a: &[f32; 3], b: &[f32; 3]) -> f32 {
+    a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+}
+
+fn mat4_mul_vec4(m: &[[f32; 4]; 4], v: &[f32; 4]) -> [f32; 4] {
+    [
+        m[0][0]*v[0] + m[1][0]*v[1] + m[2][0]*v[2] + m[3][0]*v[3],
+        m[0][1]*v[0] + m[1][1]*v[1] + m[2][1]*v[2] + m[3][1]*v[3],
+        m[0][2]*v[0] + m[1][2]*v[1] + m[2][2]*v[2] + m[3][2]*v[3],
+        m[0][3]*v[0] + m[1][3]*v[1] + m[2][3]*v[2] + m[3][3]*v[3],
+    ]
+}
+
+fn mat4_transform_point(m: &[[f32; 4]; 4], p: &[f32; 3]) -> [f32; 3] {
+    let v = mat4_mul_vec4(m, &[p[0], p[1], p[2], 1.0]);
+    if v[3].abs() > 1e-8 {
+        [v[0]/v[3], v[1]/v[3], v[2]/v[3]]
+    } else {
+        [v[0], v[1], v[2]]
+    }
+}
+
+fn mat4_transform_dir(m: &[[f32; 4]; 4], d: &[f32; 3]) -> [f32; 3] {
+    // Transform direction (no translation, no perspective divide)
+    [
+        m[0][0]*d[0] + m[1][0]*d[1] + m[2][0]*d[2],
+        m[0][1]*d[0] + m[1][1]*d[1] + m[2][1]*d[2],
+        m[0][2]*d[0] + m[1][2]*d[1] + m[2][2]*d[2],
+    ]
+}
+
+fn mat4_inverse_local(m: &[[f32; 4]; 4]) -> [[f32; 4]; 4] {
+    crate::renderer::mat4_invert(*m)
+}

package/native/shared/src/postfx.rs

@@ -0,0 +1,345 @@
+//! Post-processing effects for Bloom Engine.
+//!
+//! Implements a render-to-texture pipeline with:
+//! - Object outlines (selected/hovered objects)
+//! - Screen-space ambient occlusion (SSAO)
+//! - Final composite pass
+//!
+//! The pipeline renders the scene to offscreen textures (color + depth + object ID),
+//! then applies fullscreen post-processing passes before presenting to screen.
+
+use wgpu::util::DeviceExt;
+
+/// Fullscreen quad vertex shader (shared by all post-fx passes).
+const FULLSCREEN_VERT: &str = "
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_fullscreen(@builtin(vertex_index) idx: u32) -> VertexOutput {
+    var out: VertexOutput;
+    // Triangle strip covering screen: 3 vertices, no vertex buffer needed
+    let x = f32(i32(idx & 1u)) * 4.0 - 1.0;
+    let y = f32(i32(idx >> 1u)) * 4.0 - 1.0;
+    out.position = vec4<f32>(x, y, 0.0, 1.0);
+    out.uv = vec2<f32>((x + 1.0) * 0.5, (1.0 - y) * 0.5);
+    return out;
+}
+";
+
+/// Outline detection shader — Sobel edge detection on object ID buffer.
+const OUTLINE_FRAG: &str = "
+struct OutlineParams {
+    color_selected: vec4<f32>,    // rgba
+    color_hovered: vec4<f32>,     // rgba
+    thickness: vec4<f32>,         // [thickness, glow, pulse_time, 0]
+    screen_size: vec4<f32>,       // [width, height, 0, 0]
+};
+
+@group(0) @binding(0) var scene_color: texture_2d<f32>;
+@group(0) @binding(1) var object_id_tex: texture_2d<f32>;
+@group(0) @binding(2) var tex_sampler: sampler;
+@group(0) @binding(3) var<uniform> params: OutlineParams;
+
+// VertexOutput is defined in FULLSCREEN_VERT — this string is concatenated
+// after it, so redefining here would be a WGSL parser error.
+
+@fragment
+fn fs_outline(in: VertexOutput) -> @location(0) vec4<f32> {
+    let color = textureSample(scene_color, tex_sampler, in.uv);
+
+    // Object IDs must not be filtered — interpolating IDs produces nonsense
+    // values at edges. Use textureLoad with integer coords; this also avoids
+    // requiring the FLOAT32_FILTERABLE wgpu feature (not advertised on Apple GPUs).
+    let dim = vec2<i32>(textureDimensions(object_id_tex));
+    let max_xy = dim - vec2<i32>(1, 1);
+    let center_pix = clamp(vec2<i32>(in.uv * vec2<f32>(dim)), vec2<i32>(0, 0), max_xy);
+    let center_id = textureLoad(object_id_tex, center_pix, 0).r;
+
+    let t = max(1, i32(round(params.thickness.x)));
+
+    // Sample neighbors for edge detection
+    var edge = 0.0;
+    for (var dy = -1; dy <= 1; dy++) {
+        for (var dx = -1; dx <= 1; dx++) {
+            if (dx == 0 && dy == 0) { continue; }
+            let neighbor_pix = clamp(center_pix + vec2<i32>(dx, dy) * t, vec2<i32>(0, 0), max_xy);
+            let neighbor_id = textureLoad(object_id_tex, neighbor_pix, 0).r;
+            if (abs(neighbor_id - center_id) > 0.001) {
+                edge += 1.0;
+            }
+        }
+    }
+
+    // Normalize edge strength
+    edge = min(edge / 3.0, 1.0);
+
+    // Apply outline color if this pixel is on an edge
+    if (edge > 0.01) {
+        // Determine if selected or hovered based on the ID value
+        let outline_color = params.color_selected;
+        // Pulse effect
+        let pulse = 0.7 + 0.3 * sin(params.thickness.z * 3.0);
+        let glow = params.thickness.y * pulse;
+        return mix(color, outline_color, edge * (0.8 + glow * 0.2));
+    }
+
+    return color;
+}
+";
+
+// ============================================================
+// Outline parameters
+// ============================================================
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+pub struct OutlineParams {
+    pub color_selected: [f32; 4],
+    pub color_hovered: [f32; 4],
+    pub thickness: [f32; 4],  // [thickness, glow, pulse_time, 0]
+    pub screen_size: [f32; 4],
+}
+
+impl Default for OutlineParams {
+    fn default() -> Self {
+        Self {
+            color_selected: [0.2, 0.5, 1.0, 1.0],  // blue
+            color_hovered: [0.8, 0.8, 0.2, 1.0],    // yellow
+            thickness: [2.0, 0.3, 0.0, 0.0],
+            screen_size: [1280.0, 720.0, 0.0, 0.0],
+        }
+    }
+}
+
+// ============================================================
+// Post-FX Pipeline
+// ============================================================
+
+pub struct PostFxPipeline {
+    // Offscreen render targets
+    pub color_texture: wgpu::Texture,
+    pub color_view: wgpu::TextureView,
+    pub object_id_texture: wgpu::Texture,
+    pub object_id_view: wgpu::TextureView,
+    pub depth_texture: wgpu::Texture,
+    pub depth_view: wgpu::TextureView,
+
+    // Outline pass
+    pub outline_pipeline: wgpu::RenderPipeline,
+    pub outline_bind_group: wgpu::BindGroup,
+    pub outline_params_buffer: wgpu::Buffer,
+    pub outline_params: OutlineParams,
+
+    // Common
+    pub sampler: wgpu::Sampler,
+    pub enabled: bool,
+    pub width: u32,
+    pub height: u32,
+
+    // Selected node handles for outline rendering
+    pub selected_handles: Vec<f64>,
+    pub hovered_handle: f64,
+    pub time: f32,
+}
+
+impl PostFxPipeline {
+    pub fn new(device: &wgpu::Device, width: u32, height: u32, surface_format: wgpu::TextureFormat) -> Self {
+        let (color_texture, color_view) = create_color_target(device, width, height, surface_format);
+        let (object_id_texture, object_id_view) = create_color_target(device, width, height, wgpu::TextureFormat::R32Float);
+        let (depth_texture, depth_view) = create_depth_target(device, width, height);
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("postfx_sampler"),
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+
+        let outline_params = OutlineParams {
+            screen_size: [width as f32, height as f32, 0.0, 0.0],
+            ..Default::default()
+        };
+        let outline_params_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("outline_params"),
+            contents: bytemuck::bytes_of(&outline_params),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+
+        // Outline bind group layout
+        let outline_bg_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("outline_bg_layout"),
+            entries: &[
+                bgl_texture(0, wgpu::TextureSampleType::Float { filterable: true }),
+                // R32Float — non-filterable on adapters without FLOAT32_FILTERABLE
+                // (e.g. Apple GPUs). Sampled via textureLoad in OUTLINE_FRAG.
+                bgl_texture(1, wgpu::TextureSampleType::Float { filterable: false }),
+                bgl_sampler(2),
+                bgl_uniform(3),
+            ],
+        });
+
+        let outline_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("outline_bg"),
+            layout: &outline_bg_layout,
+            entries: &[
+                wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(&color_view) },
+                wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(&object_id_view) },
+                wgpu::BindGroupEntry { binding: 2, resource: wgpu::BindingResource::Sampler(&sampler) },
+                wgpu::BindGroupEntry { binding: 3, resource: outline_params_buffer.as_entire_binding() },
+            ],
+        });
+
+        // Outline pipeline
+        let outline_shader_src = format!("{}\n{}", FULLSCREEN_VERT, OUTLINE_FRAG);
+        let outline_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("outline_shader"),
+            source: wgpu::ShaderSource::Wgsl(outline_shader_src.into()),
+        });
+
+        let outline_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("outline_pipeline_layout"),
+            bind_group_layouts: &[Some(&outline_bg_layout)],
+            immediate_size: 0,
+        });
+
+        let outline_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("outline_pipeline"),
+            layout: Some(&outline_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &outline_shader,
+                entry_point: Some("vs_fullscreen"),
+                buffers: &[],
+                compilation_options: Default::default(),
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &outline_shader,
+                entry_point: Some("fs_outline"),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: surface_format,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+                compilation_options: Default::default(),
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleStrip,
+                ..Default::default()
+            },
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview_mask: None,
+            cache: None,
+        });
+
+        Self {
+            color_texture,
+            color_view,
+            object_id_texture,
+            object_id_view,
+            depth_texture,
+            depth_view,
+            outline_pipeline,
+            outline_bind_group,
+            outline_params_buffer,
+            outline_params,
+            sampler,
+            enabled: false,
+            width,
+            height,
+            selected_handles: Vec::new(),
+            hovered_handle: 0.0,
+            time: 0.0,
+        }
+    }
+
+    pub fn resize(&mut self, device: &wgpu::Device, width: u32, height: u32, surface_format: wgpu::TextureFormat) {
+        if width == self.width && height == self.height { return; }
+        *self = Self::new(device, width, height, surface_format);
+    }
+
+    pub fn set_selected(&mut self, handles: Vec<f64>) {
+        self.selected_handles = handles;
+    }
+
+    pub fn set_hovered(&mut self, handle: f64) {
+        self.hovered_handle = handle;
+    }
+
+    pub fn update(&mut self, queue: &wgpu::Queue, dt: f32) {
+        self.time += dt;
+        self.outline_params.thickness[2] = self.time;
+        queue.write_buffer(&self.outline_params_buffer, 0, bytemuck::bytes_of(&self.outline_params));
+    }
+}
+
+// ============================================================
+// Helpers
+// ============================================================
+
+fn create_color_target(device: &wgpu::Device, width: u32, height: u32, format: wgpu::TextureFormat) -> (wgpu::Texture, wgpu::TextureView) {
+    let tex = device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("postfx_color"),
+        size: wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
+    (tex, view)
+}
+
+fn create_depth_target(device: &wgpu::Device, width: u32, height: u32) -> (wgpu::Texture, wgpu::TextureView) {
+    let tex = device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("postfx_depth"),
+        size: wgpu::Extent3d { width, height, depth_or_array_layers: 1 },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Depth32Float,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    let view = tex.create_view(&wgpu::TextureViewDescriptor::default());
+    (tex, view)
+}
+
+fn bgl_texture(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::BindGroupLayoutEntry {
+    wgpu::BindGroupLayoutEntry {
+        binding,
+        visibility: wgpu::ShaderStages::FRAGMENT,
+        ty: wgpu::BindingType::Texture {
+            sample_type,
+            view_dimension: wgpu::TextureViewDimension::D2,
+            multisampled: false,
+        },
+        count: None,
+    }
+}
+
+fn bgl_sampler(binding: u32) -> wgpu::BindGroupLayoutEntry {
+    wgpu::BindGroupLayoutEntry {
+        binding,
+        visibility: wgpu::ShaderStages::FRAGMENT,
+        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+        count: None,
+    }
+}
+
+fn bgl_uniform(binding: u32) -> wgpu::BindGroupLayoutEntry {
+    wgpu::BindGroupLayoutEntry {
+        binding,
+        visibility: wgpu::ShaderStages::FRAGMENT,
+        ty: wgpu::BindingType::Buffer {
+            ty: wgpu::BufferBindingType::Uniform,
+            has_dynamic_offset: false,
+            min_binding_size: None,
+        },
+        count: None,
+    }
+}