lighting, blinn-phong

src/shaders/light.wgsl

@@ -0,0 +1,43 @@
+// Vertex shader
+
+struct Camera {
+    view: mat4x4<f32>,
+    proj: mat4x4<f32>,
+    position: vec4<f32>,
+}
+@group(0) @binding(0)
+var<uniform> camera: Camera;
+
+struct Light {
+    position: vec3<f32>,
+    color: vec3<f32>,
+}
+@group(1) @binding(0)
+var<uniform> light: Light;
+
+struct VertexInput {
+    @location(0) position: vec3<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) color: vec3<f32>,
+};
+
+@vertex
+fn vs_main(
+    model: VertexInput,
+) -> VertexOutput {
+    let scale = 0.25;
+    var out: VertexOutput;
+    out.clip_position = camera.proj * camera.view * vec4<f32>(model.position * scale + light.position, 1.0);
+    out.color = light.color;
+    return out;
+}
+
+// Fragment shader
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return vec4<f32>(in.color, 1.0);
+}

src/shaders/test.wgsl

@@ -3,24 +3,36 @@ struct InstanceInput {
     @location(6) model_matrix_1: vec4<f32>,
     @location(7) model_matrix_2: vec4<f32>,
     @location(8) model_matrix_3: vec4<f32>,
-};
+}
 
 // Vertex shader
 
 struct CameraUniform {
-    view_proj: mat4x4<f32>,
-};
+    view: mat4x4<f32>,
+    proj: mat4x4<f32>,
+    position: vec4<f32>,
+}
 @group(1) @binding(0)
 var<uniform> camera: CameraUniform;
 
+struct Light {
+    position: vec3<f32>,
+    color: vec3<f32>,
+}
+@group(2) @binding(0)
+var<uniform> light: Light;
+
 struct VertexInput {
     @location(0) position: vec3<f32>,
     @location(1) tex_coords: vec2<f32>,
+    @location(2) normal: vec3<f32>,
 }
 
 struct VertexOutput {
     @builtin(position) clip_position: vec4<f32>,
     @location(0) tex_coords: vec2<f32>,
+    @location(1) world_normal: vec3<f32>,
+    @location(2) world_position: vec3<f32>,
 }
 
 @vertex
@@ -34,11 +46,20 @@ fn vs_main(
         instance.model_matrix_2,
         instance.model_matrix_3,
     );
+
     var out: VertexOutput;
+
     out.tex_coords = model.tex_coords;
-    out.clip_position = camera.view_proj * model_matrix * vec4<f32>(model.position, 1.0);
+
+    out.world_normal = normalize((model_matrix * vec4<f32>(model.normal, 0.0)).xyz);
+
+    var world_position: vec4<f32> = model_matrix * vec4<f32>(model.position, 1.0);
+    out.world_position = world_position.xyz;
+    
+    out.clip_position = camera.proj * camera.view * world_position;
+
     return out;
-} 
+}
 
 // Fragment shader
 
@@ -49,5 +70,25 @@ var s_diffuse: sampler;
 
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    return textureSample(t_diffuse, s_diffuse, in.tex_coords);
+    let object_color: vec4<f32> = textureSample(t_diffuse, s_diffuse, in.tex_coords);
+    
+    let light_dir = normalize(light.position - in.world_position);
+
+    // ambient
+    let ambient_strength = 0.05;
+    let ambient_color = light.color * ambient_strength;
+
+    // diffuse
+    let diffuse_strength = max(dot(in.world_normal, light_dir), 0.0);
+    let diffuse_color = light.color * diffuse_strength;
+
+    // specular
+    let view_dir = normalize(camera.position.xyz - in.world_position);
+    let half_dir = normalize(view_dir + light_dir);
+    let specular_strength = pow(max(dot(in.world_normal, half_dir), 0.0), 32.0);
+    let specular_color = specular_strength * light.color;
+
+    let result = (ambient_color + diffuse_color + specular_color) * object_color.xyz;
+
+    return vec4<f32>(result, object_color.a);
 }