@forgeax/engine-vfx-render 0.1.2

package/src/shaders/billboard.wgsl

@@ -0,0 +1,132 @@
+#define_import_path forgeax::vfx-render.particles.billboard
+#import forgeax_view::common::{View, FogViewParams, FogRay, view}
+#import forgeax_view::fog::{apply_fog}
+
+@group(0) @binding(1) var scene_depth: texture_depth_2d;
+
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) local: vec2<f32>,
+  @location(2) emissive_intensity: vec4<f32>,
+  @location(3) surface: vec4<f32>,
+  @location(4) sheet_uv: vec2<f32>,
+  @location(5) sheet_frame: f32,
+  @location(6) fade_distance: f32,
+  @location(7) clip_position: vec3<f32>,
+};
+
+fn textureSheetFrame(age: f32, frameRate: f32, frameCount: u32) -> u32 {
+  if (frameCount == 0u || frameRate <= 0.0) { return 0u; }
+  return min(frameCount - 1u, u32(max(0.0, floor(age * frameRate))));
+}
+
+fn textureSheetUv(local: vec2<f32>, frame: u32, columns: u32, rows: u32) -> vec2<f32> {
+  let safeColumns = max(columns, 1u);
+  let safeRows = max(rows, 1u);
+  let cell = vec2<u32>(frame % safeColumns, frame / safeColumns);
+  return (local + vec2<f32>(1.0)) * 0.5 / vec2<f32>(f32(safeColumns), f32(safeRows)) +
+    vec2<f32>(f32(cell.x) / f32(safeColumns), f32(cell.y) / f32(safeRows));
+}
+
+fn billboardPivot(corner: vec2<f32>, pivot: vec2<f32>) -> vec2<f32> {
+  return corner + pivot * 2.0;
+}
+
+fn softParticleFactor(particleDepth: f32, sceneDepth: f32, fadeDistance: f32) -> f32 {
+  if (fadeDistance <= 0.0) { return 1.0; }
+  return clamp((sceneDepth - particleDepth) / fadeDistance, 0.0, 1.0);
+}
+
+fn billboardSortingKey(depth: f32, mode: u32) -> f32 {
+  return select(0.0, depth, mode == 2u);
+}
+
+fn softParticle(position: vec4<f32>, alpha: f32, fadeDistance: f32) -> f32 {
+  let pixel = vec2<i32>(position.xy);
+  let sceneDepth = textureLoad(scene_depth, pixel, 0);
+  if (fadeDistance <= 0.0) {
+    return select(alpha, 0.0, position.z > sceneDepth);
+  }
+  return alpha * softParticleFactor(position.z, sceneDepth, fadeDistance);
+}
+
+fn fogWorldPoint(ndc: vec3<f32>) -> vec3<f32> {
+  let homogeneous = view.inverseViewProj * vec4<f32>(ndc, 1.0);
+  let divisor = select(1.0, homogeneous.w, abs(homogeneous.w) > 0.000001);
+  return homogeneous.xyz / divisor;
+}
+
+fn fogRayFromNdc(ndc: vec3<f32>) -> FogRay {
+  let worldPosition = fogWorldPoint(ndc);
+  let nearPosition = fogWorldPoint(vec3<f32>(ndc.xy, 0.0));
+  let farPosition = fogWorldPoint(vec3<f32>(ndc.xy, 1.0));
+  let perspective = view.temporalProjection.z < 0.5;
+  let perspectiveVector = worldPosition - view.cameraPos;
+  let orthographicVector = farPosition - nearPosition;
+  let direction = normalize(select(orthographicVector, perspectiveVector, perspective));
+  let origin = select(nearPosition, view.cameraPos, perspective);
+  let ray_distance = select(
+    max(dot(worldPosition - nearPosition, direction), 0.0),
+    length(perspectiveVector),
+    perspective,
+  );
+  return FogRay(origin, direction, ray_distance);
+}
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) right: vec2<f32>,
+  @location(2) up: vec2<f32>,
+  @location(3) particle_color: vec4<f32>,
+  @location(4) base_color: vec4<f32>,
+  @location(5) emissive_intensity: vec4<f32>,
+  @location(6) surface: vec4<f32>,
+  @location(7) advanced: vec4<f32>,
+  @location(8) texture_sheet: vec4<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput, @builtin(vertex_index) vertex_index: u32) -> VertexOutput {
+  let corners = array<vec2<f32>, 6>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
+    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, 1.0), vec2<f32>(-1.0, 1.0)
+  );
+  let corner = billboardPivot(corners[vertex_index], input.advanced.xy);
+  var output: VertexOutput;
+  let clipPosition = vec3<f32>(
+    input.position.xy + input.right * corner.x + input.up * corner.y,
+    input.position.z,
+  );
+  output.position = vec4<f32>(clipPosition, 1.0);
+  output.clip_position = clipPosition;
+  output.color = input.particle_color * input.base_color;
+  output.local = corner;
+  output.emissive_intensity = input.emissive_intensity;
+  output.surface = input.surface;
+  output.sheet_uv = textureSheetUv(
+    corners[vertex_index],
+    u32(input.advanced.z),
+    u32(input.texture_sheet.x),
+    u32(input.texture_sheet.y),
+  );
+  output.sheet_frame = input.advanced.z;
+  output.fade_distance = input.texture_sheet.z;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let radius = length(input.local);
+  let edge = 1.0 - smoothstep(0.45, 1.0, radius);
+  let core = 1.0 - smoothstep(0.0, 0.42, radius);
+  let roughness = clamp(input.surface.y, 0.04, 1.0);
+  let clearcoat = clamp(input.surface.z, 0.0, 1.0);
+  let highlight = core * clearcoat * (1.0 - roughness * 0.65);
+  let emissive = input.emissive_intensity.rgb * input.emissive_intensity.a;
+  let alpha = softParticle(input.position, input.color.a * edge, input.fade_distance);
+  let sheetPulse = 0.82 + 0.18 * fract(input.sheet_frame * 0.618 + input.sheet_uv.x + input.sheet_uv.y);
+  let rgb = (input.color.rgb + emissive * (0.35 + core * 0.65) + vec3<f32>(highlight)) * sheetPulse;
+  let fogged = apply_fog(view.fog, fogRayFromNdc(input.clip_position), vec4<f32>(rgb, alpha));
+  return vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+}

package/src/shaders/event.wgsl

@@ -0,0 +1,11 @@
+struct ForgeaxVfxEventShaderRecord {
+  position: vec4<f32>,
+  strength: f32,
+  sequence: u32,
+  channel: u32,
+  fan_out: u32,
+}
+
+fn forgeax_vfx_event_strength(record: ForgeaxVfxEventShaderRecord) -> f32 {
+  return max(record.strength, 0.0);
+}

package/src/shaders/mesh.wgsl

@@ -0,0 +1,98 @@
+#define_import_path forgeax::vfx-render.particles.mesh
+#import forgeax_view::common::{View, FogViewParams, FogRay, view}
+#import forgeax_view::fog::{apply_fog}
+
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) emissive_intensity: vec4<f32>,
+  @location(3) surface: vec4<f32>,
+  @location(4) clip_position: vec3<f32>,
+};
+
+struct VertexInput {
+  @location(0) geometry_position: vec3<f32>,
+  @location(1) geometry_normal: vec3<f32>,
+  @location(2) geometry_uv: vec2<f32>,
+  @location(3) geometry_tangent: vec4<f32>,
+  @location(4) center: vec3<f32>,
+  @location(5) right: vec3<f32>,
+  @location(6) up: vec3<f32>,
+  @location(7) forward: vec3<f32>,
+  @location(8) particle_color: vec4<f32>,
+  @location(9) base_color: vec4<f32>,
+  @location(10) emissive_intensity: vec4<f32>,
+  @location(11) surface: vec4<f32>,
+};
+
+fn fogWorldPoint(ndc: vec3<f32>) -> vec3<f32> {
+  let homogeneous = view.inverseViewProj * vec4<f32>(ndc, 1.0);
+  let divisor = select(1.0, homogeneous.w, abs(homogeneous.w) > 0.000001);
+  return homogeneous.xyz / divisor;
+}
+
+fn fogRayFromNdc(ndc: vec3<f32>) -> FogRay {
+  let worldPosition = fogWorldPoint(ndc);
+  let nearPosition = fogWorldPoint(vec3<f32>(ndc.xy, 0.0));
+  let farPosition = fogWorldPoint(vec3<f32>(ndc.xy, 1.0));
+  let perspective = view.temporalProjection.z < 0.5;
+  let perspectiveVector = worldPosition - view.cameraPos;
+  let orthographicVector = farPosition - nearPosition;
+  let direction = normalize(select(orthographicVector, perspectiveVector, perspective));
+  let origin = select(nearPosition, view.cameraPos, perspective);
+  let ray_distance = select(
+    max(dot(worldPosition - nearPosition, direction), 0.0),
+    length(perspectiveVector),
+    perspective,
+  );
+  return FogRay(origin, direction, ray_distance);
+}
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  let offset =
+    input.right * input.geometry_position.x +
+    input.up * input.geometry_position.y +
+    input.forward * input.geometry_position.z;
+  let clipPosition = input.center + offset;
+  output.position = vec4<f32>(clipPosition, 1.0);
+  output.clip_position = clipPosition;
+  output.color = input.particle_color * input.base_color;
+  output.normal = normalize(
+    input.right * input.geometry_normal.x +
+    input.up * input.geometry_normal.y +
+    input.forward * input.geometry_normal.z
+  );
+  output.emissive_intensity = input.emissive_intensity;
+  output.surface = input.surface;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let normal = normalize(input.normal);
+  let light_direction = normalize(vec3<f32>(0.35, 0.7, 0.55));
+  let view_direction = vec3<f32>(0.0, 0.0, 1.0);
+  let half_direction = normalize(light_direction + view_direction);
+  let diffuse = 0.2 + 0.8 * max(dot(normal, light_direction), 0.0);
+  let metallic = clamp(input.surface.x, 0.0, 1.0);
+  let roughness = clamp(input.surface.y, 0.04, 1.0);
+  let clearcoat = clamp(input.surface.z, 0.0, 1.0);
+  let clearcoat_roughness = clamp(input.surface.w, 0.04, 1.0);
+  let specular_power = mix(96.0, 4.0, roughness);
+  let coat_power = mix(192.0, 8.0, clearcoat_roughness);
+  let specular = pow(max(dot(normal, half_direction), 0.0), specular_power);
+  let coat = clearcoat * pow(max(dot(normal, half_direction), 0.0), coat_power);
+  let dielectric = vec3<f32>(0.04);
+  let specular_color = mix(dielectric, input.color.rgb, metallic);
+  let lit = input.color.rgb * diffuse * (1.0 - metallic * 0.55);
+  let emissive = input.emissive_intensity.rgb * input.emissive_intensity.a;
+  let fogged = apply_fog(
+    view.fog,
+    fogRayFromNdc(input.clip_position),
+    vec4<f32>(lit + specular_color * specular + vec3<f32>(coat) + emissive, input.color.a),
+  );
+  return vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+}

package/src/shaders/ribbon.wgsl

@@ -0,0 +1,69 @@
+#define_import_path forgeax::vfx-render.particles.ribbon
+#import forgeax_view::common::{View, FogViewParams, FogRay, view}
+#import forgeax_view::fog::{apply_fog}
+
+struct SegmentInput {
+  @location(0) start: vec3<f32>,
+  @location(1) endpoint: vec3<f32>,
+  @location(2) color: vec4<f32>,
+  @location(3) properties: vec2<f32>,
+}
+
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) clip_position: vec3<f32>,
+}
+
+fn fogWorldPoint(ndc: vec3<f32>) -> vec3<f32> {
+  let homogeneous = view.inverseViewProj * vec4<f32>(ndc, 1.0);
+  let divisor = select(1.0, homogeneous.w, abs(homogeneous.w) > 0.000001);
+  return homogeneous.xyz / divisor;
+}
+
+fn fogRayFromNdc(ndc: vec3<f32>) -> FogRay {
+  let worldPosition = fogWorldPoint(ndc);
+  let nearPosition = fogWorldPoint(vec3<f32>(ndc.xy, 0.0));
+  let farPosition = fogWorldPoint(vec3<f32>(ndc.xy, 1.0));
+  let perspective = view.temporalProjection.z < 0.5;
+  let perspectiveVector = worldPosition - view.cameraPos;
+  let orthographicVector = farPosition - nearPosition;
+  let direction = normalize(select(orthographicVector, perspectiveVector, perspective));
+  let origin = select(nearPosition, view.cameraPos, perspective);
+  let ray_distance = select(
+    max(dot(worldPosition - nearPosition, direction), 0.0),
+    length(perspectiveVector),
+    perspective,
+  );
+  return FogRay(origin, direction, ray_distance);
+}
+
+@vertex
+fn vs_main(input: SegmentInput, @builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  let corners = array<vec2<f32>, 6>(
+    vec2<f32>(0.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
+    vec2<f32>(0.0, -1.0), vec2<f32>(1.0, 1.0), vec2<f32>(0.0, 1.0)
+  );
+  let corner = corners[vertexIndex];
+  let delta = input.endpoint.xy - input.start.xy;
+  let normal = normalize(vec2<f32>(-delta.y, delta.x) + vec2<f32>(0.000001, 0.0));
+  let point = mix(input.start, input.endpoint, corner.x);
+  let clipPosition = vec3<f32>(point.xy + normal * corner.y * input.properties.x, point.z);
+  var output: VertexOutput;
+  output.position = vec4<f32>(clipPosition, 1.0);
+  output.color = input.color;
+  output.clip_position = clipPosition;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let base = vec4<f32>(0.2, 0.7, 1.0, 0.9);
+  let alpha = base.a * input.color.a;
+  let fogged = apply_fog(
+    view.fog,
+    fogRayFromNdc(input.clip_position),
+    vec4<f32>(base.rgb * input.color.rgb, alpha),
+  );
+  return fogged;
+}

package/src/shaders/stage.wgsl

@@ -0,0 +1,5 @@
+// Managed particle stages are emitted by the compiler and dispatched by the RenderFeature.
+// This shared ABI helper keeps the particle-domain bounds explicit at the shader boundary.
+fn forgeax_vfx_stage_in_bounds(index: u32, capacity: u32) -> bool {
+  return index < capacity;
+}

package/src/shaders/trail.wgsl

@@ -0,0 +1,77 @@
+#define_import_path forgeax::vfx-render.particles.trail
+#import forgeax_view::common::{View, FogViewParams, FogRay, view}
+#import forgeax_view::fog::{apply_fog}
+
+struct SegmentInput {
+  @location(0) start: vec3<f32>,
+  @location(1) endpoint: vec3<f32>,
+  @location(2) color: vec4<f32>,
+  @location(3) properties: vec2<f32>,
+}
+
+struct VertexOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) clip_position: vec3<f32>,
+}
+
+fn fogWorldPoint(ndc: vec3<f32>) -> vec3<f32> {
+  let homogeneous = view.inverseViewProj * vec4<f32>(ndc, 1.0);
+  let divisor = select(1.0, homogeneous.w, abs(homogeneous.w) > 0.000001);
+  return homogeneous.xyz / divisor;
+}
+
+fn fogRayFromNdc(ndc: vec3<f32>) -> FogRay {
+  let worldPosition = fogWorldPoint(ndc);
+  let nearPosition = fogWorldPoint(vec3<f32>(ndc.xy, 0.0));
+  let farPosition = fogWorldPoint(vec3<f32>(ndc.xy, 1.0));
+  let perspective = view.temporalProjection.z < 0.5;
+  let perspectiveVector = worldPosition - view.cameraPos;
+  let orthographicVector = farPosition - nearPosition;
+  let direction = normalize(select(orthographicVector, perspectiveVector, perspective));
+  let origin = select(nearPosition, view.cameraPos, perspective);
+  let ray_distance = select(
+    max(dot(worldPosition - nearPosition, direction), 0.0),
+    length(perspectiveVector),
+    perspective,
+  );
+  return FogRay(origin, direction, ray_distance);
+}
+
+@vertex
+fn vs_main(input: SegmentInput, @builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  let corners = array<vec2<f32>, 6>(
+    vec2<f32>(0.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
+    vec2<f32>(0.0, -1.0), vec2<f32>(1.0, 1.0), vec2<f32>(0.0, 1.0)
+  );
+  let corner = corners[vertexIndex];
+  let delta = input.endpoint.xy - input.start.xy;
+  let normal = normalize(vec2<f32>(-delta.y, delta.x) + vec2<f32>(0.000001, 0.0));
+  let tangent = normalize(delta + vec2<f32>(0.000001, 0.0));
+  let taper = max(0.0, 1.0 - input.properties.y);
+  let point = mix(input.start, input.endpoint, corner.x) + vec3<f32>(
+    tangent * ((corner.x * 2.0 - 1.0) * input.properties.x),
+    0.0,
+  );
+  let clipPosition = vec3<f32>(
+    point.xy + normal * corner.y * input.properties.x * taper,
+    point.z,
+  );
+  var output: VertexOutput;
+  output.position = vec4<f32>(clipPosition, 1.0);
+  output.color = input.color;
+  output.clip_position = clipPosition;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let base = vec4<f32>(0.8, 0.35, 0.1, 1.0);
+  let alpha = base.a * input.color.a;
+  let fogged = apply_fog(
+    view.fog,
+    fogRayFromNdc(input.clip_position),
+    vec4<f32>(base.rgb * input.color.rgb, alpha),
+  );
+  return vec4<f32>(fogged.rgb * fogged.a, fogged.a);
+}