summaryrefslogtreecommitdiff
path: root/assets
diff options
context:
space:
mode:
Diffstat (limited to 'assets')
-rw-r--r--assets/demo.seq14
-rw-r--r--assets/final/demo_assets.txt6
-rw-r--r--assets/final/shaders/chroma_aberration.wgsl19
-rw-r--r--assets/final/shaders/gaussian_blur.wgsl14
-rw-r--r--assets/final/shaders/math/common_utils.wgsl36
-rw-r--r--assets/final/shaders/math/noise.wgsl147
-rw-r--r--assets/final/shaders/math/sdf_utils.wgsl97
-rw-r--r--assets/final/shaders/mesh_render.wgsl7
-rw-r--r--assets/final/shaders/ray_triangle.wgsl30
-rw-r--r--assets/final/shaders/renderer_3d.wgsl50
-rw-r--r--assets/final/shaders/skybox.wgsl9
-rw-r--r--assets/final/test_assets_list.txt2
12 files changed, 361 insertions, 70 deletions
diff --git a/assets/demo.seq b/assets/demo.seq
index 79872d3..9c55fe5 100644
--- a/assets/demo.seq
+++ b/assets/demo.seq
@@ -24,9 +24,10 @@
SEQUENCE 0b 0
EFFECT - FlashCubeEffect .2 3 # Background cube (priority -1 = behind everything)
- EFFECT + FlashEffect 0.0 1. # Priority 0
+ EFFECT + FlashEffect 0.0 1. color=1.0,0.5,0.5 decay=0.95 # Red-tinted flash
EFFECT + FadeEffect 0.1 1. # Priority 1
EFFECT + SolarizeEffect 0 4b # Priority 2 (was 3, now contiguous)
+ EFFECT + VignetteEffect 0 6 radius=0.6 softness=0.1
SEQUENCE 4b 0
EFFECT - FlashCubeEffect 0.1 3. # Priority -1
@@ -35,7 +36,7 @@ SEQUENCE 4b 0
SEQUENCE 6b 1
EFFECT + ParticleSprayEffect 0 4 # Priority 0 (spray particles)
EFFECT + ParticlesEffect 0 4 # Priority 1
- EFFECT = GaussianBlurEffect 0 8 # Priority 1 (same layer)
+ EFFECT = GaussianBlurEffect 0 8 strength=3.0 # Priority 1 (stronger blur)
SEQUENCE 7b 0
EFFECT + HeptagonEffect 0.0 .2 # Priority 0
@@ -46,8 +47,8 @@ SEQUENCE 7b 0
SEQUENCE 8b 3
EFFECT + ThemeModulationEffect 0 4 # Priority 0
EFFECT = HeptagonEffect 0.0 4.0 # Priority 0 (same layer)
- EFFECT + GaussianBlurEffect 0 8 # Priority 1
- EFFECT + ChromaAberrationEffect 0 6 # Priority 2
+ EFFECT + GaussianBlurEffect 0 8 strength=1.5 # Priority 1 (subtle blur)
+ EFFECT + ChromaAberrationEffect 0 6 offset=0.03 angle=0.785 # Priority 2 (diagonal, stronger)
EFFECT + SolarizeEffect 0 10 # Priority 3
SEQUENCE 12b 2
@@ -73,7 +74,7 @@ SEQUENCE 17b 2
EFFECT = ParticlesEffect 0 4 # Priority 2 (same layer)
EFFECT + Hybrid3DEffect 0 4 # Priority 3
EFFECT + GaussianBlurEffect 0 8 # Priority 4
- EFFECT + ChromaAberrationEffect 0 6 # Priority 5
+ EFFECT + ChromaAberrationEffect 0 6 offset=0.01 angle=1.57 # Priority 5 (vertical, subtle)
SEQUENCE 24b 1
EFFECT + ThemeModulationEffect 0 8 # Priority 0
@@ -107,6 +108,7 @@ SEQUENCE 56b 0
SEQUENCE 62b 0
EFFECT + ThemeModulationEffect 0 3 # Priority 0
- EFFECT + SolarizeEffect 0 3 # Priority 1
+ EFFECT + VignetteEffect 0 3 radius=0.6 softness=0.3 # New effect
+ EFFECT + SolarizeEffect 0 3 # Priority 2
# Demo automatically exits at this time (supports beat notation)
END_DEMO 65b
diff --git a/assets/final/demo_assets.txt b/assets/final/demo_assets.txt
index 6293696..bf39c5d 100644
--- a/assets/final/demo_assets.txt
+++ b/assets/final/demo_assets.txt
@@ -27,6 +27,7 @@ SHADER_COMMON_UNIFORMS, NONE, shaders/common_uniforms.wgsl, "Common Uniforms Sni
SHADER_SDF_PRIMITIVES, NONE, shaders/sdf_primitives.wgsl, "SDF Primitives Snippet"
SHADER_LIGHTING, NONE, shaders/lighting.wgsl, "Lighting Snippet"
SHADER_RAY_BOX, NONE, shaders/ray_box.wgsl, "Ray-Box Intersection Snippet"
+SHADER_RAY_TRIANGLE, NONE, shaders/ray_triangle.wgsl, "Ray-Triangle Intersection Snippet (Möller-Trumbore)"
SHADER_MAIN, NONE, shaders/main_shader.wgsl, "Main Heptagon Shader"
SHADER_PARTICLE_COMPUTE, NONE, shaders/particle_compute.wgsl, "Particle Compute Shader"
SHADER_PARTICLE_RENDER, NONE, shaders/particle_render.wgsl, "Particle Render Shader"
@@ -41,10 +42,13 @@ SHADER_VISUAL_DEBUG, NONE, shaders/visual_debug.wgsl, "Visual Debug Shader"
SHADER_SKYBOX, NONE, shaders/skybox.wgsl, "Skybox background shader"
SHADER_MATH_SDF_SHAPES, NONE, shaders/math/sdf_shapes.wgsl, "SDF Shapes Snippet"
SHADER_MATH_SDF_UTILS, NONE, shaders/math/sdf_utils.wgsl, "SDF Utils Snippet"
+SHADER_MATH_COMMON_UTILS, NONE, shaders/math/common_utils.wgsl, "Common Math Utils"
+SHADER_MATH_NOISE, NONE, shaders/math/noise.wgsl, "RNG and Noise Functions"
SHADER_RENDER_SHADOWS, NONE, shaders/render/shadows.wgsl, "Shadows Snippet"
SHADER_RENDER_SCENE_QUERY_BVH, NONE, shaders/render/scene_query_bvh.wgsl, "Scene Query Snippet (BVH)"
SHADER_RENDER_SCENE_QUERY_LINEAR, NONE, shaders/render/scene_query_linear.wgsl, "Scene Query Snippet (Linear)"
SHADER_RENDER_LIGHTING_UTILS, NONE, shaders/render/lighting_utils.wgsl, "Lighting Utils Snippet"
SHADER_MESH, NONE, shaders/mesh_render.wgsl, "Mesh Rasterization Shader"
MESH_CUBE, NONE, test_mesh.obj, "A simple cube mesh"
-DODECAHEDRON, NONE, dodecahedron.obj, "A dodecahedron mesh" \ No newline at end of file
+DODECAHEDRON, NONE, dodecahedron.obj, "A dodecahedron mesh"
+SHADER_VIGNETTE, NONE, shaders/vignette.wgsl, "Vignette Shader"
diff --git a/assets/final/shaders/chroma_aberration.wgsl b/assets/final/shaders/chroma_aberration.wgsl
index cd80afa..f1a3034 100644
--- a/assets/final/shaders/chroma_aberration.wgsl
+++ b/assets/final/shaders/chroma_aberration.wgsl
@@ -6,7 +6,10 @@ struct Uniforms {
beat: f32,
intensity: f32,
aspect_ratio: f32,
- resolution: vec2<f32>,
+ width: f32,
+ height: f32,
+ offset_scale: f32,
+ angle: f32,
};
@group(0) @binding(2) var<uniform> uniforms: Uniforms;
@@ -21,10 +24,16 @@ struct Uniforms {
}
@fragment fn fs_main(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
- let uv = p.xy / uniforms.resolution;
- let off = 0.02 * uniforms.intensity;
- let r = textureSample(txt, smplr, uv + vec2<f32>(off, 0.0)).r;
+ let uv = p.xy / vec2<f32>(uniforms.width, uniforms.height);
+
+ // Compute offset magnitude and direction
+ let offset_mag = uniforms.offset_scale * uniforms.intensity;
+ let offset_dir = vec2<f32>(cos(uniforms.angle), sin(uniforms.angle));
+ let offset = offset_mag * offset_dir;
+
+ // Sample RGB channels with chromatic aberration
+ let r = textureSample(txt, smplr, uv + offset).r;
let g = textureSample(txt, smplr, uv).g;
- let b = textureSample(txt, smplr, uv - vec2<f32>(off, 0.0)).b;
+ let b = textureSample(txt, smplr, uv - offset).b;
return vec4<f32>(r, g, b, 1.0);
}
diff --git a/assets/final/shaders/gaussian_blur.wgsl b/assets/final/shaders/gaussian_blur.wgsl
index 7d39ac4..e848c6b 100644
--- a/assets/final/shaders/gaussian_blur.wgsl
+++ b/assets/final/shaders/gaussian_blur.wgsl
@@ -6,7 +6,10 @@ struct Uniforms {
beat: f32,
intensity: f32,
aspect_ratio: f32,
- resolution: vec2<f32>,
+ width: f32,
+ height: f32,
+ strength: f32,
+ _pad: f32,
};
@group(0) @binding(2) var<uniform> uniforms: Uniforms;
@@ -21,17 +24,16 @@ struct Uniforms {
}
@fragment fn fs_main(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
- let uv = p.xy / uniforms.resolution;
+ let uv = p.xy / vec2<f32>(uniforms.width, uniforms.height);
var res = vec4<f32>(0.0);
- // Reduced base size + dramatic beat pulsation
- let base_size = 2.0;
+ // Parameterized strength + dramatic beat pulsation
let pulse = 0.5 + uniforms.intensity * 2.0; // Pulsate between 0.5x and 2.5x with beat
- let size = base_size * pulse;
+ let size = uniforms.strength * pulse;
for (var x: f32 = -2.0; x <= 2.0; x += 1.0) {
for (var y: f32 = -2.0; y <= 2.0; y += 1.0) {
- res += textureSample(txt, smplr, uv + vec2<f32>(x, y) * size / uniforms.resolution.x);
+ res += textureSample(txt, smplr, uv + vec2<f32>(x, y) * size / uniforms.width);
}
}
return res / 25.0;
diff --git a/assets/final/shaders/math/common_utils.wgsl b/assets/final/shaders/math/common_utils.wgsl
new file mode 100644
index 0000000..7131216
--- /dev/null
+++ b/assets/final/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/final/shaders/math/noise.wgsl b/assets/final/shaders/math/noise.wgsl
new file mode 100644
index 0000000..9f99e4a
--- /dev/null
+++ b/assets/final/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/final/shaders/math/sdf_utils.wgsl b/assets/final/shaders/math/sdf_utils.wgsl
index c2e49cf..660a4ce 100644
--- a/assets/final/shaders/math/sdf_utils.wgsl
+++ b/assets/final/shaders/math/sdf_utils.wgsl
@@ -9,6 +9,103 @@ fn get_normal_basic(p: vec3<f32>, obj_params: vec4<f32>) -> vec3<f32> {
));
}
+// 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;
diff --git a/assets/final/shaders/mesh_render.wgsl b/assets/final/shaders/mesh_render.wgsl
index 068efbc..7390b06 100644
--- a/assets/final/shaders/mesh_render.wgsl
+++ b/assets/final/shaders/mesh_render.wgsl
@@ -1,4 +1,5 @@
#include "common_uniforms"
+#include "math/common_utils"
@group(0) @binding(0) var<uniform> globals: GlobalUniforms;
@group(0) @binding(1) var<storage, read> object_data: ObjectsBuffer;
@@ -33,10 +34,8 @@ fn vs_main(in: VertexInput, @builtin(instance_index) instance_index: u32) -> Ver
out.clip_pos = globals.view_proj * world_pos;
out.world_pos = world_pos.xyz;
- // Use transpose of inverse for normals
- // Note: mat3x3 constructor takes columns, so passing rows gives us transpose
- let normal_matrix = mat3x3<f32>(obj.inv_model[0].xyz, obj.inv_model[1].xyz, obj.inv_model[2].xyz);
- out.normal = normalize(normal_matrix * in.normal);
+ // Transform normal from local to world space
+ out.normal = transform_normal(obj.inv_model, in.normal);
out.uv = in.uv;
out.color = obj.color;
diff --git a/assets/final/shaders/ray_triangle.wgsl b/assets/final/shaders/ray_triangle.wgsl
new file mode 100644
index 0000000..13341c8
--- /dev/null
+++ b/assets/final/shaders/ray_triangle.wgsl
@@ -0,0 +1,30 @@
+// This file is part of the 64k demo project.
+// Möller-Trumbore ray-triangle intersection algorithm.
+// Reference: "Fast, Minimum Storage Ray-Triangle Intersection"
+
+struct TriangleHit {
+ uv: vec2<f32>,
+ z: f32,
+ N: vec3<f32>,
+ hit: bool,
+};
+
+fn ray_triangle_intersection(
+ orig: vec3<f32>,
+ dir: vec3<f32>,
+ p0: vec3<f32>,
+ p1: vec3<f32>,
+ p2: vec3<f32>
+) -> TriangleHit {
+ let d10 = p1 - p0;
+ let d20 = p2 - p0;
+ let N = cross(d10, d20);
+ let det = -dot(dir, N);
+ let invdet = 1.0 / det;
+ let d0 = orig - p0;
+ let nd = cross(d0, dir);
+ let uv = vec2<f32>(dot(d20, nd), -dot(d10, nd)) * invdet;
+ let z = dot(d0, N) * invdet;
+ let hit = det > 0.0 && z >= 0.0 && uv.x >= 0.0 && uv.y >= 0.0 && (uv.x + uv.y) < 1.0;
+ return TriangleHit(uv, z, N, hit);
+}
diff --git a/assets/final/shaders/renderer_3d.wgsl b/assets/final/shaders/renderer_3d.wgsl
index c290df8..d3b0bae 100644
--- a/assets/final/shaders/renderer_3d.wgsl
+++ b/assets/final/shaders/renderer_3d.wgsl
@@ -1,4 +1,6 @@
#include "common_uniforms"
+#include "math/common_utils"
+#include "math/sdf_utils"
@group(0) @binding(0) var<uniform> globals: GlobalUniforms;
@group(0) @binding(1) var<storage, read> object_data: ObjectsBuffer;
@@ -100,8 +102,7 @@ fn fs_main(in: VertexOutput) -> FragmentOutput {
// Apply grid pattern to floor
let uv = p.xz * 0.5;
- let grid = 0.5 + 0.5 * sin(uv.x * 3.14) * sin(uv.y * 3.14);
- let grid_val = smoothstep(0.45, 0.55, grid);
+ let grid_val = grid_pattern(uv);
base_color = base_color * (0.5 + 0.5 * grid_val);
} else { // SDF path
let ro_world = globals.camera_pos_time.xyz;
@@ -135,53 +136,18 @@ fn fs_main(in: VertexOutput) -> FragmentOutput {
let q_hit = ro_local + rd_local * t;
p = (obj.model * vec4<f32>(q_hit, 1.0)).xyz; // Correct world position
- // Calculate normal with bump mapping
- let e = vec2<f32>(0.005, 0.0);
+ // Calculate normal with bump mapping (using utility function)
let disp_strength = 0.05;
-
- let q_x1 = q_hit + e.xyy;
- let uv_x1 = vec2<f32>(atan2(q_x1.x, q_x1.z) / 6.28 + 0.5, acos(clamp(q_x1.y / length(q_x1), -1.0, 1.0)) / 3.14);
- 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 = q_hit - e.xyy;
- let uv_x2 = vec2<f32>(atan2(q_x2.x, q_x2.z) / 6.28 + 0.5, acos(clamp(q_x2.y / length(q_x2), -1.0, 1.0)) / 3.14);
- 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 = q_hit + e.yxy;
- let uv_y1 = vec2<f32>(atan2(q_y1.x, q_y1.z) / 6.28 + 0.5, acos(clamp(q_y1.y / length(q_y1), -1.0, 1.0)) / 3.14);
- 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 = q_hit - e.yxy;
- let uv_y2 = vec2<f32>(atan2(q_y2.x, q_y2.z) / 6.28 + 0.5, acos(clamp(q_y2.y / length(q_y2), -1.0, 1.0)) / 3.14);
- 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 = q_hit + e.yyx;
- let uv_z1 = vec2<f32>(atan2(q_z1.x, q_z1.z) / 6.28 + 0.5, acos(clamp(q_z1.y / length(q_z1), -1.0, 1.0)) / 3.14);
- 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 = q_hit - e.yyx;
- let uv_z2 = vec2<f32>(atan2(q_z2.x, q_z2.z) / 6.28 + 0.5, acos(clamp(q_z2.y / length(q_z2), -1.0, 1.0)) / 3.14);
- let h_z2 = textureSample(noise_tex, noise_sampler, uv_z2).r;
- let d_z2 = get_dist(q_z2, obj.params) - disp_strength * h_z2;
-
- let n_local = normalize(vec3<f32>(d_x1 - d_x2, d_y1 - d_y2, d_z1 - d_z2));
- // Note: mat3x3 constructor takes columns, so passing rows gives us transpose
- let normal_matrix = mat3x3<f32>(obj.inv_model[0].xyz, obj.inv_model[1].xyz, obj.inv_model[2].xyz);
- normal = normalize(normal_matrix * n_local);
+ let n_local = get_normal_bump(q_hit, obj.params, noise_tex, noise_sampler, disp_strength);
+ normal = transform_normal(obj.inv_model, n_local);
// Apply texture to SDF color
if (in.instance_index == 0u || obj_type == 4.0) { // Floor (index 0) or PLANE
let uv_grid = p.xz * 0.5;
- let grid = 0.5 + 0.5 * sin(uv_grid.x * 3.14) * sin(uv_grid.y * 3.14);
- let grid_val = smoothstep(0.45, 0.55, grid);
+ let grid_val = grid_pattern(uv_grid);
base_color = base_color * (0.5 + 0.5 * grid_val);
} else {
- let uv_hit = vec2<f32>(atan2(q_hit.x, q_hit.z) / 6.28 + 0.5, acos(clamp(q_hit.y / length(q_hit), -1.0, 1.0)) / 3.14);
+ let uv_hit = spherical_uv(q_hit);
let tex_val = textureSample(noise_tex, noise_sampler, uv_hit).r;
base_color = base_color * (0.7 + 0.3 * tex_val);
}
diff --git a/assets/final/shaders/skybox.wgsl b/assets/final/shaders/skybox.wgsl
index d7f252e..31bea3b 100644
--- a/assets/final/shaders/skybox.wgsl
+++ b/assets/final/shaders/skybox.wgsl
@@ -1,4 +1,5 @@
#include "common_uniforms"
+#include "math/common_utils"
@group(0) @binding(0) var sky_tex: texture_2d<f32>;
@group(0) @binding(1) var sky_sampler: sampler;
@@ -36,10 +37,6 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
let world_pos = world_pos_h.xyz / world_pos_h.w;
let ray_dir = normalize(world_pos - globals.camera_pos_time.xyz);
-
- // Spherical Mapping
- let u = atan2(ray_dir.z, ray_dir.x) / 6.28318 + 0.5;
- let v = asin(clamp(ray_dir.y, -1.0, 1.0)) / 3.14159 + 0.5;
-
- return textureSample(sky_tex, sky_sampler, vec2<f32>(u, v));
+ let uv = spherical_uv_from_dir(ray_dir);
+ return textureSample(sky_tex, sky_sampler, uv);
} \ No newline at end of file
diff --git a/assets/final/test_assets_list.txt b/assets/final/test_assets_list.txt
index 7cded99..98d32ce 100644
--- a/assets/final/test_assets_list.txt
+++ b/assets/final/test_assets_list.txt
@@ -16,6 +16,8 @@ SHADER_SKYBOX, NONE, shaders/skybox.wgsl, "Skybox background shader"
SHADER_COMMON_UNIFORMS, NONE, shaders/common_uniforms.wgsl, "Common Uniforms Snippet"
SHADER_MATH_SDF_SHAPES, NONE, shaders/math/sdf_shapes.wgsl, "SDF Shapes Snippet"
SHADER_MATH_SDF_UTILS, NONE, shaders/math/sdf_utils.wgsl, "SDF Utils Snippet"
+SHADER_MATH_COMMON_UTILS, NONE, shaders/math/common_utils.wgsl, "Common Math Utils"
+SHADER_MATH_NOISE, NONE, shaders/math/noise.wgsl, "RNG and Noise Functions"
SHADER_RENDER_SHADOWS, NONE, shaders/render/shadows.wgsl, "Shadows Snippet"
SHADER_RENDER_SCENE_QUERY_BVH, NONE, shaders/render/scene_query_bvh.wgsl, "Scene Query Snippet (BVH)"
SHADER_RENDER_SCENE_QUERY_LINEAR, NONE, shaders/render/scene_query_linear.wgsl, "Scene Query Snippet (Linear)"
generated by cgit v1.2.3 (git 2.51.0) at 2026-02-08 21:06:46 +0000