ris-framework 0.1.0 → 0.2.0-dev.12

package/shaders/glsl/forward_blinn_phong_material_fs.glsl

@@ -0,0 +1,110 @@
+#version 300 es
+precision mediump float;
+
+#define DIRECTIONAL_LIGHTS_COUNT ##DIRECTIONAL_LIGHTS_COUNT##
+#define POINT_LIGHTS_COUNT ##POINT_LIGHTS_COUNT##
+
+in vec4 v_color;
+in vec2 v_texCoords;
+in vec3 v_normal;
+in vec3 v_worldPosition;
+
+layout(location = 0) out vec4 o_outputColor;
+
+layout(std140) uniform MaterialBuffer
+{
+    vec3 u_ambientColor;
+    vec3 u_diffuseColor;
+    vec3 u_specularColor;
+    float u_shininess;
+};
+
+layout(std140) uniform CameraPositionBuffer
+{
+    vec3 u_cameraPosition;
+};
+
+struct DirectionalLight
+{
+    vec3 light;
+    vec3 direction;
+};
+
+struct PointLight
+{
+    vec3 light;
+    float constant;
+    vec3 position;
+    float linear;
+    float quadratic;
+};
+
+layout(std140) uniform LightsBuffer
+{
+    vec3 u_ambientLight;
+    DirectionalLight u_directionalLight[DIRECTIONAL_LIGHTS_COUNT];
+    PointLight u_pointLight[POINT_LIGHTS_COUNT];
+};
+
+uniform sampler2D u_texture;
+
+void main()
+{
+    vec3 normal = normalize(v_normal);
+
+    // Ambient lighting
+    vec3 ambient = u_ambientColor * u_ambientLight;
+
+    vec3 viewDirection = normalize(u_cameraPosition - v_worldPosition);
+
+    // Directional diffuse and Blinn-Phong specular lighting
+    vec3 diffuse = vec3(0.0);
+    vec3 specular = vec3(0.0);
+
+    for (int i = 0; i < DIRECTIONAL_LIGHTS_COUNT; ++i)
+    {
+        vec3 lightColor = u_directionalLight[i].light;
+        vec3 lightDirection = normalize(-u_directionalLight[i].direction);
+
+        float NdotL = max(dot(normal, lightDirection), 0.0);
+
+        diffuse += u_diffuseColor * lightColor * NdotL;
+
+        if (NdotL > 0.0)
+        {
+            vec3 halfway = normalize(lightDirection + viewDirection);
+            float NdotH = max(dot(normal, halfway), 0.0);
+            specular += u_specularColor * lightColor * pow(NdotH, u_shininess);
+        }
+    }
+
+    // Point lights: same diffuse and specular, scaled by distance attenuation.
+    for (int i = 0; i < POINT_LIGHTS_COUNT; ++i)
+    {
+        vec3 toLight = u_pointLight[i].position - v_worldPosition;
+        float lightDistance = length(toLight);
+        vec3 lightDirection = toLight / max(lightDistance, 0.0001);
+        float attenuation = 1.0 / (u_pointLight[i].constant
+            + u_pointLight[i].linear * lightDistance
+            + u_pointLight[i].quadratic * lightDistance * lightDistance);
+        vec3 lightColor = u_pointLight[i].light * attenuation;
+
+        float NdotL = max(dot(normal, lightDirection), 0.0);
+
+        diffuse += u_diffuseColor * lightColor * NdotL;
+
+        if (NdotL > 0.0)
+        {
+            vec3 halfway = normalize(lightDirection + viewDirection);
+            float NdotH = max(dot(normal, halfway), 0.0);
+            specular += u_specularColor * lightColor * pow(NdotH, u_shininess);
+        }
+    }
+
+    // Apply material lighting, texture, and vertex color
+    vec4 texel = texture(u_texture, v_texCoords) * v_color;
+    // Specular highlights are not tinted by the texture.
+    vec3 finalColor = texel.rgb * (ambient + diffuse) + specular;
+
+    o_outputColor = vec4(finalColor, texel.a);
+}

package/shaders/glsl/forward_blinn_phong_material_vs.glsl

@@ -0,0 +1,32 @@
+#version 300 es
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec4 a_color;
+layout(location = 2) in vec2 a_texCoord;
+layout(location = 3) in vec3 a_normal;
+
+out vec4 v_color;
+out vec2 v_texCoords;
+out vec3 v_normal;
+out vec3 v_worldPosition;
+
+layout(std140) uniform CameraBuffer
+{
+	mat4 projectionView;
+};
+
+layout(std140) uniform ModelBuffer
+{
+    mat4 model;
+};
+
+void main()
+{
+    vec4 worldPosition = model * vec4(a_position, 1.0);
+	gl_Position = projectionView * worldPosition;
+	v_color = a_color;
+	v_texCoords = a_texCoord;
+    // World-space normal through the normal matrix, correct for non-uniform mesh scale.
+    v_normal = transpose(inverse(mat3(model))) * a_normal;
+    v_worldPosition = worldPosition.xyz;
+}

package/shaders/glsl/main_render_target_flip_y_fs.glsl

@@ -2,8 +2,42 @@
 precision highp float;
 in vec2 v_texCoord;
 out vec4 outColor;
+
 uniform sampler2D u_texture;
+uniform int u_colorConversion;
+
+float linearToSrgb(float c)
+{
+    if (c <= 0.0)
+        return 0.0;
+
+    if (c < 0.0031308)
+        return 12.92 * c;
+
+    if (c < 1.0)
+        return 1.055 * pow(c, 1.0 / 2.4) - 0.055;
+
+    return 1.0;
+}
+
+// https://registry.khronos.org/OpenGL/specs/gl/glspec46.core.pdf
+// Chapter 17.3.7
+// Page 513
+vec3 linearToSrgb(vec3 c)
+{
+    return vec3(
+        linearToSrgb(c.r),
+        linearToSrgb(c.g),
+        linearToSrgb(c.b)
+    );
+}
+
 void main() 
 {
-    outColor = texture(u_texture, vec2(v_texCoord.x, 1.0 - v_texCoord.y));
+    vec4 color = texture(u_texture, vec2(v_texCoord.x, 1.0 - v_texCoord.y));
+    outColor.rgb = color.rgb;
+    if(u_colorConversion == 1) {
+        outColor.rgb = linearToSrgb(color.rgb);
+    }
+    outColor.a = color.a;
 }

package/shaders/glsl/sprite_fs.glsl

@@ -10,5 +10,5 @@ uniform sampler2D u_texture;
 
 void main()
 {
-    o_outputColor = texture(u_texture, v_texCoords) * v_color + vec4(1.0);
+    o_outputColor = texture(u_texture, v_texCoords) * v_color;
 }

package/shaders/glsl/unlit_material_fs.glsl

@@ -7,7 +7,7 @@ in vec2 v_texCoords;
 layout(location = 0) out vec4 o_outputColor;
 
 layout(std140) uniform MaterialBuffer
- {
+{
     vec4 diffuseColor;
 };
 

package/shaders/wgsl/forward_blinn_phong_material.wgsl

@@ -0,0 +1,150 @@
+// Forward Blinn-Phong material shader (WebGPU): ambient + directional + point lights, per fragment in world space.
+// Hand-maintained, mirrors slang/forward_blinn_phong_material.slang and glsl_300_es/forward_blinn_phong_material_*.glsl.
+//
+// The light counts must match LightsBuffer.DEFAULT_*_LIGHTS_COUNT (3 directional, 5 point lights;
+// Lights = 4 + 3 * 8 + 5 * 12 = 88 floats = 352 bytes). Every member is a 16 byte aligned vec4.
+// The counts are fixed here because the WebGPU pipeline does not pass a shader config.
+//
+// Bind groups (WebGPUForwardBlinnPhongRenderPipeline), WebGPU guarantees only 4 groups:
+//   group 0: binding 0 = projection view matrix, binding 1 = model matrix (vertex)
+//   group 1: binding 0 = diffuse texture, binding 1 = sampler (fragment)
+//   group 2: binding 2 = material (fragment)
+//   group 3: binding 3 = lights, binding 4 = camera position (fragment)
+
+const DIRECTIONAL_LIGHTS_COUNT : u32 = 3u;
+const POINT_LIGHTS_COUNT : u32 = 5u;
+
+// Material colors (MTL Ka, Kd, Ks) and the specular exponent (MTL Ns).
+struct BlinnPhongMaterial
+{
+    ambientColor : vec4<f32>,
+    diffuseColor : vec4<f32>,
+    specularColorShininess : vec4<f32>, // xyz specular color, w shininess
+};
+
+struct DirectionalLight
+{
+    light : vec4<f32>,     // xyz color * intensity
+    direction : vec4<f32>, // xyz direction in which the light travels
+};
+
+struct PointLight
+{
+    lightConstant : vec4<f32>,  // xyz color * intensity, w constant attenuation
+    positionLinear : vec4<f32>, // xyz world position, w linear attenuation
+    quadratic : vec4<f32>,      // x quadratic attenuation
+};
+
+struct Lights
+{
+    ambientLight : vec4<f32>, // xyz color * intensity
+    directionalLights : array<DirectionalLight, DIRECTIONAL_LIGHTS_COUNT>,
+    pointLights : array<PointLight, POINT_LIGHTS_COUNT>,
+};
+
+struct CameraPosition
+{
+    position : vec4<f32>, // xyz world-space eye
+};
+
+@group(0) @binding(0) var<uniform> projectionView : mat4x4<f32>;
+@group(0) @binding(1) var<uniform> model : mat4x4<f32>;
+
+@group(1) @binding(0) var diffuseTexture : texture_2d<f32>;
+@group(1) @binding(1) var diffuseSampler : sampler;
+
+@group(2) @binding(2) var<uniform> material : BlinnPhongMaterial;
+
+@group(3) @binding(3) var<uniform> lights : Lights;
+@group(3) @binding(4) var<uniform> cameraPosition : CameraPosition;
+
+struct VertexInput
+{
+    @location(0) position : vec3<f32>,
+    @location(1) color : vec4<f32>,
+    @location(2) texCoord : vec2<f32>,
+    @location(3) normal : vec3<f32>,
+};
+
+struct VertexOutput
+{
+    @builtin(position) position : vec4<f32>,
+    @location(0) color : vec4<f32>,
+    @location(1) texCoord : vec2<f32>,
+    @location(2) normal : vec3<f32>,
+    @location(3) worldPosition : vec3<f32>,
+};
+
+@vertex
+fn main_vs(input : VertexInput) -> VertexOutput
+{
+    var output : VertexOutput;
+    let worldPosition = model * vec4<f32>(input.position, 1.0);
+    output.position = projectionView * worldPosition;
+    output.color = input.color;
+    output.texCoord = input.texCoord;
+    output.worldPosition = worldPosition.xyz;
+
+    // World-space normal through the normal matrix (inverse transpose of the upper 3x3 of the model matrix),
+    // correct for non-uniform scale. For M = [a b c] (columns) the cofactor matrix is [b x c, c x a, a x b];
+    // it equals the inverse transpose times det(M). The length is removed in the fragment shader, only the sign matters.
+    let a = model[0].xyz;
+    let b = model[1].xyz;
+    let c = model[2].xyz;
+    let cofactor = mat3x3<f32>(cross(b, c), cross(c, a), cross(a, b));
+    let determinantSign = select(1.0, -1.0, dot(a, cross(b, c)) < 0.0);
+    output.normal = determinantSign * (cofactor * input.normal);
+    return output;
+}
+
+fn blinnPhong(normal : vec3<f32>, lightDirection : vec3<f32>, viewDirection : vec3<f32>, lightColor : vec3<f32>,
+    diffuse : ptr<function, vec3<f32>>, specular : ptr<function, vec3<f32>>)
+{
+    let NdotL = max(dot(normal, lightDirection), 0.0);
+    *diffuse += material.diffuseColor.xyz * lightColor * NdotL;
+
+    if (NdotL > 0.0)
+    {
+        let halfway = normalize(lightDirection + viewDirection);
+        let NdotH = max(dot(normal, halfway), 0.0);
+        *specular += material.specularColorShininess.xyz * lightColor * pow(NdotH, material.specularColorShininess.w);
+    }
+}
+
+@fragment
+fn main_fs(input : VertexOutput) -> @location(0) vec4<f32>
+{
+    let normal = normalize(input.normal);
+
+    // Ambient lighting.
+    let ambient = material.ambientColor.xyz * lights.ambientLight.xyz;
+
+    let viewDirection = normalize(cameraPosition.position.xyz - input.worldPosition);
+
+    // Diffuse and Blinn-Phong specular lighting.
+    var diffuse = vec3<f32>(0.0);
+    var specular = vec3<f32>(0.0);
+
+    for (var i = 0u; i < DIRECTIONAL_LIGHTS_COUNT; i++)
+    {
+        let light = lights.directionalLights[i];
+        blinnPhong(normal, normalize(-light.direction.xyz), viewDirection, light.light.xyz, &diffuse, &specular);
+    }
+
+    // Point lights: same diffuse and specular, scaled by distance attenuation.
+    for (var i = 0u; i < POINT_LIGHTS_COUNT; i++)
+    {
+        let light = lights.pointLights[i];
+        let toLight = light.positionLinear.xyz - input.worldPosition;
+        let lightDistance = length(toLight);
+        let lightDirection = toLight / max(lightDistance, 0.0001);
+        let attenuation = 1.0 / (light.lightConstant.w
+            + light.positionLinear.w * lightDistance
+            + light.quadratic.x * lightDistance * lightDistance);
+        blinnPhong(normal, lightDirection, viewDirection, light.lightConstant.xyz * attenuation, &diffuse, &specular);
+    }
+
+    // Apply material lighting, texture and vertex color. Specular highlights are not tinted by the texture.
+    let texel = textureSample(diffuseTexture, diffuseSampler, input.texCoord) * input.color;
+    return vec4<f32>(texel.rgb * (ambient + diffuse) + specular, texel.a);
+}

package/shaders/wgsl/inspect_texture_mips.wgsl

@@ -0,0 +1,51 @@
+// Inspect texture mips shader (WebGPU): draws a texture at an explicit mip level.
+// Hand-maintained, mirrors slang/inspect_texture_mips.slang and glsl_300_es/inspect_texture_mips_*.glsl.
+// Note: there is no WebGPU inspect pipeline yet; the layout follows the mesh pipelines.
+//
+// Bind groups:
+//   group 0: binding 0 = projection view matrix, binding 1 = model matrix (vertex)
+//   group 1: binding 0 = texture, binding 1 = sampler (fragment)
+//   group 2: binding 2 = texture constants (fragment)
+
+struct TextureConstants
+{
+    mipLevel : f32,
+};
+
+@group(0) @binding(0) var<uniform> projectionView : mat4x4<f32>;
+@group(0) @binding(1) var<uniform> model : mat4x4<f32>;
+
+@group(1) @binding(0) var diffuseTexture : texture_2d<f32>;
+@group(1) @binding(1) var diffuseSampler : sampler;
+
+@group(2) @binding(2) var<uniform> textureConstants : TextureConstants;
+
+struct VertexInput
+{
+    @location(0) position : vec3<f32>,
+    @location(1) color : vec4<f32>,
+    @location(2) texCoord : vec2<f32>,
+};
+
+struct VertexOutput
+{
+    @builtin(position) position : vec4<f32>,
+    @location(0) color : vec4<f32>,
+    @location(1) texCoord : vec2<f32>,
+};
+
+@vertex
+fn main_vs(input : VertexInput) -> VertexOutput
+{
+    var output : VertexOutput;
+    output.position = projectionView * model * vec4<f32>(input.position, 1.0);
+    output.color = input.color;
+    output.texCoord = input.texCoord;
+    return output;
+}
+
+@fragment
+fn main_fs(input : VertexOutput) -> @location(0) vec4<f32>
+{
+    return textureSampleLevel(diffuseTexture, diffuseSampler, input.texCoord, textureConstants.mipLevel) * input.color;
+}

package/shaders/wgsl/main_frame_buffer.wgsl

@@ -0,0 +1,35 @@
+// Draws the main render target texture to the screen. (WebGPU)
+// Hand-maintained, mirrors slang/main_frame_buffer.slang.
+//
+// Bind groups (WebGPUMainFrameBufferRenderPipeline):
+//   group 0: binding 0 = texture, binding 1 = sampler (fragment)
+
+@group(0) @binding(0) var diffuseTexture : texture_2d<f32>;
+@group(0) @binding(1) var diffuseSampler : sampler;
+
+struct VertexInput
+{
+    @location(0) position : vec3<f32>,
+    @location(1) texCoord : vec2<f32>,
+};
+
+struct VertexOutput
+{
+    @builtin(position) position : vec4<f32>,
+    @location(0) texCoord : vec2<f32>,
+};
+
+@vertex
+fn main_vs(input : VertexInput) -> VertexOutput
+{
+    var output : VertexOutput;
+    output.position = vec4<f32>(input.position, 1.0);
+    output.texCoord = input.texCoord;
+    return output;
+}
+
+@fragment
+fn main_fs(input : VertexOutput) -> @location(0) vec4<f32>
+{
+    return textureSample(diffuseTexture, diffuseSampler, input.texCoord);
+}

package/shaders/wgsl/main_render_target_flip_y.wgsl

@@ -0,0 +1,35 @@
+// Draws the main render target texture to the screen, flipped on Y. (WebGPU)
+// Hand-maintained, mirrors slang/main_render_target_flip_y.slang.
+//
+// Bind groups (WebGPUMainFrameBufferRenderPipeline):
+//   group 0: binding 0 = texture, binding 1 = sampler (fragment)
+
+@group(0) @binding(0) var diffuseTexture : texture_2d<f32>;
+@group(0) @binding(1) var diffuseSampler : sampler;
+
+struct VertexInput
+{
+    @location(0) position : vec3<f32>,
+    @location(1) texCoord : vec2<f32>,
+};
+
+struct VertexOutput
+{
+    @builtin(position) position : vec4<f32>,
+    @location(0) texCoord : vec2<f32>,
+};
+
+@vertex
+fn main_vs(input : VertexInput) -> VertexOutput
+{
+    var output : VertexOutput;
+    output.position = vec4<f32>(input.position, 1.0);
+    output.texCoord = input.texCoord;
+    return output;
+}
+
+@fragment
+fn main_fs(input : VertexOutput) -> @location(0) vec4<f32>
+{
+    return textureSample(diffuseTexture, diffuseSampler, vec2<f32>(input.texCoord.x, 1.0 - input.texCoord.y));
+}

package/shaders/wgsl/sprite.wgsl

@@ -0,0 +1,40 @@
+// Sprite batch shader (WebGPU). Hand-maintained, mirrors slang/sprite.slang and glsl_300_es/sprite_*.glsl.
+//
+// Bind groups (WebGPUSpriteRenderPipeline):
+//   group 0: binding 0 = projection view matrix (vertex)
+//   group 1: binding 0 = sprite texture, binding 1 = sampler (fragment)
+
+@group(0) @binding(0) var<uniform> projectionView : mat4x4<f32>;
+
+@group(1) @binding(0) var diffuseTexture : texture_2d<f32>;
+@group(1) @binding(1) var diffuseSampler : sampler;
+
+struct VertexInput
+{
+    @location(0) position : vec3<f32>,
+    @location(1) color : vec4<f32>,
+    @location(2) texCoord : vec2<f32>,
+};
+
+struct VertexOutput
+{
+    @builtin(position) position : vec4<f32>,
+    @location(0) color : vec4<f32>,
+    @location(1) texCoord : vec2<f32>,
+};
+
+@vertex
+fn main_vs(input : VertexInput) -> VertexOutput
+{
+    var output : VertexOutput;
+    output.position = projectionView * vec4<f32>(input.position, 1.0);
+    output.color = input.color;
+    output.texCoord = input.texCoord;
+    return output;
+}
+
+@fragment
+fn main_fs(input : VertexOutput) -> @location(0) vec4<f32>
+{
+    return textureSample(diffuseTexture, diffuseSampler, input.texCoord) * input.color;
+}

package/shaders/wgsl/unlit_material.wgsl

@@ -0,0 +1,49 @@
+// Unlit material shader (WebGPU). Hand-maintained, mirrors slang/unlit_material.slang and glsl_300_es/unlit_material_*.glsl.
+//
+// Bind groups (WebGPUUnlitRenderPipeline):
+//   group 0: binding 0 = projection view matrix, binding 1 = model matrix (vertex)
+//   group 1: binding 0 = diffuse texture, binding 1 = sampler (fragment)
+//   group 2: binding 2 = material (fragment)
+
+struct Material
+{
+    diffuseColor : vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> projectionView : mat4x4<f32>;
+@group(0) @binding(1) var<uniform> model : mat4x4<f32>;
+
+@group(1) @binding(0) var diffuseTexture : texture_2d<f32>;
+@group(1) @binding(1) var diffuseSampler : sampler;
+
+@group(2) @binding(2) var<uniform> material : Material;
+
+struct VertexInput
+{
+    @location(0) position : vec3<f32>,
+    @location(1) color : vec4<f32>,
+    @location(2) texCoord : vec2<f32>,
+};
+
+struct VertexOutput
+{
+    @builtin(position) position : vec4<f32>,
+    @location(0) color : vec4<f32>,
+    @location(1) texCoord : vec2<f32>,
+};
+
+@vertex
+fn main_vs(input : VertexInput) -> VertexOutput
+{
+    var output : VertexOutput;
+    output.position = projectionView * model * vec4<f32>(input.position, 1.0);
+    output.color = input.color;
+    output.texCoord = input.texCoord;
+    return output;
+}
+
+@fragment
+fn main_fs(input : VertexOutput) -> @location(0) vec4<f32>
+{
+    return textureSample(diffuseTexture, diffuseSampler, input.texCoord) * material.diffuseColor * input.color;
+}