render-zig

mesh_clusters.wgsl (5731B)

---

 struct VertexInput {
     @location(0) position: vec4<f32>,
     @location(1) normal: vec3<f32>,
     @location(2) tex_coord: vec3<f32>,
     @location(3) tangent: vec3<f32>,
     @location(4) bitangent: vec3<f32>,
 };
 
 struct VertexOutput {
     @builtin(position) clip_position: vec4<f32>,
     @location(0) tex_coord: vec3<f32>,
     @location(1) pt_fragment: vec3<f32>,
     @location(2) pt_light: vec3<f32>,
     @location(3) pt_camera: vec3<f32>,
     @location(4) @interpolate(flat) instance_id: u32,
 };
 
 @group(0) @binding(0)
 var<storage, read> instances: array<Instance>;
 struct Instance {
     model_matrix: mat4x4<f32>,
     material: Material,
 };
 struct Material {
     albedo: u32,
     normal: u32,
     roughness: u32,
     metalness: u32,
 };
 
 @group(0) @binding(4)
 var<storage, read> clusters: array<Cluster>;
 struct Cluster {
     model_id: u32,
 };
 
 @group(0) @binding(1)
 var<uniform> uniform_data: UniformData;
 struct UniformData {
     pw_camera: vec3<f32>,
     view_matrix: mat4x4<f32>,
     proj_matrix: mat4x4<f32>,
 };
 
 @vertex fn vertex(
     in: VertexInput,
     @builtin(instance_index) idx: u32,
 ) -> VertexOutput {
     let model_id = clusters[idx].model_id;
     let model_matrix = instances[model_id].model_matrix;
     let camera_matrix = uniform_data.proj_matrix * uniform_data.view_matrix;
 
     let t = normalize((model_matrix * vec4(in.tangent, 0.0)).xyz);
     let b = normalize((model_matrix * vec4(in.bitangent, 0.0)).xyz);
     let n = normalize((model_matrix * vec4(in.normal, 0.0)).xyz);
     let tangent_matrix = mat3x3<f32>(t, b, n);
 
     let world_position = model_matrix * in.position;
     let tangent_position = tangent_matrix * world_position.xyz;
 
     let light_position = vec3<f32>(20, 80, 20);
     let tangent_light_position = tangent_matrix * light_position;
 
     let pt_camera = tangent_matrix * uniform_data.pw_camera;
 
 
     return VertexOutput(
         camera_matrix * world_position,
         in.tex_coord,
         tangent_position,
         tangent_light_position,
         pt_camera,
         idx,
     );
 }
 
 
 @group(0) @binding(2) var material_sampler: sampler;
 @group(0) @binding(3) var material_texture: texture_2d_array<f32>;
 
 fn diffuse_lambert(albedo: vec3<f32>) -> vec3<f32> {
     return albedo * 0.31830988618;
 }
 
 fn distribution_trowbridge_reitz_ggx(
     n_dot_h: f32,
     alpha: f32,
 ) -> f32 {
     let alpha_squared = alpha * alpha;
     let n_dot_h_squared = n_dot_h * n_dot_h;
     let denom = n_dot_h_squared * (alpha_squared - 1) + 1;
     let denom_squared = denom * denom;
     return alpha_squared / (3.14159265359 * denom_squared);
 }
 
 fn geometry_schlick_ggx(
     n_dot_x: f32,
     alpha: f32,
 ) -> f32 {
     let k = 0.5 * alpha;
     let denom = n_dot_x * (1.0 - k) + k;
     return n_dot_x / denom;
 }
 
 fn geometry_smith(
     n_dot_l: f32,
     n_dot_v: f32,
     alpha: f32,
 ) -> f32 {
     let g1 = geometry_schlick_ggx(n_dot_l, alpha);
     let g2 = geometry_schlick_ggx(n_dot_v, alpha);
     return g1 * g2;
 }
 
 fn fresnel_schlick(
     f0: vec3<f32>,
     v_dot_h: f32,
 ) -> vec3<f32> {
     return f0 + (1.0 - f0) * pow(1.0 - v_dot_h, 5.0);
 }
 
 fn cook_torrance(
     n_dot_v: f32,
     n_dot_l: f32,
     n_dot_h: f32,
     roughness: f32,
 ) -> f32 {
     let alpha = roughness * roughness;
     let distribution = distribution_trowbridge_reitz_ggx(
         n_dot_h,
         alpha,
     );
     let geometry = geometry_smith(
         n_dot_l,
         n_dot_v,
         alpha,
     );
     let denom = 4.0 * n_dot_v * n_dot_l + 0.000001;
     return (distribution * geometry) / denom;
 }
 
 fn lighting(
     normal: vec3<f32>,
     p_fragment: vec3<f32>,
     p_camera: vec3<f32>,
     p_light: vec3<f32>,
     c_light: vec3<f32>,
     albedo: vec3<f32>,
     roughness: f32,
     metalness: f32,
 ) -> vec3<f32> {
     let v = normalize(p_camera - p_fragment);
     let l = normalize(p_light - p_fragment);
     let h = normalize(v + l);
 
     let n_dot_v = max(dot(normal, v), 0.0);
     let n_dot_l = max(dot(normal, l), 0.0);
     let n_dot_h = max(dot(normal, h), 0.0);
     let v_dot_h = max(dot(v, h), 0.0);
 
     let f0 = mix(vec3<f32>(0.04), albedo, metalness);
     let k_s = fresnel_schlick(f0, v_dot_h);
     let k_d = 1.0 - k_s;
 
     let diffuse = k_d * diffuse_lambert(albedo);
     let specular = k_s * cook_torrance(n_dot_v, n_dot_l, n_dot_h, roughness);
     let brdf = (diffuse + specular) * n_dot_l;
     return brdf * c_light;
 }
 
 @fragment fn fragment(in: VertexOutput) -> @location(0) vec4<f32> {
     let material = instances[in.instance_id].material;
     let uv = vec2<f32>(in.tex_coord.x, 1 - in.tex_coord.y);
     var albedo = textureSample(material_texture, material_sampler, uv, material.albedo).rgb;
     albedo = pow(albedo, vec3<f32>(2.2));
     var normal = textureSample(material_texture, material_sampler, uv, material.normal).rgb;
     normal = normalize(normal * 2.0 - 1.0);
     var roughness = textureSample(material_texture, material_sampler, uv, material.roughness).r;
     var metalness = textureSample(material_texture, material_sampler, uv, material.metalness).r;
 
     let light_color = normalize(vec3<f32>(23.47, 21.31, 20.79));
     //let light_color = normalize(vec3<f32>(0.9, 0.9, 0.9));
     var c = lighting(
         normal,
         in.pt_fragment,
         in.pt_camera,
         in.pt_light,
         light_color,
         albedo.rgb,
         roughness,
         metalness,
     );
 
     let ambient = vec3<f32>(0.03) * albedo;
     c += ambient;
 
     c = c / (c + 1.0);
     c = pow(c, vec3<f32>(1.0/2.2));
 
     let colors = array<vec3<f32>, 6>(
         vec3<f32>(1, 1, 0),
         vec3<f32>(0, 1, 1),
         vec3<f32>(1, 0, 1),
         vec3<f32>(1, 0, 0),
         vec3<f32>(0, 1, 0),
         vec3<f32>(0, 0, 1),
     );
     let color = colors[in.instance_id % 6];
 
     return vec4<f32>(color, 1.0);
 }