summaryrefslogtreecommitdiff
path: root/assets
diff options
context:
space:
mode:
Diffstat (limited to 'assets')
-rw-r--r--assets/common/shaders/common_uniforms.wgsl25
-rw-r--r--assets/common/shaders/compute/gen_blend.wgsl29
-rw-r--r--assets/common/shaders/compute/gen_grid.wgsl24
-rw-r--r--assets/common/shaders/compute/gen_mask.wgsl27
-rw-r--r--assets/common/shaders/compute/gen_noise.wgsl26
-rw-r--r--assets/common/shaders/compute/gen_perlin.wgsl44
-rw-r--r--assets/common/shaders/math/common_utils.wgsl36
-rw-r--r--assets/common/shaders/math/noise.wgsl147
-rw-r--r--assets/common/shaders/math/sdf_shapes.wgsl14
-rw-r--r--assets/common/shaders/math/sdf_utils.wgsl115
-rw-r--r--assets/common/shaders/render/lighting_utils.wgsl6
-rw-r--r--assets/common/shaders/render/scene_query_bvh.wgsl67
-rw-r--r--assets/common/shaders/render/scene_query_linear.wgsl56
-rw-r--r--assets/common/shaders/render/shadows.wgsl13
14 files changed, 629 insertions, 0 deletions
diff --git a/assets/common/shaders/common_uniforms.wgsl b/assets/common/shaders/common_uniforms.wgsl
new file mode 100644
index 0000000..ce1be53
--- /dev/null
+++ b/assets/common/shaders/common_uniforms.wgsl
@@ -0,0 +1,25 @@
+struct CommonUniforms {
+ resolution: vec2<f32>,
+ _pad0: f32,
+ _pad1: f32,
+ aspect_ratio: f32,
+ time: f32,
+ beat: f32,
+ audio_intensity: f32,
+};
+struct GlobalUniforms {
+ view_proj: mat4x4<f32>,
+ inv_view_proj: mat4x4<f32>,
+ camera_pos_time: vec4<f32>,
+ params: vec4<f32>,
+ resolution: vec2<f32>,
+};
+struct ObjectData {
+ model: mat4x4<f32>,
+ inv_model: mat4x4<f32>,
+ color: vec4<f32>,
+ params: vec4<f32>,
+};
+struct ObjectsBuffer {
+ objects: array<ObjectData>,
+}; \ No newline at end of file
diff --git a/assets/common/shaders/compute/gen_blend.wgsl b/assets/common/shaders/compute/gen_blend.wgsl
new file mode 100644
index 0000000..9fc9e1e
--- /dev/null
+++ b/assets/common/shaders/compute/gen_blend.wgsl
@@ -0,0 +1,29 @@
+// This file is part of the 64k demo project.
+// GPU composite shader: Blend two textures.
+
+struct BlendParams {
+ width: u32,
+ height: u32,
+ blend_factor: f32,
+ _pad0: f32,
+}
+
+@group(0) @binding(0) var output_tex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: BlendParams;
+@group(0) @binding(2) var input_a: texture_2d<f32>;
+@group(0) @binding(3) var input_b: texture_2d<f32>;
+@group(0) @binding(4) var tex_sampler: sampler;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+ if (id.x >= params.width || id.y >= params.height) { return; }
+
+ let uv = vec2<f32>(f32(id.x) / f32(params.width),
+ f32(id.y) / f32(params.height));
+
+ let color_a = textureSampleLevel(input_a, tex_sampler, uv, 0.0);
+ let color_b = textureSampleLevel(input_b, tex_sampler, uv, 0.0);
+ let blended = mix(color_a, color_b, params.blend_factor);
+
+ textureStore(output_tex, id.xy, blended);
+}
diff --git a/assets/common/shaders/compute/gen_grid.wgsl b/assets/common/shaders/compute/gen_grid.wgsl
new file mode 100644
index 0000000..cc5e189
--- /dev/null
+++ b/assets/common/shaders/compute/gen_grid.wgsl
@@ -0,0 +1,24 @@
+// GPU procedural grid pattern generator.
+// Simple grid lines with configurable spacing and thickness.
+
+struct GridParams {
+ width: u32,
+ height: u32,
+ grid_size: u32,
+ thickness: u32,
+}
+
+@group(0) @binding(0) var output_tex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: GridParams;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+ if (id.x >= params.width || id.y >= params.height) { return; }
+
+ let on_line = (id.x % params.grid_size) < params.thickness ||
+ (id.y % params.grid_size) < params.thickness;
+
+ let val = select(0.0, 1.0, on_line);
+
+ textureStore(output_tex, id.xy, vec4<f32>(val, val, val, 1.0));
+}
diff --git a/assets/common/shaders/compute/gen_mask.wgsl b/assets/common/shaders/compute/gen_mask.wgsl
new file mode 100644
index 0000000..1ce9f52
--- /dev/null
+++ b/assets/common/shaders/compute/gen_mask.wgsl
@@ -0,0 +1,27 @@
+// This file is part of the 64k demo project.
+// GPU composite shader: Multiply texture A by texture B (masking).
+
+struct MaskParams {
+ width: u32,
+ height: u32,
+}
+
+@group(0) @binding(0) var output_tex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: MaskParams;
+@group(0) @binding(2) var input_a: texture_2d<f32>;
+@group(0) @binding(3) var input_b: texture_2d<f32>;
+@group(0) @binding(4) var tex_sampler: sampler;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+ if (id.x >= params.width || id.y >= params.height) { return; }
+
+ let uv = vec2<f32>(f32(id.x) / f32(params.width),
+ f32(id.y) / f32(params.height));
+
+ let color_a = textureSampleLevel(input_a, tex_sampler, uv, 0.0);
+ let mask_b = textureSampleLevel(input_b, tex_sampler, uv, 0.0);
+ let masked = color_a * mask_b;
+
+ textureStore(output_tex, id.xy, masked);
+}
diff --git a/assets/common/shaders/compute/gen_noise.wgsl b/assets/common/shaders/compute/gen_noise.wgsl
new file mode 100644
index 0000000..5c0babd
--- /dev/null
+++ b/assets/common/shaders/compute/gen_noise.wgsl
@@ -0,0 +1,26 @@
+// GPU procedural noise texture generator.
+// Uses compute shader for parallel texture generation.
+
+#include "math/noise"
+
+struct NoiseParams {
+ width: u32,
+ height: u32,
+ seed: f32,
+ frequency: f32,
+}
+
+@group(0) @binding(0) var output_tex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: NoiseParams;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+ if (id.x >= params.width || id.y >= params.height) { return; }
+
+ let uv = vec2<f32>(f32(id.x) / f32(params.width),
+ f32(id.y) / f32(params.height));
+ let p = uv * params.frequency + params.seed;
+ let noise = noise_2d(p);
+
+ textureStore(output_tex, id.xy, vec4<f32>(noise, noise, noise, 1.0));
+}
diff --git a/assets/common/shaders/compute/gen_perlin.wgsl b/assets/common/shaders/compute/gen_perlin.wgsl
new file mode 100644
index 0000000..73816d6
--- /dev/null
+++ b/assets/common/shaders/compute/gen_perlin.wgsl
@@ -0,0 +1,44 @@
+// GPU procedural Perlin noise texture generator.
+// Fractional Brownian Motion using value noise.
+
+#include "math/noise"
+
+struct PerlinParams {
+ width: u32,
+ height: u32,
+ seed: f32,
+ frequency: f32,
+ amplitude: f32,
+ amplitude_decay: f32,
+ octaves: u32,
+ _pad0: f32, // Padding for alignment
+}
+
+@group(0) @binding(0) var output_tex: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(1) var<uniform> params: PerlinParams;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+ if (id.x >= params.width || id.y >= params.height) { return; }
+
+ let uv = vec2<f32>(f32(id.x) / f32(params.width),
+ f32(id.y) / f32(params.height));
+
+ var value = 0.0;
+ var amplitude = params.amplitude;
+ var frequency = params.frequency;
+ var total_amp = 0.0;
+
+ for (var o: u32 = 0u; o < params.octaves; o++) {
+ let p = uv * frequency + params.seed;
+ value += noise_2d(p) * amplitude;
+ total_amp += amplitude;
+ frequency *= 2.0;
+ amplitude *= params.amplitude_decay;
+ }
+
+ value /= total_amp;
+ let clamped = clamp(value, 0.0, 1.0);
+
+ textureStore(output_tex, id.xy, vec4<f32>(clamped, clamped, clamped, 1.0));
+}
diff --git a/assets/common/shaders/math/common_utils.wgsl b/assets/common/shaders/math/common_utils.wgsl
new file mode 100644
index 0000000..7131216
--- /dev/null
+++ b/assets/common/shaders/math/common_utils.wgsl
@@ -0,0 +1,36 @@
+// Common utility functions for WGSL shaders.
+// Reduces duplication across renderer_3d, mesh_render, etc.
+
+// Constants
+const PI: f32 = 3.14159265359;
+const TAU: f32 = 6.28318530718;
+
+// Transform normal from local to world space using inverse model matrix
+fn transform_normal(inv_model: mat4x4<f32>, normal_local: vec3<f32>) -> vec3<f32> {
+ let normal_matrix = mat3x3<f32>(inv_model[0].xyz, inv_model[1].xyz, inv_model[2].xyz);
+ return normalize(normal_matrix * normal_local);
+}
+
+// Spherical UV mapping (sphere or any radial surface)
+// Returns UV in [0,1] range
+fn spherical_uv(p: vec3<f32>) -> vec2<f32> {
+ let u = atan2(p.x, p.z) / TAU + 0.5;
+ let v = acos(clamp(p.y / length(p), -1.0, 1.0)) / PI;
+ return vec2<f32>(u, v);
+}
+
+// Spherical UV from direction vector (for skybox, etc.)
+fn spherical_uv_from_dir(dir: vec3<f32>) -> vec2<f32> {
+ let u = atan2(dir.z, dir.x) / TAU + 0.5;
+ let v = asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5;
+ return vec2<f32>(u, v);
+}
+
+// Grid pattern for procedural texturing (checkerboard-like)
+fn grid_pattern(uv: vec2<f32>) -> f32 {
+ let grid = 0.5 + 0.5 * sin(uv.x * PI) * sin(uv.y * PI);
+ return smoothstep(0.45, 0.55, grid);
+}
+
+// NOTE: calc_sdf_normal_bumped() removed - too specialized, depends on get_dist()
+// from scene_query snippets. Keep bump mapping code inline in shaders that use it.
diff --git a/assets/common/shaders/math/noise.wgsl b/assets/common/shaders/math/noise.wgsl
new file mode 100644
index 0000000..9f99e4a
--- /dev/null
+++ b/assets/common/shaders/math/noise.wgsl
@@ -0,0 +1,147 @@
+// Random number generation and noise functions for WGSL shaders.
+// Collection of hash functions and noise generators.
+
+// ============================================
+// Hash Functions (Float Input)
+// ============================================
+
+// Hash: f32 -> f32
+// Fast fractional hash for floats
+fn hash_1f(x: f32) -> f32 {
+ var v = fract(x * 0.3351);
+ v *= v + 33.33;
+ v *= v + v;
+ return fract(v);
+}
+
+// Hash: vec2<f32> -> f32
+// 2D coordinate to single hash value
+fn hash_2f(p: vec2<f32>) -> f32 {
+ var h = dot(p, vec2<f32>(127.1, 311.7));
+ return fract(sin(h) * 43758.5453123);
+}
+
+// Hash: vec2<f32> -> vec2<f32>
+// 2D coordinate to 2D hash (from Shadertoy 4djSRW)
+fn hash_2f_2f(p: vec2<f32>) -> vec2<f32> {
+ var p3 = fract(vec3<f32>(p.x, p.y, p.x) * vec3<f32>(0.1021, 0.1013, 0.0977));
+ p3 += dot(p3, p3.yzx + 33.33);
+ return fract((p3.xx + p3.yz) * p3.zy);
+}
+
+// Hash: vec3<f32> -> f32
+// 3D coordinate to single hash value
+fn hash_3f(p: vec3<f32>) -> f32 {
+ var h = dot(p, vec3<f32>(127.1, 311.7, 74.7));
+ return fract(sin(h) * 43758.5453123);
+}
+
+// Hash: vec3<f32> -> vec3<f32>
+// 3D coordinate to 3D hash
+fn hash_3f_3f(p: vec3<f32>) -> vec3<f32> {
+ var v = fract(p);
+ v += dot(v, v.yxz + 32.41);
+ return fract((v.xxy + v.yzz) * v.zyx);
+}
+
+// ============================================
+// Hash Functions (Integer Input)
+// ============================================
+
+// Hash: u32 -> f32
+// Integer hash with bit operations (high quality)
+fn hash_1u(p: u32) -> f32 {
+ var P = (p << 13u) ^ p;
+ P = P * (P * P * 15731u + 789221u) + 1376312589u;
+ return bitcast<f32>((P >> 9u) | 0x3f800000u) - 1.0;
+}
+
+// Hash: u32 -> vec2<f32>
+fn hash_1u_2f(p: u32) -> vec2<f32> {
+ return vec2<f32>(hash_1u(p), hash_1u(p + 1423u));
+}
+
+// Hash: u32 -> vec3<f32>
+fn hash_1u_3f(p: u32) -> vec3<f32> {
+ return vec3<f32>(hash_1u(p), hash_1u(p + 1423u), hash_1u(p + 124453u));
+}
+
+// ============================================
+// Noise Functions
+// ============================================
+
+// Value Noise: 2D
+// Interpolated grid noise using smoothstep
+fn noise_2d(p: vec2<f32>) -> f32 {
+ let i = floor(p);
+ let f = fract(p);
+ let u = f * f * (3.0 - 2.0 * f);
+ let n0 = hash_2f(i + vec2<f32>(0.0, 0.0));
+ let n1 = hash_2f(i + vec2<f32>(1.0, 0.0));
+ let n2 = hash_2f(i + vec2<f32>(0.0, 1.0));
+ let n3 = hash_2f(i + vec2<f32>(1.0, 1.0));
+ let ix0 = mix(n0, n1, u.x);
+ let ix1 = mix(n2, n3, u.x);
+ return mix(ix0, ix1, u.y);
+}
+
+// Value Noise: 3D
+fn noise_3d(p: vec3<f32>) -> f32 {
+ let i = floor(p);
+ let f = fract(p);
+ let u = f * f * (3.0 - 2.0 * f);
+ let n000 = hash_3f(i + vec3<f32>(0.0, 0.0, 0.0));
+ let n100 = hash_3f(i + vec3<f32>(1.0, 0.0, 0.0));
+ let n010 = hash_3f(i + vec3<f32>(0.0, 1.0, 0.0));
+ let n110 = hash_3f(i + vec3<f32>(1.0, 1.0, 0.0));
+ let n001 = hash_3f(i + vec3<f32>(0.0, 0.0, 1.0));
+ let n101 = hash_3f(i + vec3<f32>(1.0, 0.0, 1.0));
+ let n011 = hash_3f(i + vec3<f32>(0.0, 1.0, 1.0));
+ let n111 = hash_3f(i + vec3<f32>(1.0, 1.0, 1.0));
+ let ix00 = mix(n000, n100, u.x);
+ let ix10 = mix(n010, n110, u.x);
+ let ix01 = mix(n001, n101, u.x);
+ let ix11 = mix(n011, n111, u.x);
+ let iy0 = mix(ix00, ix10, u.y);
+ let iy1 = mix(ix01, ix11, u.y);
+ return mix(iy0, iy1, u.z);
+}
+
+// ============================================
+// Special Functions
+// ============================================
+
+// Gyroid function (periodic triply-orthogonal minimal surface)
+// Useful for procedural patterns and cellular structures
+fn gyroid(p: vec3<f32>) -> f32 {
+ return abs(0.04 + dot(sin(p), cos(p.zxy)));
+}
+
+// Fractional Brownian Motion (FBM) 2D
+// Multi-octave noise for natural-looking variation
+fn fbm_2d(p: vec2<f32>, octaves: i32) -> f32 {
+ var value = 0.0;
+ var amplitude = 0.5;
+ var frequency = 1.0;
+ var pos = p;
+ for (var i = 0; i < octaves; i++) {
+ value += amplitude * noise_2d(pos * frequency);
+ frequency *= 2.0;
+ amplitude *= 0.5;
+ }
+ return value;
+}
+
+// Fractional Brownian Motion (FBM) 3D
+fn fbm_3d(p: vec3<f32>, octaves: i32) -> f32 {
+ var value = 0.0;
+ var amplitude = 0.5;
+ var frequency = 1.0;
+ var pos = p;
+ for (var i = 0; i < octaves; i++) {
+ value += amplitude * noise_3d(pos * frequency);
+ frequency *= 2.0;
+ amplitude *= 0.5;
+ }
+ return value;
+}
diff --git a/assets/common/shaders/math/sdf_shapes.wgsl b/assets/common/shaders/math/sdf_shapes.wgsl
new file mode 100644
index 0000000..31bbe2d
--- /dev/null
+++ b/assets/common/shaders/math/sdf_shapes.wgsl
@@ -0,0 +1,14 @@
+fn sdSphere(p: vec3<f32>, r: f32) -> f32 {
+ return length(p) - r;
+}
+fn sdBox(p: vec3<f32>, b: vec3<f32>) -> f32 {
+ let q = abs(p) - b;
+ return length(max(q, vec3<f32>(0.0))) + min(max(q.x, max(q.y, q.z)), 0.0);
+}
+fn sdTorus(p: vec3<f32>, t: vec2<f32>) -> f32 {
+ let q = vec2<f32>(length(p.xz) - t.x, p.y);
+ return length(q) - t.y;
+}
+fn sdPlane(p: vec3<f32>, n: vec3<f32>, h: f32) -> f32 {
+ return dot(p, n) + h;
+}
diff --git a/assets/common/shaders/math/sdf_utils.wgsl b/assets/common/shaders/math/sdf_utils.wgsl
new file mode 100644
index 0000000..660a4ce
--- /dev/null
+++ b/assets/common/shaders/math/sdf_utils.wgsl
@@ -0,0 +1,115 @@
+fn get_normal_basic(p: vec3<f32>, obj_params: vec4<f32>) -> vec3<f32> {
+ let obj_type = obj_params.x;
+ if (obj_type == 1.0) { return normalize(p); }
+ let e = vec2<f32>(0.001, 0.0);
+ return normalize(vec3<f32>(
+ get_dist(p + e.xyy, obj_params) - get_dist(p - e.xyy, obj_params),
+ get_dist(p + e.yxy, obj_params) - get_dist(p - e.yxy, obj_params),
+ get_dist(p + e.yyx, obj_params) - get_dist(p - e.yyx, obj_params)
+ ));
+}
+
+// Optimized normal estimation using tetrahedron pattern (4 SDF evals instead of 6).
+// Slightly less accurate than central differences but faster.
+// Uses tetrahedral gradient approximation with corners at (±1, ±1, ±1).
+fn get_normal_fast(p: vec3<f32>, obj_params: vec4<f32>) -> vec3<f32> {
+ let obj_type = obj_params.x;
+ if (obj_type == 1.0) { return normalize(p); }
+ let eps = 0.0001;
+ let k = vec2<f32>(1.0, -1.0);
+ return normalize(
+ k.xyy * get_dist(p + k.xyy * eps, obj_params) +
+ k.yyx * get_dist(p + k.yyx * eps, obj_params) +
+ k.yxy * get_dist(p + k.yxy * eps, obj_params) +
+ k.xxx * get_dist(p + k.xxx * eps, obj_params)
+ );
+}
+
+// Bump-mapped normal using central differences (6 samples: SDF + texture).
+// High quality, suitable for detailed surfaces with displacement mapping.
+// Note: Requires spherical_uv() function and get_dist() to be available in calling context.
+fn get_normal_bump(
+ p: vec3<f32>,
+ obj_params: vec4<f32>,
+ noise_tex: texture_2d<f32>,
+ noise_sampler: sampler,
+ disp_strength: f32
+) -> vec3<f32> {
+ let e = vec2<f32>(0.005, 0.0);
+
+ let q_x1 = p + e.xyy;
+ let uv_x1 = spherical_uv(q_x1);
+ let h_x1 = textureSample(noise_tex, noise_sampler, uv_x1).r;
+ let d_x1 = get_dist(q_x1, obj_params) - disp_strength * h_x1;
+
+ let q_x2 = p - e.xyy;
+ let uv_x2 = spherical_uv(q_x2);
+ let h_x2 = textureSample(noise_tex, noise_sampler, uv_x2).r;
+ let d_x2 = get_dist(q_x2, obj_params) - disp_strength * h_x2;
+
+ let q_y1 = p + e.yxy;
+ let uv_y1 = spherical_uv(q_y1);
+ let h_y1 = textureSample(noise_tex, noise_sampler, uv_y1).r;
+ let d_y1 = get_dist(q_y1, obj_params) - disp_strength * h_y1;
+
+ let q_y2 = p - e.yxy;
+ let uv_y2 = spherical_uv(q_y2);
+ let h_y2 = textureSample(noise_tex, noise_sampler, uv_y2).r;
+ let d_y2 = get_dist(q_y2, obj_params) - disp_strength * h_y2;
+
+ let q_z1 = p + e.yyx;
+ let uv_z1 = spherical_uv(q_z1);
+ let h_z1 = textureSample(noise_tex, noise_sampler, uv_z1).r;
+ let d_z1 = get_dist(q_z1, obj_params) - disp_strength * h_z1;
+
+ let q_z2 = p - e.yyx;
+ let uv_z2 = spherical_uv(q_z2);
+ let h_z2 = textureSample(noise_tex, noise_sampler, uv_z2).r;
+ let d_z2 = get_dist(q_z2, obj_params) - disp_strength * h_z2;
+
+ return normalize(vec3<f32>(d_x1 - d_x2, d_y1 - d_y2, d_z1 - d_z2));
+}
+
+// Optimized bump-mapped normal using tetrahedron pattern (4 samples instead of 6).
+// 33% faster than get_normal_bump(), slightly less accurate.
+// Suitable for real-time rendering with displacement mapping.
+fn get_normal_bump_fast(
+ p: vec3<f32>,
+ obj_params: vec4<f32>,
+ noise_tex: texture_2d<f32>,
+ noise_sampler: sampler,
+ disp_strength: f32
+) -> vec3<f32> {
+ let eps = 0.0005;
+ let k = vec2<f32>(1.0, -1.0);
+
+ let q1 = p + k.xyy * eps;
+ let uv1 = spherical_uv(q1);
+ let h1 = textureSample(noise_tex, noise_sampler, uv1).r;
+ let d1 = get_dist(q1, obj_params) - disp_strength * h1;
+
+ let q2 = p + k.yyx * eps;
+ let uv2 = spherical_uv(q2);
+ let h2 = textureSample(noise_tex, noise_sampler, uv2).r;
+ let d2 = get_dist(q2, obj_params) - disp_strength * h2;
+
+ let q3 = p + k.yxy * eps;
+ let uv3 = spherical_uv(q3);
+ let h3 = textureSample(noise_tex, noise_sampler, uv3).r;
+ let d3 = get_dist(q3, obj_params) - disp_strength * h3;
+
+ let q4 = p + k.xxx * eps;
+ let uv4 = spherical_uv(q4);
+ let h4 = textureSample(noise_tex, noise_sampler, uv4).r;
+ let d4 = get_dist(q4, obj_params) - disp_strength * h4;
+
+ return normalize(k.xyy * d1 + k.yyx * d2 + k.yxy * d3 + k.xxx * d4);
+}
+
+// Distance to an Axis-Aligned Bounding Box
+fn aabb_sdf(p: vec3<f32>, min_p: vec3<f32>, max_p: vec3<f32>) -> f32 {
+ let center = (min_p + max_p) * 0.5;
+ let extent = (max_p - min_p) * 0.5;
+ let q = abs(p - center) - extent;
+ return length(max(q, vec3<f32>(0.0))) + min(max(q.x, max(q.y, q.z)), 0.0);
+}
diff --git a/assets/common/shaders/render/lighting_utils.wgsl b/assets/common/shaders/render/lighting_utils.wgsl
new file mode 100644
index 0000000..d2fd2e2
--- /dev/null
+++ b/assets/common/shaders/render/lighting_utils.wgsl
@@ -0,0 +1,6 @@
+fn calculate_lighting(color: vec3<f32>, normal: vec3<f32>, pos: vec3<f32>, shadow: f32) -> vec3<f32> {
+ let light_dir = normalize(vec3<f32>(1.0, 1.0, 1.0));
+ let diffuse = max(dot(normal, light_dir), 0.0);
+ let lighting = diffuse * (0.1 + 0.9 * shadow) + 0.1; // Ambient + Shadowed Diffuse
+ return color * lighting;
+}
diff --git a/assets/common/shaders/render/scene_query_bvh.wgsl b/assets/common/shaders/render/scene_query_bvh.wgsl
new file mode 100644
index 0000000..3e6f895
--- /dev/null
+++ b/assets/common/shaders/render/scene_query_bvh.wgsl
@@ -0,0 +1,67 @@
+#include "math/sdf_shapes"
+#include "math/sdf_utils"
+
+struct BVHNode {
+ min: vec3<f32>,
+ left_idx: i32,
+ max: vec3<f32>,
+ obj_idx_or_right: i32,
+};
+
+@group(0) @binding(2) var<storage, read> bvh_nodes: array<BVHNode>;
+
+fn get_dist(p: vec3<f32>, obj_params: vec4<f32>) -> f32 {
+ let obj_type = obj_params.x;
+ if (obj_type == 1.0) { return length(p) - 1.0; } // Unit Sphere
+ if (obj_type == 2.0) { return sdBox(p, vec3<f32>(1.0)); } // Unit Box
+ if (obj_type == 3.0) { return sdTorus(p, vec2<f32>(1.0, 0.4)); } // Unit Torus
+ if (obj_type == 4.0) { return sdPlane(p, vec3<f32>(0.0, 1.0, 0.0), 0.0); }
+ if (obj_type == 5.0) { return sdBox(p, obj_params.yzw); } // MESH AABB
+ return 100.0;
+}
+
+fn map_scene(p: vec3<f32>, skip_idx: u32) -> f32 {
+ var d = 1000.0;
+ var stack: array<i32, 32>;
+ var stack_ptr = 0;
+
+ if (arrayLength(&bvh_nodes) > 0u) {
+ stack[stack_ptr] = 0;
+ stack_ptr++;
+ }
+
+ while (stack_ptr > 0) {
+ stack_ptr--;
+ let node_idx = stack[stack_ptr];
+ let node = bvh_nodes[node_idx];
+
+ if (aabb_sdf(p, node.min, node.max) < d) {
+ if (node.left_idx < 0) { // Leaf
+ let obj_idx = u32(node.obj_idx_or_right);
+ if (obj_idx == skip_idx) { continue; }
+ let obj = object_data.objects[obj_idx];
+ let q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
+
+ // Extract scale factors from the model matrix
+ let sx = length(obj.model[0].xyz);
+ let sy = length(obj.model[1].xyz);
+ let sz = length(obj.model[2].xyz);
+
+ var s = min(sx, min(sy, sz));
+ if (obj.params.x == 4.0) {
+ s = sy; // Plane normal is (0,1,0) in local space
+ }
+
+ d = min(d, get_dist(q, obj.params) * s);
+ } else { // Internal
+ if (stack_ptr < 31) {
+ stack[stack_ptr] = node.left_idx;
+ stack_ptr++;
+ stack[stack_ptr] = node.obj_idx_or_right;
+ stack_ptr++;
+ }
+ }
+ }
+ }
+ return d;
+}
diff --git a/assets/common/shaders/render/scene_query_linear.wgsl b/assets/common/shaders/render/scene_query_linear.wgsl
new file mode 100644
index 0000000..0497a40
--- /dev/null
+++ b/assets/common/shaders/render/scene_query_linear.wgsl
@@ -0,0 +1,56 @@
+#include "math/sdf_shapes"
+#include "math/sdf_utils"
+
+fn get_dist(p: vec3<f32>, obj_params: vec4<f32>) -> f32 {
+ let obj_type = obj_params.x;
+ if (obj_type == 1.0) { return length(p) - 1.0; } // Unit Sphere
+ if (obj_type == 2.0) { return sdBox(p, vec3<f32>(1.0)); } // Unit Box
+ if (obj_type == 3.0) { return sdTorus(p, vec2<f32>(1.0, 0.4)); } // Unit Torus
+ if (obj_type == 4.0) { return sdPlane(p, vec3<f32>(0.0, 1.0, 0.0), 0.0); }
+ if (obj_type == 5.0) { return sdBox(p, obj_params.yzw); } // MESH AABB
+ return 100.0;
+}
+
+fn map_scene(p: vec3<f32>, skip_idx: u32) -> f32 {
+
+ var d = 1000.0;
+
+ let num_objects = arrayLength(&object_data.objects);
+
+ for (var i = 0u; i < num_objects; i++) {
+
+ if (i == skip_idx) { continue; }
+
+ let obj = object_data.objects[i];
+
+ let q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
+
+
+
+ // Extract scale factors from the model matrix
+
+ let sx = length(obj.model[0].xyz);
+
+ let sy = length(obj.model[1].xyz);
+
+ let sz = length(obj.model[2].xyz);
+
+
+
+ var s = min(sx, min(sy, sz));
+
+ if (obj.params.x == 4.0) {
+
+ s = sy; // Plane normal is (0,1,0) in local space
+
+ }
+
+
+
+ d = min(d, get_dist(q, obj.params) * s);
+
+ }
+
+ return d;
+
+}
diff --git a/assets/common/shaders/render/shadows.wgsl b/assets/common/shaders/render/shadows.wgsl
new file mode 100644
index 0000000..7cba089
--- /dev/null
+++ b/assets/common/shaders/render/shadows.wgsl
@@ -0,0 +1,13 @@
+fn calc_shadow(ro: vec3<f32>, rd: vec3<f32>, tmin: f32, tmax: f32, skip_idx: u32) -> f32 {
+ var res = 1.0;
+ var t = tmin;
+ if (t < 0.05) { t = 0.05; }
+ for (var i = 0; i < 32; i = i + 1) {
+ let h = map_scene(ro + rd * t, skip_idx);
+ if (h < 0.001) { return 0.0; }
+ res = min(res, 16.0 * h / t);
+ t = t + clamp(h, 0.02, 0.4);
+ if (t > tmax) { break; }
+ }
+ return clamp(res, 0.0, 1.0);
+}
generated by cgit v1.2.3 (git 2.51.0) at 2026-02-09 23:32:16 +0000