Merge master into optimize-draw-arrange

Author: DoubleStyx

.gitignore

@@ -21,6 +21,8 @@ mono_crash.*
 
 # Build results
 [Dd]ebug/
+!crates/renderide/src/config/types/debug/
+!crates/renderide/src/config/types/debug/*.rs
 [Dd]ebugPublic/
 [Rr]elease/
 [Rr]eleases/

crates/renderide/assets/xr/bindings/valve_index_controller.toml

@@ -36,10 +36,10 @@ path = "/user/hand/right/input/trigger/click"
 
 [[binding]]
 action = "left_squeeze"
-path = "/user/hand/left/input/squeeze/value"
+path = "/user/hand/left/input/squeeze/force"
 [[binding]]
 action = "right_squeeze"
-path = "/user/hand/right/input/squeeze/value"
+path = "/user/hand/right/input/squeeze/force"
 
 [[binding]]
 action = "left_thumbstick"

crates/renderide/build_support/shader.rs

@@ -24,7 +24,7 @@ mod model;
 mod modules;
 #[path = "shader/parallel.rs"]
 mod parallel;
-#[path = "../src/shader_package/schema.rs"]
+#[path = "../src/materials/shader_package/schema.rs"]
 mod shader_package_schema;
 #[path = "shader/source.rs"]
 mod source;

crates/renderide/build_support/shader/emit.rs

@@ -205,37 +205,37 @@ pub struct EmbeddedShaderReflection {
 fn embedded_shader_lookup_fn_defs() -> &'static str {
     r#"/// Flattened WGSL for `stem` from the runtime shader package.
 pub fn embedded_target_wgsl(stem: &str) -> Option<&'static str> {
-    crate::shader_package::target_wgsl(stem)
+    crate::materials::shader_package::target_wgsl(stem)
 }
 
 /// Declared render passes for `stem`, parsed from package TOML metadata.
 pub fn embedded_target_passes(stem: &str) -> &'static [crate::materials::MaterialPassDesc] {
-    crate::shader_package::material_passes(stem)
+    crate::materials::shader_package::material_passes(stem)
 }
 
 /// Shader default render queue for `stem`, parsed from package TOML metadata.
 pub fn embedded_target_default_render_queue(stem: &str) -> i32 {
-    crate::shader_package::material_default_render_queue(stem)
+    crate::materials::shader_package::material_default_render_queue(stem)
 }
 
 /// Required device features for `stem`, parsed from package TOML metadata.
 pub fn embedded_target_required_features(stem: &str) -> wgpu::Features {
-    crate::shader_package::target_required_features(stem)
+    crate::materials::shader_package::target_required_features(stem)
 }
 
 /// Declared texture fallbacks for `stem`, parsed from package TOML metadata.
 pub fn embedded_target_texture_defaults(stem: &str) -> &'static [EmbeddedTextureDefault] {
-    crate::shader_package::material_texture_defaults(stem)
+    crate::materials::shader_package::material_texture_defaults(stem)
 }
 
 /// Declared material uniform fallbacks for `stem`, parsed from package TOML metadata.
 pub fn embedded_target_material_defaults(stem: &str) -> &'static [EmbeddedMaterialDefault] {
-    crate::shader_package::material_uniform_defaults(stem)
+    crate::materials::shader_package::material_uniform_defaults(stem)
 }
 
 /// Stable reflection metadata for `stem`, reflected from WGSL with Naga at runtime.
 pub fn embedded_target_reflection(stem: &str) -> EmbeddedShaderReflection {
-    crate::shader_package::material_reflection(stem)
+    crate::materials::shader_package::material_reflection(stem)
 }
 "#
 }
@@ -410,7 +410,7 @@ mod tests {
         assert!(!embedded.contains("pub fn embedded_target_desc"));
         assert!(embedded.contains("pub fn embedded_target_reflection"));
         assert!(embedded.contains("macro_rules! embedded_wgsl"));
-        assert!(embedded.contains("crate::shader_package::target_wgsl"));
+        assert!(embedded.contains("crate::materials::shader_package::target_wgsl"));
         assert!(!embedded.contains("wgsl body"));
         assert!(!embedded.contains("pub const OUTLINE_DEFAULT_WGSL"));
         Ok(())

crates/renderide/shaders/materials/billboardunlit.wgsl

@@ -378,7 +378,7 @@ fn vs_main(
 }
 
 fn main_st(view_layer: u32) -> vec4<f32> {
-    if (kw_RIGHT_EYE_ST() && view_layer != 0u) {
+    if (kw_RIGHT_EYE_ST() && rg::view_layer_is_right_eye(view_layer)) {
         return mat._RightEye_ST;
     }
     return mat._Tex_ST;

crates/renderide/shaders/materials/reflection.wgsl

@@ -1,8 +1,8 @@
 //! Unity `Shader "Reflection"`: samples a host-provided 2D reflection texture in screen space,
 //! optionally distorted by a tangent-space normal map. **Not a grab pass** -- `_ReflectionTex` is a
 //! regular `sampler2D`, populated by the host with whatever reflection RT (planar, cubemap-projected,
-//! etc.) is available. Multi-view eye separation is handled by the renderer's per-eye render pass,
-//! not the side-by-side `eyeIndex` texture-coordinate offset Unity needs for single-pass stereo.
+//! etc.) is available. VR camera portals render left/right mirror eyes into side-by-side halves of
+//! the same host render texture, matching Unity's non-single-pass fallback.
 //!
 //! Froox variant bits populate `_RenderideVariantBits`; this shader decodes Reflection's
 //! shader-specific keyword bits locally. `_OFFSET_TEXTURE` is reserved in the bit table so the
@@ -60,6 +60,7 @@ struct VertexOutput {
     @builtin(position) clip_pos: vec4<f32>,
     @location(0) screen_uv: vec3<f32>,
     @location(1) uv: vec2<f32>,
+    @location(2) @interpolate(flat) view_layer: u32,
 }
 
 @vertex
@@ -80,33 +81,54 @@ fn vs_main(
     let vp = mv::select_view_proj(d, 0u);
 #endif
     let clip = vp * world_p;
+#ifdef MULTIVIEW
+    let view_layer = view_idx;
+    let screen_y = (clip.y + clip.w) * 0.5;
+#else
+    let view_layer = 0u;
+    let screen_y = (clip.w - clip.y) * 0.5;
+#endif
     var out: VertexOutput;
     out.clip_pos = clip;
-    // Equivalent of Unity's ComputeNonStereoScreenPos: ((clip.xy * vec2(1, -1) + clip.w) * 0.5, w)
-    // packed into xy/z so the fragment can do uv/w to get [0..1] screen UV.
+    // Unity ComputeNonStereoScreenPos with the projection sign matching the active target path.
     out.screen_uv = vec3<f32>(
         (clip.x + clip.w) * 0.5,
-        (clip.w - clip.y) * 0.5,
+        screen_y,
         clip.w,
     );
     out.uv = uvu::apply_st(uv, mat._NormalMap_ST);
+    out.view_layer = view_layer;
     return out;
 }
 
+fn projected_reflection_uv(screen_uv: vec3<f32>) -> vec2<f32> {
+    return screen_uv.xy / max(screen_uv.z, 1e-4);
+}
+
+fn reflection_texture_uv(screen: vec2<f32>, view_layer: u32) -> vec2<f32> {
+    var uv = screen;
+#ifdef MULTIVIEW
+    uv.x = uv.x * 0.5 + f32(view_layer) * 0.5;
+#endif
+    return uv;
+}
+
 //#pass type=forward blend=material_filter a2c=cutout
 @fragment
 fn fs_main(
     @location(0) screen_uv: vec3<f32>,
     @location(1) uv: vec2<f32>,
+    @location(2) @interpolate(flat) view_layer: u32,
 ) -> @location(0) vec4<f32> {
-    var screen = screen_uv.xy / max(screen_uv.z, 1e-4);
+    var screen = projected_reflection_uv(screen_uv);
     if (kw_NORMALMAP()) {
         let bump = nd::decode_ts_normal_with_placeholder_sample(
             ts::sample_tex_2d(_NormalMap, _NormalMap_sampler, uv, mat._NormalMap_LodBias),
             1.0,
         );
         screen = screen + bump.xy * mat._Distort;
     }
+    screen = reflection_texture_uv(screen, view_layer);
     var col = textureSample(_ReflectionTex, _ReflectionTex_sampler, screen);
     if (kw_COLOR()) {
         col = col * mat._Color;

crates/renderide/shaders/materials/unlit.wgsl

@@ -105,7 +105,7 @@ fn vs_main(
 }
 
 fn main_texture_st(view_layer: u32) -> vec4<f32> {
-    if (kw_RIGHT_EYE_ST() && view_layer != 0u) {
+    if (kw_RIGHT_EYE_ST() && rg::view_layer_is_right_eye(view_layer)) {
         return mat._RightEye_ST;
     }
     return mat._Tex_ST;

crates/renderide/shaders/modules/frame/globals.wgsl

@@ -7,7 +7,8 @@
 //! layout at pipeline creation for storage-backed frame resources.
 //!
 //! CPU packing must match [`crate::gpu::frame_globals::FrameGpuUniforms`],
-//! [`crate::backend::light_gpu::GpuLight`], and [`crate::backend::cluster_gpu`] cluster buffers.
+//! [`crate::backend::light_gpu::GpuLight`], [`crate::gpu::GpuLightCookieRect`], and
+//! [`crate::backend::cluster_gpu`] cluster buffers.
 
 #define_import_path renderide::frame::globals
 
@@ -26,12 +27,13 @@
 @group(0) @binding(10) var reflection_probe_specular_sampler: sampler;
 @group(0) @binding(11) var ibl_dfg_lut: texture_2d<f32>;
 @group(0) @binding(12) var<storage, read> reflection_probes: array<ft::GpuReflectionProbe>;
-@group(0) @binding(13) var light_cookie_2d_atlas: texture_2d_array<f32>;
-@group(0) @binding(14) var light_cookie_point_atlas: texture_2d_array<f32>;
+@group(0) @binding(13) var light_cookie_2d_atlas: texture_2d<f32>;
+@group(0) @binding(14) var light_cookie_point_atlas: texture_2d<f32>;
 @group(0) @binding(15) var light_cookie_sampler: sampler;
 @group(0) @binding(16) var<storage, read> shadow_views: array<ft::GpuShadowView>;
 @group(0) @binding(17) var shadow_atlas: texture_depth_2d_array;
 @group(0) @binding(18) var shadow_sampler: sampler_comparison;
+@group(0) @binding(19) var<storage, read> light_cookie_rects: array<ft::GpuLightCookieRect>;
 
 /// View index encoded in a material varying.
 fn view_index_from_layer(view_layer: u32) -> u32 {
@@ -43,10 +45,19 @@ fn draw_index_from_layer(view_layer: u32) -> u32 {
     return view_layer >> 1u;
 }
 
+/// Returns true when the encoded material view layer targets the right eye.
+fn view_layer_is_right_eye(view_layer: u32) -> bool {
+#ifdef MULTIVIEW
+    return view_index_from_layer(view_layer) != 0u;
+#else
+    return false;
+#endif
+}
+
 /// World-space camera position for the current view layer.
 fn camera_world_pos_for_view(view_layer: u32) -> vec3<f32> {
 #ifdef MULTIVIEW
-    if (view_index_from_layer(view_layer) != 0u) {
+    if (view_layer_is_right_eye(view_layer)) {
         return frame.camera_world_pos_right.xyz;
     }
 #endif
@@ -65,7 +76,7 @@ fn stereo_center_camera_world_pos() -> vec3<f32> {
 /// World -> view-space Z coefficients for the current view layer.
 fn view_space_z_coeffs_for_view(view_layer: u32) -> vec4<f32> {
 #ifdef MULTIVIEW
-    if (view_index_from_layer(view_layer) != 0u) {
+    if (view_layer_is_right_eye(view_layer)) {
         return frame.view_space_z_coeffs_right;
     }
 #endif
@@ -75,7 +86,7 @@ fn view_space_z_coeffs_for_view(view_layer: u32) -> vec4<f32> {
 /// View -> world-space Y coefficients for the current view layer.
 fn view_to_world_y_coeffs_for_view(view_layer: u32) -> vec4<f32> {
 #ifdef MULTIVIEW
-    if (view_index_from_layer(view_layer) != 0u) {
+    if (view_layer_is_right_eye(view_layer)) {
         return frame.view_to_world_y_coeffs_right;
     }
 #endif
@@ -85,7 +96,7 @@ fn view_to_world_y_coeffs_for_view(view_layer: u32) -> vec4<f32> {
 /// Projection coefficients for the current view layer.
 fn proj_params_for_view(view_layer: u32) -> vec4<f32> {
 #ifdef MULTIVIEW
-    if (view_index_from_layer(view_layer) != 0u) {
+    if (view_layer_is_right_eye(view_layer)) {
         return frame.proj_params_right;
     }
 #endif
@@ -95,7 +106,7 @@ fn proj_params_for_view(view_layer: u32) -> vec4<f32> {
 /// Projection matrix for the current view layer.
 fn projection_for_view(view_layer: u32) -> mat4x4<f32> {
 #ifdef MULTIVIEW
-    if (view_index_from_layer(view_layer) != 0u) {
+    if (view_layer_is_right_eye(view_layer)) {
         return frame.proj_right;
     }
 #endif
@@ -105,7 +116,7 @@ fn projection_for_view(view_layer: u32) -> mat4x4<f32> {
 /// Projection flags for the current view layer.
 fn projection_flags_for_view(view_layer: u32) -> u32 {
 #ifdef MULTIVIEW
-    if (view_index_from_layer(view_layer) != 0u) {
+    if (view_layer_is_right_eye(view_layer)) {
         return frame.frame_tail.z;
     }
 #endif
@@ -174,7 +185,8 @@ fn retain_globals_additive(color: vec4<f32>) -> vec4<f32> {
         f32(cluster_light_indices[0u] & 255u) * 1e-10;
     let probe_touch = reflection_probes[0u].params.x * 1e-10;
     let cookie_touch =
-        textureSampleLevel(light_cookie_2d_atlas, light_cookie_sampler, vec2<f32>(0.5), 0, 0.0).r * 1e-10 +
-        textureSampleLevel(light_cookie_point_atlas, light_cookie_sampler, vec2<f32>(0.5), 0, 0.0).r * 1e-10;
+        textureSampleLevel(light_cookie_2d_atlas, light_cookie_sampler, vec2<f32>(0.5), 0.0).r * 1e-10 +
+        textureSampleLevel(light_cookie_point_atlas, light_cookie_sampler, vec2<f32>(0.5), 0.0).r * 1e-10 +
+        light_cookie_rects[0u].origin_scale.x * 1e-10;
     return color + vec4<f32>(vec3<f32>(f32(lit) * 1e-10 + cluster_touch + probe_touch + cookie_touch), 0.0);
 }

crates/renderide/shaders/modules/frame/types.wgsl

@@ -55,6 +55,10 @@ struct GpuShadowView {
     light_params: vec4<f32>,
 }
 
+struct GpuLightCookieRect {
+    origin_scale: vec4<f32>,
+}
+
 struct GpuReflectionProbe {
     /// World-space AABB minimum; `.w` stores the sanitized blend distance.
     box_min: vec4<f32>,

crates/renderide/shaders/modules/lighting/light_cookies.wgsl

@@ -39,12 +39,16 @@ fn wrap_cookie_uv(uv: vec2<f32>, bits: u32) -> vec2<f32> {
     );
 }
 
+fn atlas_cookie_uv(rect_index: u32, uv: vec2<f32>) -> vec2<f32> {
+    let rect = rg::light_cookie_rects[rect_index].origin_scale;
+    return rect.xy + uv * rect.zw;
+}
+
 fn sample_2d_cookie(light: ft::GpuLight, uv: vec2<f32>) -> f32 {
     return textureSample(
         rg::light_cookie_2d_atlas,
         rg::light_cookie_sampler,
-        wrap_cookie_uv(uv, light.cookie_reserved),
-        i32(light.cookie_layer),
+        atlas_cookie_uv(light.cookie_layer, wrap_cookie_uv(uv, light.cookie_reserved)),
     ).r;
 }
 
@@ -114,8 +118,12 @@ fn point_cookie_multiplier(light: ft::GpuLight, world_pos: vec3<f32>) -> f32 {
         dot(from_light, light.direction),
     ) * inverseSqrt(len_sq);
     let face_uv = cube_face_uv(local);
-    let layer = light.cookie_layer + u32(face_uv.z);
-    return textureSample(rg::light_cookie_point_atlas, rg::light_cookie_sampler, face_uv.xy, i32(layer)).r;
+    let rect_index = light.cookie_layer + u32(face_uv.z);
+    return textureSample(
+        rg::light_cookie_point_atlas,
+        rg::light_cookie_sampler,
+        atlas_cookie_uv(rect_index, face_uv.xy),
+    ).r;
 }
 
 fn multiplier(light: ft::GpuLight, world_pos: vec3<f32>) -> f32 {