Files
Blacksite/third_party/bevy_solari/src/scene/raytracing_scene_bindings.wgsl
T
Rbanh 0798aa5d57 Build renderer and material component foundations
Add dedicated skinned rendering, pose restoration, shared Material and Material Instance slots, registry-driven components, Surface/Solari integration, transactional schema upgrades, navigation authoring, documentation, and evaluation evidence.
2026-07-12 00:24:06 -04:00

397 lines
14 KiB
WebGPU Shading Language

enable wgpu_ray_query;
#define_import_path bevy_solari::scene_bindings
#import bevy_pbr::lighting::perceptualRoughnessToRoughness
#import bevy_pbr::pbr_functions::calculate_tbn_mikktspace
struct InstanceGeometryIds {
vertex_buffer_id: u32,
vertex_buffer_offset: u32,
index_buffer_id: u32,
index_buffer_offset: u32,
triangle_count: u32,
}
struct VertexBuffer { vertices: array<PackedVertex> }
struct IndexBuffer { indices: array<u32> }
struct PackedVertex {
a: vec4<f32>,
b: vec4<f32>,
tangent: vec4<f32>,
}
struct Vertex {
position: vec3<f32>,
normal: vec3<f32>,
uv: vec2<f32>,
tangent: vec4<f32>,
}
fn unpack_vertex(packed: PackedVertex) -> Vertex {
var vertex: Vertex;
vertex.position = packed.a.xyz;
vertex.normal = vec3(packed.a.w, packed.b.xy);
vertex.uv = packed.b.zw;
vertex.tangent = packed.tangent;
return vertex;
}
struct SurfaceUniform {
shader_id: u32,
flags: u32,
alpha_cutoff: f32,
abi_version: u32,
params: array<vec4<f32>, 16>,
uv_transforms: array<vec4<f32>, 8>,
}
struct Material {
texture_ids: vec4<u32>,
surface_texture_ids_0: vec4<u32>,
surface_texture_ids_1: vec4<u32>,
material_info: vec4<u32>,
base_color: vec4<f32>,
emissive_roughness: vec4<f32>,
pbr: vec4<f32>,
surface_uniform: SurfaceUniform,
}
const TEXTURE_MAP_NONE = 0xFFFFFFFFu;
const MATERIAL_FLAG_ALPHA_CUTOUT = 1u << 0u;
const MATERIAL_FLAG_SURFACE = 1u << 1u;
const BLACKSITE_SURFACE_UNLIT = 1u;
const MIRROR_ROUGHNESS_THRESHOLD = 0.001f;
struct LightSource {
kind: u32, // 1 bit for kind, 31 bits for extra data
id: u32,
}
const LIGHT_SOURCE_KIND_EMISSIVE_MESH = 0u;
const LIGHT_SOURCE_KIND_DIRECTIONAL = 1u;
struct DirectionalLight {
direction_to_light: vec3<f32>,
cos_theta_max: f32,
luminance: vec3<f32>,
inverse_pdf: f32,
}
const LIGHT_NOT_PRESENT_THIS_FRAME = 0xFFFFFFFFu;
@group(0) @binding(0) var<storage> vertex_buffers: binding_array<VertexBuffer>;
@group(0) @binding(1) var<storage> index_buffers: binding_array<IndexBuffer>;
@group(0) @binding(2) var textures: binding_array<texture_2d<f32>>;
@group(0) @binding(3) var samplers: binding_array<sampler>;
@group(0) @binding(4) var<storage> materials: array<Material>;
@group(0) @binding(5) var tlas: acceleration_structure;
@group(0) @binding(6) var<storage> transforms: array<mat4x4<f32>>; // TODO: Use mat3x4<f32>?
@group(0) @binding(7) var<storage> previous_frame_transforms: array<mat4x4<f32>>; // TODO: Use mat3x4<f32>?
@group(0) @binding(8) var<storage> geometry_ids: array<InstanceGeometryIds>;
@group(0) @binding(9) var<storage> material_ids: array<u32>; // TODO: Store material_id in instance_custom_index instead?
@group(0) @binding(10) var<storage> light_sources: array<LightSource>;
@group(0) @binding(11) var<storage> directional_lights: array<DirectionalLight>;
@group(0) @binding(12) var<storage> previous_frame_light_id_translations: array<u32>;
@group(0) @binding(13) var brdf_dfg_lut: texture_2d<f32>;
@group(0) @binding(14) var brdf_dfg_lut_sampler: sampler;
const RAY_T_MIN = 0.001f;
const RAY_T_MAX = 100000.0f;
const RAY_NO_CULL = 0xFFu;
fn trace_ray(ray_origin: vec3<f32>, ray_direction: vec3<f32>, ray_t_min: f32, ray_t_max: f32, ray_flag: u32) -> RayIntersection {
let ray = RayDesc(ray_flag, RAY_NO_CULL, ray_t_min, ray_t_max, ray_origin, ray_direction);
var rq: ray_query;
rayQueryInitialize(&rq, tlas, ray);
while (rayQueryProceed(&rq)) {
let candidate = rayQueryGetCandidateIntersection(&rq);
if candidate.kind == RAY_QUERY_INTERSECTION_TRIANGLE && candidate_passes_alpha(candidate) {
rayQueryConfirmIntersection(&rq);
}
}
return rayQueryGetCommittedIntersection(&rq);
}
fn sample_texture(id: u32, uv: vec2<f32>) -> vec4<f32> {
return textureSampleLevel(textures[id], samplers[id], uv, 0.0); // TODO: Mipmap
}
struct SurfaceInput {
uv0: vec2<f32>,
world_position: vec3<f32>,
world_normal: vec3<f32>,
}
struct SurfaceParams {
lanes: array<vec4<f32>, 16>,
}
struct SurfaceSamples {
values: array<vec4<f32>, 8>,
}
struct Surface {
base_color: vec4<f32>,
normal_ts: vec3<f32>,
emissive: vec3<f32>,
metallic: f32,
perceptual_roughness: f32,
reflectance: f32,
occlusion: f32,
model: u32,
}
fn surface_default() -> Surface {
var surface: Surface;
surface.base_color = vec4<f32>(1.0);
surface.normal_ts = vec3<f32>(0.0, 0.0, 1.0);
surface.emissive = vec3<f32>(0.0);
surface.metallic = 0.0;
surface.perceptual_roughness = 0.5;
surface.reflectance = 0.5;
surface.occlusion = 1.0;
surface.model = 0u;
return surface;
}
fn surface_texture_id(material: Material, index: u32) -> u32 {
if index < 4u {
return material.surface_texture_ids_0[index];
}
return material.surface_texture_ids_1[index - 4u];
}
fn surface_samples(material: Material, uv: vec2<f32>) -> SurfaceSamples {
var samples: SurfaceSamples;
for (var index = 0u; index < 8u; index += 1u) {
let transform = material.surface_uniform.uv_transforms[index];
let transformed_uv = uv * transform.xy + transform.zw;
let texture_id = surface_texture_id(material, index);
samples.values[index] = vec4<f32>(1.0);
if texture_id != TEXTURE_MAP_NONE {
samples.values[index] = sample_texture(texture_id, transformed_uv);
}
}
return samples;
}
// BLACKSITE_SURFACE_EVALUATOR_LIBRARY
fn evaluate_surface(
shader_id: u32,
input: SurfaceInput,
params: SurfaceParams,
samples: SurfaceSamples,
) -> Surface {
// BLACKSITE_SURFACE_EVALUATOR_DISPATCH
return surface_default();
}
struct ResolvedMaterial {
base_color: vec3<f32>,
emissive: vec3<f32>,
reflectance: f32,
perceptual_roughness: f32,
roughness: f32,
metallic: f32,
}
struct ResolvedSurface {
material: ResolvedMaterial,
normal_ts: vec3<f32>,
alpha: f32,
}
struct ResolvedRayHitFull {
world_position: vec3<f32>,
previous_frame_world_position: vec3<f32>,
world_normal: vec3<f32>,
geometric_world_normal: vec3<f32>,
world_tangent: vec4<f32>,
uv: vec2<f32>,
triangle_area: f32,
triangle_count: u32,
material: ResolvedMaterial,
}
fn resolve_standard_surface(material: Material, uv: vec2<f32>) -> ResolvedSurface {
var m: ResolvedMaterial;
var base_color = material.base_color;
if material.texture_ids.y != TEXTURE_MAP_NONE {
base_color *= sample_texture(material.texture_ids.y, uv);
}
m.base_color = base_color.rgb;
m.emissive = material.emissive_roughness.rgb;
if material.texture_ids.z != TEXTURE_MAP_NONE {
m.emissive *= sample_texture(material.texture_ids.z, uv).rgb;
}
m.reflectance = material.pbr.y;
m.perceptual_roughness = material.emissive_roughness.w;
m.metallic = material.pbr.x;
if material.texture_ids.w != TEXTURE_MAP_NONE {
let metallic_roughness = sample_texture(material.texture_ids.w, uv).rgb;
m.perceptual_roughness *= metallic_roughness.g;
m.metallic *= metallic_roughness.b;
}
m.roughness = m.perceptual_roughness * m.perceptual_roughness;
return ResolvedSurface(m, vec3<f32>(0.0, 0.0, 1.0), base_color.a);
}
fn resolve_surface(
material: Material,
uv: vec2<f32>,
world_position: vec3<f32>,
world_normal: vec3<f32>,
) -> ResolvedSurface {
if (material.material_info.x & MATERIAL_FLAG_SURFACE) == 0u {
return resolve_standard_surface(material, uv);
}
let input = SurfaceInput(uv, world_position, world_normal);
let params = SurfaceParams(material.surface_uniform.params);
let surface = evaluate_surface(
material.surface_uniform.shader_id,
input,
params,
surface_samples(material, uv),
);
var m: ResolvedMaterial;
m.base_color = surface.base_color.rgb * clamp(surface.occlusion, 0.0, 1.0);
m.emissive = surface.emissive;
m.reflectance = clamp(surface.reflectance, 0.0, 1.0);
m.perceptual_roughness = clamp(surface.perceptual_roughness, 0.001, 1.0);
m.roughness = m.perceptual_roughness * m.perceptual_roughness;
m.metallic = clamp(surface.metallic, 0.0, 1.0);
if surface.model == BLACKSITE_SURFACE_UNLIT {
m.emissive += surface.base_color.rgb;
m.base_color = vec3<f32>(0.0);
m.metallic = 0.0;
m.perceptual_roughness = 1.0;
m.roughness = 1.0;
}
return ResolvedSurface(m, surface.normal_ts, surface.base_color.a);
}
fn resolve_ray_hit_full(ray_hit: RayIntersection) -> ResolvedRayHitFull {
let barycentrics = vec3(1.0 - ray_hit.barycentrics.x - ray_hit.barycentrics.y, ray_hit.barycentrics);
return resolve_triangle_data_full(ray_hit.instance_index, ray_hit.primitive_index, barycentrics);
}
fn load_vertices(instance_geometry_ids: InstanceGeometryIds, triangle_id: u32) -> array<Vertex, 3> {
let index_buffer = &index_buffers[instance_geometry_ids.index_buffer_id].indices;
let vertex_buffer = &vertex_buffers[instance_geometry_ids.vertex_buffer_id].vertices;
let indices_i = (triangle_id * 3u) + vec3(0u, 1u, 2u) + instance_geometry_ids.index_buffer_offset;
let indices = vec3((*index_buffer)[indices_i.x], (*index_buffer)[indices_i.y], (*index_buffer)[indices_i.z]) + instance_geometry_ids.vertex_buffer_offset;
return array<Vertex, 3>(
unpack_vertex((*vertex_buffer)[indices.x]),
unpack_vertex((*vertex_buffer)[indices.y]),
unpack_vertex((*vertex_buffer)[indices.z])
);
}
fn transform_positions(transform: mat4x4<f32>, vertices: array<Vertex, 3>) -> array<vec3<f32>, 3> {
return array<vec3<f32>, 3>(
(transform * vec4(vertices[0].position, 1.0)).xyz,
(transform * vec4(vertices[1].position, 1.0)).xyz,
(transform * vec4(vertices[2].position, 1.0)).xyz
);
}
fn candidate_passes_alpha(candidate: RayIntersection) -> bool {
let material = materials[material_ids[candidate.instance_index]];
if (material.material_info.x & MATERIAL_FLAG_ALPHA_CUTOUT) == 0u {
return true;
}
let barycentrics = vec3(
1.0 - candidate.barycentrics.x - candidate.barycentrics.y,
candidate.barycentrics,
);
let instance_geometry_ids = geometry_ids[candidate.instance_index];
let vertices = load_vertices(instance_geometry_ids, candidate.primitive_index);
let transform = transforms[candidate.instance_index];
let world_vertices = transform_positions(transform, vertices);
let world_position = mat3x3(world_vertices[0], world_vertices[1], world_vertices[2]) * barycentrics;
let uv = mat3x2(vertices[0].uv, vertices[1].uv, vertices[2].uv) * barycentrics;
let local_normal = mat3x3(vertices[0].normal, vertices[1].normal, vertices[2].normal) * barycentrics;
let world_normal = normalize(mat3x3(transform[0].xyz, transform[1].xyz, transform[2].xyz) * local_normal);
let resolved = resolve_surface(material, uv, world_position, world_normal);
let cutoff = select(
material.pbr.z,
material.surface_uniform.alpha_cutoff,
(material.material_info.x & MATERIAL_FLAG_SURFACE) != 0u,
);
return resolved.alpha >= cutoff;
}
fn resolve_triangle_data_full(instance_id: u32, triangle_id: u32, barycentrics: vec3<f32>) -> ResolvedRayHitFull {
let material_id = material_ids[instance_id];
let material = materials[material_id];
let transform = transforms[instance_id];
let previous_frame_transform = previous_frame_transforms[instance_id];
let instance_geometry_ids = geometry_ids[instance_id];
let vertices = load_vertices(instance_geometry_ids, triangle_id);
let world_vertices = transform_positions(transform, vertices);
let world_position = mat3x3(world_vertices[0], world_vertices[1], world_vertices[2]) * barycentrics;
let previous_frame_world_vertices = transform_positions(previous_frame_transform, vertices);
let previous_frame_world_position = mat3x3(previous_frame_world_vertices[0], previous_frame_world_vertices[1], previous_frame_world_vertices[2]) * barycentrics;
let uv = mat3x2(vertices[0].uv, vertices[1].uv, vertices[2].uv) * barycentrics;
let local_tangent = mat3x3(vertices[0].tangent.xyz, vertices[1].tangent.xyz, vertices[2].tangent.xyz) * barycentrics;
let world_tangent = vec4(
normalize(mat3x3(transform[0].xyz, transform[1].xyz, transform[2].xyz) * local_tangent),
vertices[0].tangent.w,
);
let local_normal = mat3x3(vertices[0].normal, vertices[1].normal, vertices[2].normal) * barycentrics; // TODO: Use barycentric lerp, ray_hit.object_to_world, cross product geo normal
var world_normal = normalize(mat3x3(transform[0].xyz, transform[1].xyz, transform[2].xyz) * local_normal);
let geometric_world_normal = world_normal;
let resolved_surface = resolve_surface(material, uv, world_position, world_normal);
if (material.material_info.x & MATERIAL_FLAG_SURFACE) != 0u {
let TBN = calculate_tbn_mikktspace(world_normal, world_tangent);
let Nt = normalize(resolved_surface.normal_ts);
world_normal = normalize(Nt.x * TBN[0] + Nt.y * TBN[1] + Nt.z * TBN[2]);
} else if material.texture_ids.x != TEXTURE_MAP_NONE {
let TBN = calculate_tbn_mikktspace(world_normal, world_tangent);
let T = TBN[0];
let B = TBN[1];
let N = TBN[2];
let Nt = sample_texture(material.texture_ids.x, uv).xyz;
world_normal = normalize(Nt.x * T + Nt.y * B + Nt.z * N);
}
let triangle_edge0 = world_vertices[0] - world_vertices[1];
let triangle_edge1 = world_vertices[0] - world_vertices[2];
let triangle_area = length(cross(triangle_edge0, triangle_edge1)) / 2.0;
return ResolvedRayHitFull(
world_position,
previous_frame_world_position,
world_normal,
geometric_world_normal,
world_tangent,
uv,
triangle_area,
instance_geometry_ids.triangle_count,
resolved_surface.material,
);
}