fix: sorted texture binding

Cargo.toml

@@ -49,7 +49,7 @@ default = [
   "query_select",
   "query_sparse",
 
-  "sort_radix",
+  # "sort_radix",
   "sort_rayon",
   "sort_std",
 

src/morph/particle.rs

@@ -24,7 +24,15 @@ use bevy::{
             RenderAssets,
             RenderAssetPlugin,
         },
-        render_resource::*,
+        render_resource::{
+            Buffer,
+            BufferInitDescriptor,
+            BufferUsages,
+            Extent3d,
+            ShaderType,
+            TextureDimension,
+            TextureFormat,
+        },
         renderer::{
             RenderContext,
             RenderDevice,

src/render/gaussian.wgsl

@@ -48,12 +48,36 @@
     get_scale,
     get_opacity,
     get_visibility,
+    location,
 }
 #endif
 
 
+#ifdef BUFFER_STORAGE
 @group(3) @binding(0) var<storage, read> sorted_entries: array<Entry>;
 
+fn get_entry(index: u32) -> Entry {
+    return sorted_entries[index];
+}
+#endif
+
+#ifdef BUFFER_TEXTURE
+@group(3) @binding(0) var sorted_entries: texture_2d<u32>;
+
+fn get_entry(index: u32) -> Entry {
+    let sample = textureLoad(
+        sorted_entries,
+        location(index),
+        0,
+    );
+
+    return Entry(
+        sample.r,
+        sample.g,
+    );
+}
+#endif
+
 struct GaussianVertexOutput {
     @builtin(position) position: vec4<f32>,
     @location(0) @interpolate(flat) color: vec4<f32>,
@@ -239,11 +263,13 @@ fn vs_points(
     @builtin(vertex_index) vertex_index: u32,
 ) -> GaussianVertexOutput {
     var output: GaussianVertexOutput;
-    let splat_index = sorted_entries[instance_index][1];
+
+    let entry = get_entry(instance_index);
+    let splat_index = entry.value;
 
     var discard_quad = false;
 
-    discard_quad |= sorted_entries[instance_index][0] == 0xFFFFFFFFu; // || splat_index == 0u;
+    discard_quad |= entry.key == 0xFFFFFFFFu; // || splat_index == 0u;
 
     let position = vec4<f32>(get_position(splat_index), 1.0);
 
@@ -277,8 +303,8 @@ fn vs_points(
     var rgb = vec3<f32>(0.0);
 
 #ifdef VISUALIZE_DEPTH
-    let first_position = vec4<f32>(get_position(sorted_entries[1][1]), 1.0);
-    let last_position = vec4<f32>(get_position(sorted_entries[gaussian_uniforms.count - 1u][1]), 1.0);
+    let first_position = vec4<f32>(get_position(get_entry(1u).value), 1.0);
+    let last_position = vec4<f32>(get_position(get_entry(gaussian_uniforms.count - 1u).value), 1.0);
 
     let min_position = (gaussian_uniforms.global_transform * first_position).xyz;
     let max_position = (gaussian_uniforms.global_transform * last_position).xyz;

src/render/mod.rs

@@ -41,7 +41,43 @@ use bevy::{
             SetItemPipeline,
             TrackedRenderPass,
         },
-        render_resource::*,
+        render_resource::{
+            BindGroup,
+            BindGroupEntry,
+            BindGroupLayout,
+            BindGroupLayoutDescriptor,
+            BindGroupLayoutEntry,
+            BindingResource,
+            BindingType,
+            BlendState,
+            Buffer,
+            BufferBinding,
+            BufferBindingType,
+            BufferInitDescriptor,
+            BufferUsages,
+            ColorTargetState,
+            ColorWrites,
+            CompareFunction,
+            DepthBiasState,
+            DepthStencilState,
+            FragmentState,
+            FrontFace,
+            MultisampleState,
+            PipelineCache,
+            PolygonMode,
+            PrimitiveState,
+            PrimitiveTopology,
+            RenderPipelineDescriptor,
+            ShaderDefVal,
+            ShaderStages,
+            ShaderType,
+            SpecializedRenderPipeline,
+            SpecializedRenderPipelines,
+            StencilFaceState,
+            StencilState,
+            TextureFormat,
+            VertexState,
+        },
         renderer::RenderDevice,
         Render,
         RenderApp,
@@ -393,7 +429,7 @@ impl FromWorld for GaussianCloudPipeline {
         #[cfg(feature = "buffer_texture")]
         let gaussian_cloud_layout = texture::get_bind_group_layout(&render_device, read_only);
 
-        // TODO: support sorted layout as a texture
+        #[cfg(feature = "buffer_storage")]
         let sorted_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             label: Some("sorted_layout"),
             entries: &[
@@ -409,6 +445,8 @@ impl FromWorld for GaussianCloudPipeline {
                 },
             ],
         });
+        #[cfg(feature = "buffer_texture")]
+        let sorted_layout = texture::get_sorted_bind_group_layout(&render_device);
 
         GaussianCloudPipeline {
             gaussian_cloud_layout,
@@ -742,6 +780,9 @@ fn queue_gaussian_bind_group(
         &Handle<SortedEntries>,
         &texture::GpuTextureBuffers,
     )>,
+
+    #[cfg(feature = "buffer_texture")]
+    gpu_images: Res<RenderAssets<Image>>,
 ) {
     let Some(model) = gaussian_uniforms.buffer() else {
         return;
@@ -788,7 +829,9 @@ fn queue_gaussian_bind_group(
             continue;
         }
 
+        #[cfg(not(feature = "buffer_texture"))]
         let cloud: &GpuGaussianCloud = gaussian_cloud_res.get(cloud_handle).unwrap();
+
         let sorted_entries = sorted_entries_res.get(sorted_entries_handle).unwrap();
 
         #[cfg(feature = "packed")]
@@ -798,6 +841,7 @@ fn queue_gaussian_bind_group(
         #[cfg(feature = "buffer_texture")]
         let cloud_bind_group = texture_buffers.bind_group.clone();
 
+        #[cfg(feature = "buffer_storage")]
         let sorted_bind_group = render_device.create_bind_group(
             "render_sorted_bind_group",
             &gaussian_cloud_pipeline.sorted_layout,
@@ -812,6 +856,19 @@ fn queue_gaussian_bind_group(
                 },
             ],
         );
+        #[cfg(feature = "buffer_texture")]
+        let sorted_bind_group = render_device.create_bind_group(
+            Some("render_sorted_bind_group"),
+            &gaussian_cloud_pipeline.sorted_layout,
+            &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: BindingResource::TextureView(
+                        &gpu_images.get(&sorted_entries.texture).unwrap().texture_view
+                    ),
+                },
+            ],
+        );
 
         commands.entity(entity).insert(GaussianCloudBindGroup {
             cloud_bind_group,

src/render/packed.rs

@@ -1,5 +1,13 @@
 use bevy::render::{
-    render_resource::*,
+    render_resource::{
+        Buffer,
+        BufferInitDescriptor,
+        BufferUsages,
+        Extent3d,
+        ShaderType,
+        TextureDimension,
+        TextureFormat,
+    },
     renderer::RenderDevice,
 };
 

src/render/planar.rs

@@ -1,5 +1,13 @@
 use bevy::render::{
-    render_resource::*,
+    render_resource::{
+        Buffer,
+        BufferInitDescriptor,
+        BufferUsages,
+        Extent3d,
+        ShaderType,
+        TextureDimension,
+        TextureFormat,
+    },
     renderer::RenderDevice,
 };
 

src/render/texture.rs

@@ -11,7 +11,22 @@ use bevy::{
         RenderApp,
         RenderSet,
         render_asset::RenderAssets,
-        render_resource::*,
+        render_resource::{
+            BindGroup,
+            BindGroupLayout,
+            BindGroupLayoutDescriptor,
+            BindGroupLayoutEntry,
+            BindGroupEntry,
+            BindingType,
+            BindingResource,
+            Extent3d,
+            TextureDimension,
+            TextureFormat,
+            TextureSampleType,
+            TextureUsages,
+            TextureViewDimension,
+            ShaderStages,
+        },
         renderer::RenderDevice,
     },
 };
@@ -27,15 +42,15 @@ use crate::{
             ScaleOpacity,
         },
     },
-    render::{
-        GaussianCloudPipeline,
-        GpuGaussianCloud,
-    },
     material::spherical_harmonics::{
         SH_COEFF_COUNT,
         SH_VEC4_PLANES,
         SphericalHarmonicCoefficients,
     },
+    render::{
+        GaussianCloudPipeline,
+        GpuGaussianCloud,
+    },
 };
 
 
@@ -275,6 +290,27 @@ fn queue_textures(
 }
 
 
+pub fn get_sorted_bind_group_layout(
+    render_device: &RenderDevice,
+) -> BindGroupLayout {
+    render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        label: Some("texture_sorted_layout"),
+        entries: &[
+            BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::all(),
+                ty: BindingType::Texture {
+                    view_dimension: TextureViewDimension::D2,
+                    sample_type: TextureSampleType::Uint,
+                    multisampled: false,
+                },
+                count: None,
+            },
+        ],
+    })
+}
+
+
 #[cfg(feature = "f16")]
 pub fn get_bind_group_layout(
     render_device: &RenderDevice,
@@ -287,21 +323,23 @@ pub fn get_bind_group_layout(
     };
 
     render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-        label: Some("planar_f16_gaussian_cloud_layout"),
+        label: Some("texture_f16_gaussian_cloud_layout"),
         entries: &[
             BindGroupLayoutEntry {
                 binding: 0,
-                visibility: ShaderStages::VERTEX_FRAGMENT,
+                visibility: ShaderStages::all(),
                 ty: BindingType::Texture {
                     view_dimension: TextureViewDimension::D2,
-                    sample_type: TextureSampleType::Uint,
+                    sample_type: TextureSampleType::Float {
+                        filterable: false,
+                    },
                     multisampled: false,
                 },
                 count: None,
             },
             BindGroupLayoutEntry {
                 binding: 1,
-                visibility: ShaderStages::VERTEX_FRAGMENT,
+                visibility: ShaderStages::all(),
                 ty: BindingType::Texture {
                     view_dimension: sh_view_dimension,
                     sample_type: TextureSampleType::Uint,
@@ -311,7 +349,7 @@ pub fn get_bind_group_layout(
             },
             BindGroupLayoutEntry {
                 binding: 2,
-                visibility: ShaderStages::VERTEX_FRAGMENT,
+                visibility: ShaderStages::all(),
                 ty: BindingType::Texture {
                     view_dimension: TextureViewDimension::D2,
                     sample_type: TextureSampleType::Uint,
@@ -330,7 +368,7 @@ pub fn get_bind_group_layout(
     read_only: bool
 ) -> BindGroupLayout {
     render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-        label: Some("planar_f32_gaussian_cloud_layout"),
+        label: Some("texture_f32_gaussian_cloud_layout"),
         entries: &[
             BindGroupLayoutEntry {
                 binding: 0,