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 } struct IndexBuffer { indices: array } struct PackedVertex { a: vec4, b: vec4, tangent: vec4, } struct Vertex { position: vec3, normal: vec3, uv: vec2, tangent: vec4, } 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, 16>, uv_transforms: array, 8>, } struct Material { texture_ids: vec4, surface_texture_ids_0: vec4, surface_texture_ids_1: vec4, material_info: vec4, base_color: vec4, emissive_roughness: vec4, pbr: vec4, 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, cos_theta_max: f32, luminance: vec3, inverse_pdf: f32, } const LIGHT_NOT_PRESENT_THIS_FRAME = 0xFFFFFFFFu; @group(0) @binding(0) var vertex_buffers: binding_array; @group(0) @binding(1) var index_buffers: binding_array; @group(0) @binding(2) var textures: binding_array>; @group(0) @binding(3) var samplers: binding_array; @group(0) @binding(4) var materials: array; @group(0) @binding(5) var tlas: acceleration_structure; @group(0) @binding(6) var transforms: array>; // TODO: Use mat3x4? @group(0) @binding(7) var previous_frame_transforms: array>; // TODO: Use mat3x4? @group(0) @binding(8) var geometry_ids: array; @group(0) @binding(9) var material_ids: array; // TODO: Store material_id in instance_custom_index instead? @group(0) @binding(10) var light_sources: array; @group(0) @binding(11) var directional_lights: array; @group(0) @binding(12) var previous_frame_light_id_translations: array; @group(0) @binding(13) var brdf_dfg_lut: texture_2d; @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, ray_direction: vec3, 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) -> vec4 { return textureSampleLevel(textures[id], samplers[id], uv, 0.0); // TODO: Mipmap } struct SurfaceInput { uv0: vec2, world_position: vec3, world_normal: vec3, } struct SurfaceParams { lanes: array, 16>, } struct SurfaceSamples { values: array, 8>, } struct Surface { base_color: vec4, normal_ts: vec3, emissive: vec3, metallic: f32, perceptual_roughness: f32, reflectance: f32, occlusion: f32, model: u32, } fn surface_default() -> Surface { var surface: Surface; surface.base_color = vec4(1.0); surface.normal_ts = vec3(0.0, 0.0, 1.0); surface.emissive = vec3(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) -> 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(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, emissive: vec3, reflectance: f32, perceptual_roughness: f32, roughness: f32, metallic: f32, } struct ResolvedSurface { material: ResolvedMaterial, normal_ts: vec3, alpha: f32, } struct ResolvedRayHitFull { world_position: vec3, previous_frame_world_position: vec3, world_normal: vec3, geometric_world_normal: vec3, world_tangent: vec4, uv: vec2, triangle_area: f32, triangle_count: u32, material: ResolvedMaterial, } fn resolve_standard_surface(material: Material, uv: vec2) -> 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(0.0, 0.0, 1.0), base_color.a); } fn resolve_surface( material: Material, uv: vec2, world_position: vec3, world_normal: vec3, ) -> 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(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 { 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( unpack_vertex((*vertex_buffer)[indices.x]), unpack_vertex((*vertex_buffer)[indices.y]), unpack_vertex((*vertex_buffer)[indices.z]) ); } fn transform_positions(transform: mat4x4, vertices: array) -> array, 3> { return array, 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) -> 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, ); }