diff options
Diffstat (limited to 'assets/final')
25 files changed, 702 insertions, 119 deletions
diff --git a/assets/final/demo_assets.txt b/assets/final/demo_assets.txt index 6293696..05eee17 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,16 @@ 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" +CIRCLE_MASK_COMPUTE_SHADER, NONE, shaders/circle_mask_compute.wgsl, "Circle mask compute shader" +CIRCLE_MASK_RENDER_SHADER, NONE, shaders/circle_mask_render.wgsl, "Circle mask render shader" +MASKED_CUBE_SHADER, NONE, shaders/masked_cube.wgsl, "Masked cube shader" diff --git a/assets/final/shaders/chroma_aberration.wgsl b/assets/final/shaders/chroma_aberration.wgsl index cd80afa..ca1e17d 100644 --- a/assets/final/shaders/chroma_aberration.wgsl +++ b/assets/final/shaders/chroma_aberration.wgsl @@ -1,15 +1,20 @@ @group(0) @binding(0) var smplr: sampler; @group(0) @binding(1) var txt: texture_2d<f32>; -struct Uniforms { +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, time: f32, beat: f32, - intensity: f32, - aspect_ratio: f32, - resolution: vec2<f32>, + audio_intensity: f32, +}; +struct EffectParams { + offset_scale: f32, + angle: f32, }; -@group(0) @binding(2) var<uniform> uniforms: Uniforms; +@group(0) @binding(2) var<uniform> common: CommonUniforms; +@group(0) @binding(3) var<uniform> params: EffectParams; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { var pos = array<vec2<f32>, 3>( @@ -21,10 +26,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 / common.resolution; + + // Compute offset magnitude and direction + let offset_mag = params.offset_scale * common.audio_intensity; + let offset_dir = vec2<f32>(cos(params.angle), sin(params.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/circle_mask_compute.wgsl b/assets/final/shaders/circle_mask_compute.wgsl new file mode 100644 index 0000000..9bb03ff --- /dev/null +++ b/assets/final/shaders/circle_mask_compute.wgsl @@ -0,0 +1,39 @@ +// Circle mask compute shader +// Generates a circular mask (1.0 inside, 0.0 outside) + +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, + time: f32, + beat: f32, + audio_intensity: f32, +}; +struct EffectParams { + radius: f32, + _pad: vec3<f32>, +}; + +@group(0) @binding(0) var<uniform> common: CommonUniforms; +@group(0) @binding(1) var<uniform> params: EffectParams; + +struct VSOutput { + @builtin(position) position: vec4<f32>, +}; + +@vertex fn vs_main(@builtin(vertex_index) i: u32) -> VSOutput { + var pos = array<vec2<f32>, 3>( + vec2<f32>(-1, -1), vec2<f32>(3, -1), vec2<f32>(-1, 3)); + return VSOutput(vec4<f32>(pos[i], 0.0, 1.0)); +} + +@fragment fn fs_main(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> { + let uv = p.xy / common.resolution; + let center = vec2<f32>(0.5, 0.5); + let aspect_corrected_uv = (uv - center) * vec2<f32>(common.aspect_ratio, 1.0); + let dist = length(aspect_corrected_uv); + + let edge_width = 0.01; + let mask = smoothstep(params.radius + edge_width, params.radius - edge_width, dist); + + return vec4<f32>(mask, mask, mask, 1.0); +} diff --git a/assets/final/shaders/circle_mask_render.wgsl b/assets/final/shaders/circle_mask_render.wgsl new file mode 100644 index 0000000..6855c95 --- /dev/null +++ b/assets/final/shaders/circle_mask_render.wgsl @@ -0,0 +1,36 @@ +// Circle mask render shader +// Samples mask and draws green outside the circle + +@group(0) @binding(0) var mask_tex: texture_2d<f32>; +@group(0) @binding(1) var mask_sampler: sampler; + +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, + time: f32, + beat: f32, + audio_intensity: f32, +}; + +@group(0) @binding(2) var<uniform> uniforms: CommonUniforms; + +struct VSOutput { + @builtin(position) position: vec4<f32>, +}; + +@vertex fn vs_main(@builtin(vertex_index) i: u32) -> VSOutput { + var pos = array<vec2<f32>, 3>( + vec2<f32>(-1, -1), vec2<f32>(3, -1), vec2<f32>(-1, 3)); + return VSOutput(vec4<f32>(pos[i], 0.0, 1.0)); +} + +@fragment fn fs_main(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> { + let uv = p.xy / uniforms.resolution; + let mask_value = textureSample(mask_tex, mask_sampler, uv).r; + + if (mask_value > 0.5) { + discard; + } + + return vec4<f32>(0.0, 1.0, 0.0, 1.0); +} diff --git a/assets/final/shaders/common_uniforms.wgsl b/assets/final/shaders/common_uniforms.wgsl index 4b5cf33..1e0e242 100644 --- a/assets/final/shaders/common_uniforms.wgsl +++ b/assets/final/shaders/common_uniforms.wgsl @@ -1,3 +1,10 @@ +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, + time: f32, + beat: f32, + audio_intensity: f32, +}; struct GlobalUniforms { view_proj: mat4x4<f32>, inv_view_proj: mat4x4<f32>, diff --git a/assets/final/shaders/distort.wgsl b/assets/final/shaders/distort.wgsl index 2d5f276..cca01c4 100644 --- a/assets/final/shaders/distort.wgsl +++ b/assets/final/shaders/distort.wgsl @@ -1,15 +1,15 @@ @group(0) @binding(0) var smplr: sampler; @group(0) @binding(1) var txt: texture_2d<f32>; -struct Uniforms { +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, time: f32, beat: f32, - intensity: f32, - aspect_ratio: f32, - resolution: vec2<f32>, + audio_intensity: f32, }; -@group(0) @binding(2) var<uniform> uniforms: Uniforms; +@group(0) @binding(2) var<uniform> uniforms: CommonUniforms; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { var pos = array<vec2<f32>, 3>( @@ -22,6 +22,6 @@ struct Uniforms { @fragment fn fs_main(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> { let uv = p.xy / uniforms.resolution; - let dist = 0.1 * uniforms.intensity * sin(uv.y * 20.0 + uniforms.time * 5.0); + let dist = 0.1 * uniforms.audio_intensity * sin(uv.y * 20.0 + uniforms.time * 5.0); return textureSample(txt, smplr, uv + vec2<f32>(dist, 0.0)); } diff --git a/assets/final/shaders/ellipse.wgsl b/assets/final/shaders/ellipse.wgsl index be236c8..1b6df0b 100644 --- a/assets/final/shaders/ellipse.wgsl +++ b/assets/final/shaders/ellipse.wgsl @@ -1,12 +1,12 @@ -struct Uniforms { +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, time: f32, beat: f32, - intensity: f32, - aspect_ratio: f32, - resolution: vec2<f32>, + audio_intensity: f32, }; -@group(0) @binding(0) var<uniform> uniforms: Uniforms; +@group(0) @binding(0) var<uniform> uniforms: CommonUniforms; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { var pos = array<vec2<f32>, 3>( diff --git a/assets/final/shaders/gaussian_blur.wgsl b/assets/final/shaders/gaussian_blur.wgsl index 7d39ac4..39cbf54 100644 --- a/assets/final/shaders/gaussian_blur.wgsl +++ b/assets/final/shaders/gaussian_blur.wgsl @@ -1,15 +1,20 @@ @group(0) @binding(0) var smplr: sampler; @group(0) @binding(1) var txt: texture_2d<f32>; -struct Uniforms { +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, time: f32, beat: f32, - intensity: f32, - aspect_ratio: f32, - resolution: vec2<f32>, + audio_intensity: f32, +}; +struct EffectParams { + strength: f32, + _pad: f32, }; -@group(0) @binding(2) var<uniform> uniforms: Uniforms; +@group(0) @binding(2) var<uniform> common: CommonUniforms; +@group(0) @binding(3) var<uniform> params: EffectParams; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { var pos = array<vec2<f32>, 3>( @@ -21,17 +26,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 / common.resolution; var res = vec4<f32>(0.0); - // Reduced base size + dramatic beat pulsation - let base_size = 2.0; - let pulse = 0.5 + uniforms.intensity * 2.0; // Pulsate between 0.5x and 2.5x with beat - let size = base_size * pulse; + // Parameterized strength + dramatic beat pulsation + let pulse = 0.5 + common.audio_intensity * 2.0; // Pulsate between 0.5x and 2.5x with beat + let size = params.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 / common.resolution.x); } } return res / 25.0; diff --git a/assets/final/shaders/main_shader.wgsl b/assets/final/shaders/main_shader.wgsl index 7011159..5bb7d46 100644 --- a/assets/final/shaders/main_shader.wgsl +++ b/assets/final/shaders/main_shader.wgsl @@ -1,15 +1,17 @@ -struct Uniforms { - audio_peak: f32, +struct CommonUniforms { + resolution: vec2<f32>, aspect_ratio: f32, time: f32, + beat: f32, + audio_intensity: f32, }; -@group(0) @binding(0) var<uniform> uniforms: Uniforms; +@group(0) @binding(0) var<uniform> uniforms: CommonUniforms; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { let PI = 3.14159265; let num_sides = 7.0; - let scale = 0.5 + 0.3 * uniforms.audio_peak; + let scale = 0.5 + 0.3 * uniforms.audio_intensity; let tri_idx = f32(i / 3u); let sub_idx = i % 3u; if (sub_idx == 0u) { @@ -20,10 +22,10 @@ struct Uniforms { } @fragment fn fs_main() -> @location(0) vec4<f32> { - let h = uniforms.time * 2.0 + uniforms.audio_peak * 3.0; + let h = uniforms.time * 2.0 + uniforms.audio_intensity * 3.0; let r = sin(h) * 0.5 + 0.5; let g = sin(h + 2.0) * 0.9 + 0.3; let b = sin(h + 4.0) * 0.5 + 0.5; - let boost = uniforms.audio_peak * 0.5; + let boost = uniforms.audio_intensity * 0.5; return vec4<f32>(r + boost, g + boost, b + boost, 1.0); } diff --git a/assets/final/shaders/masked_cube.wgsl b/assets/final/shaders/masked_cube.wgsl new file mode 100644 index 0000000..5e673a3 --- /dev/null +++ b/assets/final/shaders/masked_cube.wgsl @@ -0,0 +1,159 @@ +// Masked cube shader - based on renderer_3d.wgsl with mask sampling +#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; +@group(0) @binding(3) var noise_tex: texture_2d<f32>; +@group(0) @binding(4) var noise_sampler: sampler; + +@group(1) @binding(0) var mask_tex: texture_2d<f32>; +@group(1) @binding(1) var mask_sampler: sampler; + +struct VertexOutput { + @builtin(position) position: vec4<f32>, + @location(0) local_pos: vec3<f32>, + @location(1) color: vec4<f32>, + @location(2) @interpolate(flat) instance_index: u32, + @location(3) world_pos: vec3<f32>, + @location(4) transformed_normal: vec3<f32>, +}; + +@vertex +fn vs_main(@builtin(vertex_index) vertex_index: u32, + @builtin(instance_index) instance_index: u32) -> VertexOutput { + var pos = array<vec3<f32>, 36>( + vec3(-1.0, -1.0, 1.0), vec3( 1.0, -1.0, 1.0), vec3( 1.0, 1.0, 1.0), + vec3(-1.0, -1.0, 1.0), vec3( 1.0, 1.0, 1.0), vec3(-1.0, 1.0, 1.0), + vec3(-1.0, -1.0, -1.0), vec3(-1.0, 1.0, -1.0), vec3( 1.0, 1.0, -1.0), + vec3(-1.0, -1.0, -1.0), vec3( 1.0, 1.0, -1.0), vec3( 1.0, -1.0, -1.0), + vec3(-1.0, 1.0, -1.0), vec3(-1.0, 1.0, 1.0), vec3( 1.0, 1.0, 1.0), + vec3(-1.0, 1.0, -1.0), vec3( 1.0, 1.0, 1.0), vec3( 1.0, 1.0, -1.0), + vec3(-1.0, -1.0, -1.0), vec3( 1.0, -1.0, -1.0), vec3( 1.0, -1.0, 1.0), + vec3(-1.0, -1.0, -1.0), vec3( 1.0, -1.0, 1.0), vec3(-1.0, -1.0, 1.0), + vec3( 1.0, -1.0, -1.0), vec3( 1.0, 1.0, -1.0), vec3( 1.0, 1.0, 1.0), + vec3( 1.0, -1.0, -1.0), vec3( 1.0, 1.0, 1.0), vec3( 1.0, -1.0, 1.0), + vec3(-1.0, -1.0, -1.0), vec3(-1.0, -1.0, 1.0), vec3(-1.0, 1.0, 1.0), + vec3(-1.0, -1.0, -1.0), vec3(-1.0, 1.0, 1.0), vec3(-1.0, 1.0, -1.0) + ); + + var p = pos[vertex_index]; + let obj = object_data.objects[instance_index]; + let world_pos = obj.model * vec4<f32>(p, 1.0); + let clip_pos = globals.view_proj * world_pos; + + var out: VertexOutput; + out.position = clip_pos; + out.local_pos = p; + out.color = obj.color; + out.instance_index = instance_index; + out.world_pos = world_pos.xyz; + out.transformed_normal = normalize(vec3<f32>(0.0, 1.0, 0.0)); + + return out; +} + +#include "render/scene_query_mode" +#include "render/shadows" +#include "render/lighting_utils" +#include "ray_box" + +struct FragmentOutput { + @location(0) color: vec4<f32>, + @builtin(frag_depth) depth: f32, +}; + +@fragment +fn fs_main(in: VertexOutput) -> FragmentOutput { + let screen_uv = in.position.xy / globals.resolution; + let mask_value = textureSample(mask_tex, mask_sampler, screen_uv).r; + + if (mask_value < 0.5) { + discard; + } + + let obj = object_data.objects[in.instance_index]; + let obj_type = obj.params.x; + + var p: vec3<f32>; + var normal: vec3<f32>; + var base_color = in.color.rgb; + let light_dir = normalize(vec3<f32>(1.0, 1.0, 1.0)); + + let ray_origin = globals.camera_pos_time.xyz; + let ray_dir = normalize(in.world_pos - ray_origin); + let inv_model = obj.inv_model; + + let local_origin = (inv_model * vec4<f32>(ray_origin, 1.0)).xyz; + let local_dir = normalize((inv_model * vec4<f32>(ray_dir, 0.0)).xyz); + + let bounds = ray_box_intersection(local_origin, local_dir, vec3<f32>(1.0)); + if (!bounds.hit) { + discard; + } + + let t_start = bounds.t_entry; + let t_end = bounds.t_exit; + + var t_march = t_start; + let max_steps = 128; + var hit = false; + var local_p = vec3<f32>(0.0); + + for (var step = 0; step < max_steps; step++) { + local_p = local_origin + t_march * local_dir; + let d = sdBox(local_p, vec3<f32>(1.0)); + + if (d < 0.001) { + hit = true; + break; + } + + t_march += max(d * 0.5, 0.001); + if (t_march > t_end) { + break; + } + } + + if (!hit) { + discard; + } + + p = local_p; + let eps = 0.001; + normal = normalize(vec3<f32>( + sdBox(p + vec3<f32>(eps, 0.0, 0.0), vec3<f32>(1.0)) - + sdBox(p - vec3<f32>(eps, 0.0, 0.0), vec3<f32>(1.0)), + sdBox(p + vec3<f32>(0.0, eps, 0.0), vec3<f32>(1.0)) - + sdBox(p - vec3<f32>(0.0, eps, 0.0), vec3<f32>(1.0)), + sdBox(p + vec3<f32>(0.0, 0.0, eps), vec3<f32>(1.0)) - + sdBox(p - vec3<f32>(0.0, 0.0, eps), vec3<f32>(1.0)) + )); + + let world_p = (obj.model * vec4<f32>(p, 1.0)).xyz; + let world_normal = normalize((obj.model * vec4<f32>(normal, 0.0)).xyz); + + let bump_strength = 0.3; + let bump_scale = 4.0; + let noise_uv = world_p.xy * bump_scale; + let noise_val = textureSample(noise_tex, noise_sampler, noise_uv).r; + let bump_offset = (noise_val - 0.5) * bump_strength; + + let bumped_normal = normalize(world_normal + vec3<f32>(bump_offset)); + + let diffuse = max(dot(bumped_normal, light_dir), 0.0); + let ambient = 0.3; + let lighting = ambient + diffuse * 0.7; + + let final_color = base_color * lighting; + + let clip_p = globals.view_proj * vec4<f32>(world_p, 1.0); + let depth = clip_p.z / clip_p.w; + + var out: FragmentOutput; + out.color = vec4<f32>(final_color, 1.0); + out.depth = depth; + + return out; +} 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/particle_compute.wgsl b/assets/final/shaders/particle_compute.wgsl index a6c96db..f2f7ae3 100644 --- a/assets/final/shaders/particle_compute.wgsl +++ b/assets/final/shaders/particle_compute.wgsl @@ -5,15 +5,16 @@ struct Particle { color: vec4<f32>, }; -struct Uniforms { - audio_peak: f32, +struct CommonUniforms { + resolution: vec2<f32>, aspect_ratio: f32, time: f32, beat: f32, + audio_intensity: f32, }; @group(0) @binding(0) var<storage, read_write> particles: array<Particle>; -@group(0) @binding(1) var<uniform> uniforms: Uniforms; +@group(0) @binding(1) var<uniform> uniforms: CommonUniforms; @compute @workgroup_size(64) fn main(@builtin(global_invocation_id) id: vec3<u32>) { @@ -24,11 +25,11 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) { var p = particles[i]; let new_pos = p.pos.xyz + p.vel.xyz * 0.016; p.pos = vec4<f32>(new_pos, p.pos.w); - p.vel.y = p.vel.y - 0.01 * (1.0 + uniforms.audio_peak * 5.0); + p.vel.y = p.vel.y - 0.01 * (1.0 + uniforms.audio_intensity * 5.0); p.rot.x = p.rot.x + p.rot.y * 0.016; if (p.pos.y < -1.5) { p.pos.y = 1.5; - p.pos.x = (f32(i % 100u) / 50.0) - 1.0 + (uniforms.audio_peak * 0.5); + p.pos.x = (f32(i % 100u) / 50.0) - 1.0 + (uniforms.audio_intensity * 0.5); p.vel.y = 0.0; } particles[i] = p; diff --git a/assets/final/shaders/particle_render.wgsl b/assets/final/shaders/particle_render.wgsl index 6a955f0..a0740dc 100644 --- a/assets/final/shaders/particle_render.wgsl +++ b/assets/final/shaders/particle_render.wgsl @@ -5,15 +5,16 @@ struct Particle { color: vec4<f32>, }; -struct Uniforms { - audio_peak: f32, +struct CommonUniforms { + resolution: vec2<f32>, aspect_ratio: f32, time: f32, beat: f32, + audio_intensity: f32, }; @group(0) @binding(0) var<storage, read> particles: array<Particle>; -@group(0) @binding(1) var<uniform> uniforms: Uniforms; +@group(0) @binding(1) var<uniform> uniforms: CommonUniforms; struct VSOut { @builtin(position) pos: vec4<f32>, @@ -23,7 +24,7 @@ struct VSOut { @vertex fn vs_main(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VSOut { let p = particles[ii]; - let size = 0.02 + p.pos.z * 0.01 + uniforms.audio_peak * 0.02; + let size = 0.02 + p.pos.z * 0.01 + uniforms.audio_intensity * 0.02; var offsets = array<vec2<f32>, 6>( vec2<f32>(-1, -1), vec2<f32>(1, -1), @@ -40,7 +41,7 @@ struct VSOut { // Fade based on lifetime (p.pos.w goes from 1.0 to 0.0) let lifetime_fade = p.pos.w; - let color_with_fade = vec4<f32>(p.color.rgb * (0.5 + 0.5 * uniforms.audio_peak), p.color.a * lifetime_fade); + let color_with_fade = vec4<f32>(p.color.rgb * (0.5 + 0.5 * uniforms.audio_intensity), p.color.a * lifetime_fade); return VSOut(vec4<f32>(pos, 0.0, 1.0), color_with_fade, offset); } diff --git a/assets/final/shaders/particle_spray_compute.wgsl b/assets/final/shaders/particle_spray_compute.wgsl index 55fa8e9..f1a4d43 100644 --- a/assets/final/shaders/particle_spray_compute.wgsl +++ b/assets/final/shaders/particle_spray_compute.wgsl @@ -5,15 +5,16 @@ struct Particle { color: vec4<f32>, }; -struct Uniforms { - intensity: f32, +struct CommonUniforms { + resolution: vec2<f32>, aspect_ratio: f32, time: f32, beat: f32, + audio_intensity: f32, }; @group(0) @binding(0) var<storage, read_write> particles: array<Particle>; -@group(0) @binding(1) var<uniform> uniforms: Uniforms; +@group(0) @binding(1) var<uniform> uniforms: CommonUniforms; fn hash(p: f32) -> f32 { return fract(sin(p) * 43758.5453); @@ -30,7 +31,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) { let r = hash(f32(i) + uniforms.time); let angle = r * 6.28318; p.pos = vec4<f32>(0.0, 0.0, 0.0, 1.0); - p.vel = vec4<f32>(cos(angle), sin(angle), 0.0, 0.0) * (0.5 + hash(r) * 0.5) * (1.0 + uniforms.intensity * 2.0); + p.vel = vec4<f32>(cos(angle), sin(angle), 0.0, 0.0) * (0.5 + hash(r) * 0.5) * (1.0 + uniforms.audio_intensity * 2.0); p.color = vec4<f32>(hash(r + 0.1), hash(r + 0.2), 1.0, 1.0); } let new_pos = p.pos.xyz + p.vel.xyz * 0.016; diff --git a/assets/final/shaders/passthrough.wgsl b/assets/final/shaders/passthrough.wgsl index aa4de1c..c1ac60a 100644 --- a/assets/final/shaders/passthrough.wgsl +++ b/assets/final/shaders/passthrough.wgsl @@ -1,14 +1,14 @@ @group(0) @binding(0) var smplr: sampler; @group(0) @binding(1) var txt: texture_2d<f32>; -struct Uniforms { +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, time: f32, beat: f32, - intensity: f32, - aspect_ratio: f32, - resolution: vec2<f32>, + audio_intensity: f32, }; -@group(0) @binding(2) var<uniform> uniforms: Uniforms; +@group(0) @binding(2) var<uniform> uniforms: CommonUniforms; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { var pos = array<vec2<f32>, 3>( 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/shaders/solarize.wgsl b/assets/final/shaders/solarize.wgsl index fcb9d80..c9f19a2 100644 --- a/assets/final/shaders/solarize.wgsl +++ b/assets/final/shaders/solarize.wgsl @@ -1,15 +1,15 @@ @group(0) @binding(0) var smplr: sampler; @group(0) @binding(1) var txt: texture_2d<f32>; -struct Uniforms { +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, time: f32, beat: f32, - intensity: f32, - aspect_ratio: f32, - resolution: vec2<f32>, + audio_intensity: f32, }; -@group(0) @binding(2) var<uniform> uniforms: Uniforms; +@group(0) @binding(2) var<uniform> uniforms: CommonUniforms; @vertex fn vs_main(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> { var pos = array<vec2<f32>, 3>( diff --git a/assets/final/shaders/vignette.wgsl b/assets/final/shaders/vignette.wgsl new file mode 100644 index 0000000..9b7f43f --- /dev/null +++ b/assets/final/shaders/vignette.wgsl @@ -0,0 +1,37 @@ +@group(0) @binding(0) var input_sampler: sampler; +@group(0) @binding(1) var input_tex: texture_2d<f32>; +struct CommonUniforms { + resolution: vec2<f32>, + aspect_ratio: f32, + time: f32, + beat: f32, + audio_intensity: f32, +}; +struct EffectParams { + radius: f32, + softness: f32, +}; + +@group(0) @binding(2) var<uniform> common: CommonUniforms; +@group(0) @binding(3) var<uniform> params: EffectParams; + +@vertex +fn vs_main(@builtin(vertex_index) vertex_idx: u32) -> @builtin(position) vec4<f32> { + var pos = array<vec2<f32>, 3>( + vec2<f32>(-1.0, -1.0), + vec2<f32>(3.0, -1.0), + vec2<f32>(-1.0, 3.0) + ); + return vec4<f32>(pos[vertex_idx], 0.0, 1.0); +} + +@fragment +fn fs_main(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> { + let uv = pos.xy / common.resolution; + let color = textureSample(input_tex, input_sampler, uv); + + let d = distance(uv, vec2<f32>(0.5, 0.5)); + let vignette = smoothstep(params.radius, params.radius - params.softness, d); + + return vec4<f32>(color.rgb * mix(1.0, vignette, common.audio_intensity), color.a); +}
\ No newline at end of file diff --git a/assets/final/shaders/visual_debug.wgsl b/assets/final/shaders/visual_debug.wgsl index e91c1a9..63e1f13 100644 --- a/assets/final/shaders/visual_debug.wgsl +++ b/assets/final/shaders/visual_debug.wgsl @@ -1,7 +1,11 @@ -struct Uniforms { - viewProj : mat4x4<f32>, -} -@group(0) @binding(0) var<uniform> uniforms : Uniforms; +struct GlobalUniforms { + view_proj: mat4x4<f32>, + inv_view_proj: mat4x4<f32>, + camera_pos_time: vec4<f32>, + params: vec4<f32>, + resolution: vec2<f32>, +}; +@group(0) @binding(0) var<uniform> uniforms : GlobalUniforms; struct VertexInput { @location(0) position : vec3<f32>, @@ -16,7 +20,7 @@ struct VertexOutput { @vertex fn vs_main(in : VertexInput) -> VertexOutput { var out : VertexOutput; - out.position = uniforms.viewProj * vec4<f32>(in.position, 1.0); + out.position = uniforms.view_proj * vec4<f32>(in.position, 1.0); out.color = in.color; return out; } 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)" |