chorama 0.0.0

package/src/shader/basicVertex.glsl

@@ -0,0 +1,87 @@
+precision mediump float;
+
+#include <common>
+
+uniform CameraBlock {
+  Camera camera;
+};
+
+uniform mat4 model;
+#ifdef SKINNED
+  uniform sampler2D bone_transforms;
+#endif
+
+in vec3 position;
+in vec2 uv;
+in vec3 normal;
+#ifdef VERTEX_TANGENTS
+  in vec3 tangent;
+#endif
+#ifdef SKINNED
+  in uvec4 joint_index;
+  in vec4 joint_weight;
+#endif
+
+out vec3 v_position;
+#ifdef VERTEX_UVS
+  out vec2 v_uv;
+#endif
+#ifdef VERTEX_NORMALS
+  out vec3 v_normal;
+#endif
+#ifdef VERTEX_TANGENTS
+  out vec3 v_tangent;
+#endif
+out vec3 cam_direction;
+
+void main(){
+  #ifdef SKINNED
+    mat4 boneMat0 = get_value_from_texture(joint_index.x, bone_transforms);
+    mat4 boneMat1 = get_value_from_texture(joint_index.y, bone_transforms);
+    mat4 boneMat2 = get_value_from_texture(joint_index.z, bone_transforms);
+    mat4 boneMat3 = get_value_from_texture(joint_index.w, bone_transforms);
+
+    vec4 skeleton_space_position = vec4(position, 1.0);
+    vec4 skinned_position =
+      (boneMat0 * skeleton_space_position) * joint_weight.x +
+      (boneMat1 * skeleton_space_position) * joint_weight.y +
+      (boneMat2 * skeleton_space_position) * joint_weight.z +
+      (boneMat3 * skeleton_space_position) * joint_weight.w;
+    mat3 normal_matrix = mat3(model);
+    vec3 world_space_position = (model * skinned_position).xyz;
+  #else
+    vec3 world_space_position = (model * vec4(position,1.0)).xyz;
+    mat3 normal_matrix = mat3(model);
+  #endif
+  
+  v_position = world_space_position;
+  #ifdef VERTEX_UVS
+    v_uv = uv;
+  #endif
+  #ifdef VERTEX_NORMALS
+    #ifdef SKINNED
+      vec3 skeleton_space_normal =
+        (mat3(boneMat0) * normal) * joint_weight.x +
+        (mat3(boneMat1) * normal) * joint_weight.y +
+        (mat3(boneMat2) * normal) * joint_weight.z +
+        (mat3(boneMat3) * normal) * joint_weight.w;
+      v_normal = normal_matrix * skeleton_space_normal;
+    #else
+      v_normal = normal_matrix * normal;
+    #endif
+  #endif
+  #ifdef VERTEX_TANGENTS
+    #ifdef SKINNED
+      vec3 skeleton_space_tangent =
+        (mat3(boneMat0) * tangent) * joint_weight.x +
+        (mat3(boneMat1) * tangent) * joint_weight.y +
+        (mat3(boneMat2) * tangent) * joint_weight.z +
+        (mat3(boneMat3) * tangent) * joint_weight.w;
+      v_tangent = normal_matrix * skeleton_space_tangent;
+    #else
+      v_tangent = normal_matrix * tangent;
+    #endif
+  #endif
+  cam_direction = camera.cam_position - world_space_position;
+  gl_Position = camera.projection * camera.view * vec4(world_space_position, 1.0);
+}

package/src/shader/common/color.glsl

@@ -0,0 +1,7 @@
+vec3 quick_sRGB_to_linear(vec3 color) {
+  return pow(color, vec3(2.2));
+}
+
+vec3 quick_linear_to_sRGB(vec3 color) {
+  return pow(color, 1.0 / vec3(2.2));
+}

package/src/shader/common/common.glsl

@@ -0,0 +1,25 @@
+struct Camera {
+  mat4 view;
+  mat4 projection;
+  vec3 cam_position;
+  float near;
+  float far;
+};
+
+// functions
+vec3 tint(vec3 tex_color, vec3 tint_color){
+  return tex_color * tint_color;
+}
+
+mat4 get_value_from_texture(uint index, sampler2D transforms) {
+  uint size = uint(textureSize( transforms, 0 ).x);
+  uint stride = index * uint(4);
+  uint x = stride % size;
+  uint y = stride / size;
+  vec4 column1 = texelFetch( transforms, ivec2( x, y ), 0 );
+  vec4 column2 = texelFetch( transforms, ivec2( x + uint(1), y ), 0 );
+  vec4 column3 = texelFetch( transforms, ivec2( x + uint(2), y ), 0 );
+  vec4 column4 = texelFetch( transforms, ivec2( x + uint(3), y ), 0 );
+
+  return mat4( column1, column2, column3, column4 );
+}

package/src/shader/common/index.js

@@ -0,0 +1,4 @@
+export { default as colorShaderLib } from './color.glsl'
+export { default as commonShaderLib } from './common.glsl'
+export { default as lightShaderLib } from './light.glsl'
+export { default as mathShaderLib } from './math.glsl'

package/src/shader/common/light.glsl

@@ -0,0 +1,437 @@
+struct DirectionalLight {
+  vec4 color;
+  vec3 direction;
+  float intensity;
+  int shadow_index;
+};
+
+struct AmbientLight {
+  float intensity;
+  vec4 color;
+};
+
+struct PointLight {
+  vec4 color;
+  vec3 position;
+  float intensity;
+  float radius;
+  float decay;
+  int shadow_index;
+};
+
+struct SpotLight {
+  vec4 color;
+  vec3 position;
+  int shadow_index;
+  vec3 direction;
+  float intensity;
+  float distance;
+  float decay;
+  float innerAngle;
+  float outerAngle;
+};
+
+struct Shadow {
+  mat4 space;
+  float bias;
+  float normal_bias;
+  float layer;
+  uint mode;
+  float pcf_radius;
+  float pcss_search_radius;
+  float pcss_penumbra;
+  float _padding2;
+};
+
+struct DirectionalLights {
+  int count;
+  DirectionalLight lights[MAX_DIRECTIONAL_LIGHTS];
+};
+
+struct PointLights {
+  int count;
+  PointLight lights[MAX_POINT_LIGHTS];
+};
+
+struct SpotLights {
+  int count;
+  SpotLight lights[MAX_SPOT_LIGHTS];
+};
+
+float calculate_brightness(vec3 normal, vec3 dir) {
+  return max(dot(normal, dir), 0.0);
+}
+
+// https://lisyarus.github.io/blog/posts/point-light-attenuation.html
+float attenuate_light_distance(float distance, float max_distance, float falloff){
+  float s = distance / max_distance;
+
+  if (s >= 1.0){
+    return 0.0;
+  }
+
+  float s2 = sq(s);
+  return sq(1.0 - s2) / (1.0 + falloff * s2);
+}
+
+float attenuate_point_light(float distance, float radius, float max_intensity, float falloff){
+  float s = distance / radius;
+
+  if (s >= 1.0){
+    return 0.0;
+  }
+
+  float s2 = sq(s);
+  return max_intensity * sq(1.0 - s2) / (1.0 + falloff * s2);
+}
+
+float attenuate_spot_light(SpotLight light, vec3 direction, float distance){
+  float factor = max(dot(light.direction, -direction), 0.0);
+  
+  if(factor > light.outerAngle){
+  float cone_attenuation = smoothstep(light.outerAngle, light.innerAngle, factor);
+  float distance_attenuation = attenuate_light_distance(distance, light.distance, light.decay);
+    return cone_attenuation * distance_attenuation * light.intensity;
+  }
+  return 0.0;
+}
+
+vec3 map_cube_from_array_texture_ndc(vec3 direction) {
+  vec3 absolute_direction = abs(direction);
+
+  if (absolute_direction.x >= absolute_direction.y && absolute_direction.x >= absolute_direction.z) {
+    float face = direction.x > 0.0 ? 0.0 : 1.0;
+    float inv = 1.0 / absolute_direction.x;
+    vec2 uv = vec2(
+      direction.x > 0.0 ? -direction.z : direction.z,
+      -direction.y
+    );
+    
+    return vec3(uv * inv, face);
+  } else if (absolute_direction.y >= absolute_direction.x && absolute_direction.y >= absolute_direction.z) {
+    float face = direction.y > 0.0 ? 2.0 : 3.0;
+    float inv = 1.0 / absolute_direction.y;
+    vec2 uv = vec2(
+      direction.x,
+      direction.y > 0.0 ? direction.z : -direction.z
+    );
+
+    return vec3(uv * inv, face);
+  }
+  
+  float face = direction.z > 0.0 ? 4.0 : 5.0;
+  float inv = 1.0 / absolute_direction.z;
+  vec2 uv = vec2(
+    direction.z > 0.0 ? direction.x : -direction.x,
+    -direction.y
+  );
+    
+  return vec3(uv * inv, face);
+}
+
+vec3 map_cube_to_array_texture_direction(float face, vec2 uv) {
+  if (face == 0.0) {
+    return normalize(vec3(1.0, -uv.y, -uv.x));
+  }
+
+  if (face == 1.0) {
+    return normalize(vec3(-1.0, -uv.y, uv.x));
+  }
+
+  if (face == 2.0) {
+    return normalize(vec3(uv.x, 1.0, uv.y));
+  }
+
+  if (face == 3.0) {
+    return normalize(vec3(uv.x, -1.0, -uv.y));
+  }
+
+  if (face == 4.0) {
+    return normalize(vec3(uv.x, -uv.y, 1.0));
+  }
+
+  return normalize(vec3(-uv.x, -uv.y, -1.0));
+}
+
+float shadow_compare_2d(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 shadow_map_postion,
+  float current_depth,
+  float bias
+){
+  float shadow_map_depth = texture(
+    shadow_atlas,
+    vec3(shadow_map_postion.xy, shadow.layer)
+  ).r;
+
+  return current_depth - bias > shadow_map_depth ? 0.0 : 1.0;
+}
+
+float shadow_compare_cube(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 direction,
+  float current_depth,
+  float bias
+){
+  vec3 ndc_uv = map_cube_from_array_texture_ndc(direction);
+  vec2 shadow_uv = ndc_uv.xy * 0.5 + 0.5;
+  float shadow_map_depth = texture(
+    shadow_atlas,
+    vec3(shadow_uv.xy, shadow.layer + ndc_uv.z)
+  ).r;
+  vec2 clip_planes = shadow.space[0].xy;
+  float near = clip_planes.x;
+  float far = clip_planes.y;
+  vec3 norm_direction = normalize(direction);
+  float scale = max(abs(norm_direction.x), max(abs(norm_direction.y), abs(norm_direction.z)));
+  float view_space_map_depth = linearize_depth(shadow_map_depth, near, far);
+  float map_depth = view_space_map_depth / (scale * far);
+
+  return current_depth - bias > map_depth ? 0.0 : 1.0;
+}
+
+float shadow_pcf_2d_radius(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 shadow_map_postion,
+  float current_depth,
+  float radius,
+  float bias
+){
+  vec2 texel_size = 1.0 / vec2(textureSize(shadow_atlas, 0).xy);
+  vec2 pcf_step = texel_size * radius;
+  float shadow_sum = 0.0;
+
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 sample_offset = vec2(float(x), float(y)) * pcf_step;
+      vec3 sample_position = vec3(shadow_map_postion.xy + sample_offset, shadow_map_postion.z);
+      shadow_sum += shadow_compare_2d(shadow, shadow_atlas, sample_position, current_depth, bias);
+    }
+  }
+
+  return shadow_sum / 9.0;
+}
+
+float shadow_pcf_2d(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 shadow_map_postion,
+  float current_depth,
+  float bias
+){
+  return shadow_pcf_2d_radius(
+    shadow,
+    shadow_atlas,
+    shadow_map_postion,
+    current_depth,
+    shadow.pcf_radius,
+    bias
+  );
+}
+
+float shadow_pcf_cube_radius(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 direction,
+  float current_depth,
+  float radius,
+  float bias
+){
+  vec3 ndc_uv = map_cube_from_array_texture_ndc(direction);
+  vec2 texel_size = 1.0 / vec2(textureSize(shadow_atlas, 0).xy);
+  vec2 pcf_step = texel_size * radius;
+  float shadow_sum = 0.0;
+
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 sample_offset = vec2(float(x), float(y)) * pcf_step;
+      vec2 sample_uv = ndc_uv.xy + sample_offset;
+      vec3 sample_direction = map_cube_to_array_texture_direction(ndc_uv.z, sample_uv);
+      shadow_sum += shadow_compare_cube(shadow, shadow_atlas, sample_direction, current_depth, bias);
+    }
+  }
+
+  return shadow_sum / 9.0;
+}
+
+float shadow_pcf_cube(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 direction,
+  float current_depth,
+  float bias
+){
+  return shadow_pcf_cube_radius(
+    shadow,
+    shadow_atlas,
+    direction,
+    current_depth,
+    shadow.pcf_radius,
+    bias
+  );
+}
+
+float shadow_pcss_2d(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 shadow_map_postion,
+  float current_depth,
+  float bias
+){
+  vec2 texel_size = 1.0 / vec2(textureSize(shadow_atlas, 0).xy);
+  vec2 search_step = texel_size * shadow.pcss_search_radius;
+  float blocker_sum = 0.0;
+  float blocker_count = 0.0;
+
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 sample_offset = vec2(float(x), float(y)) * search_step;
+      float sample_depth = texture(
+        shadow_atlas,
+        vec3(shadow_map_postion.xy + sample_offset, shadow.layer)
+      ).r;
+      if (sample_depth < current_depth - bias) {
+        blocker_sum += sample_depth;
+        blocker_count += 1.0;
+      }
+    }
+  }
+
+  if (blocker_count == 0.0) {
+    return 1.0;
+  }
+
+  float blocker_depth = blocker_sum / blocker_count;
+  float penumbra = (current_depth - blocker_depth) / max(blocker_depth, 0.0001);
+  float filter_radius = clamp(
+    shadow.pcf_radius + penumbra * shadow.pcss_penumbra,
+    shadow.pcf_radius,
+    shadow.pcf_radius + 12.0
+  );
+  return shadow_pcf_2d_radius(
+    shadow,
+    shadow_atlas,
+    shadow_map_postion,
+    current_depth,
+    filter_radius,
+    bias
+  );
+}
+
+float shadow_pcss_cube(
+  Shadow shadow,
+  sampler2DArray shadow_atlas,
+  vec3 direction,
+  float current_depth,
+  float bias
+){
+  vec3 ndc_uv = map_cube_from_array_texture_ndc(direction);
+  vec2 texel_size = 1.0 / vec2(textureSize(shadow_atlas, 0).xy);
+  vec2 search_step = texel_size * shadow.pcss_search_radius;
+  vec2 clip_planes = shadow.space[0].xy;
+  float near = clip_planes.x;
+  float far = clip_planes.y;
+  float blocker_sum = 0.0;
+  float blocker_count = 0.0;
+
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 sample_offset = vec2(float(x), float(y)) * search_step;
+      vec2 sample_uv = ndc_uv.xy + sample_offset;
+      vec3 sample_direction = map_cube_to_array_texture_direction(ndc_uv.z, sample_uv);
+      vec3 sample_ndc = map_cube_from_array_texture_ndc(sample_direction);
+      vec2 sample_shadow_uv = sample_ndc.xy * 0.5 + 0.5;
+      float shadow_map_depth = texture(
+        shadow_atlas,
+        vec3(sample_shadow_uv.xy, shadow.layer + sample_ndc.z)
+      ).r;
+      vec3 norm_direction = normalize(sample_direction);
+      float scale = max(abs(norm_direction.x), max(abs(norm_direction.y), abs(norm_direction.z)));
+      float view_space_map_depth = linearize_depth(shadow_map_depth, near, far);
+      float map_depth = view_space_map_depth / (scale * far);
+      if (map_depth < current_depth - bias) {
+        blocker_sum += map_depth;
+        blocker_count += 1.0;
+      }
+    }
+  }
+
+  if (blocker_count == 0.0) {
+    return 1.0;
+  }
+
+  float blocker_depth = blocker_sum / blocker_count;
+  float penumbra = (current_depth - blocker_depth) / max(blocker_depth, 0.0001);
+  float filter_radius = clamp(
+    shadow.pcf_radius + penumbra * shadow.pcss_penumbra,
+    shadow.pcf_radius,
+    shadow.pcf_radius + 12.0
+  );
+  return shadow_pcf_cube_radius(
+    shadow,
+    shadow_atlas,
+    direction,
+    current_depth,
+    filter_radius,
+    bias
+  );
+}
+
+float shadow_contribution_2d(Shadow shadow, sampler2DArray shadow_atlas, vec3 position, float NdotL){
+  vec4 clipped_position = shadow.space * vec4(position, 1.0);
+  vec3 ndc_position = clipped_position.xyz / clipped_position.w;
+  vec3 shadow_map_postion = ndc_position * 0.5 + 0.5;
+
+  if(
+    shadow_map_postion.x < 0.0 || shadow_map_postion.x > 1.0 ||
+    shadow_map_postion.y < 0.0 || shadow_map_postion.y > 1.0
+  ){
+    return 1.0;
+  }
+  float current_depth = shadow_map_postion.z;
+  float normal_bias = shadow.normal_bias * (1.0 - NdotL);
+  float bias = shadow.bias + normal_bias;
+
+  if (shadow.mode == 0u) {
+    return shadow_compare_2d(shadow, shadow_atlas, shadow_map_postion, current_depth, bias);
+  }
+  if (shadow.mode == 1u) {
+    return shadow_pcf_2d(shadow, shadow_atlas, shadow_map_postion, current_depth, bias);
+  }
+  if (shadow.mode == 2u) {
+    return shadow_pcss_2d(shadow, shadow_atlas, shadow_map_postion, current_depth, bias);
+  }
+  return shadow_pcf_2d(shadow, shadow_atlas, shadow_map_postion, current_depth, bias);
+}
+
+float shadow_contribution_cube(Shadow shadow, sampler2DArray shadow_atlas, vec3 position, float NdotL){
+  // the clipping planes are encoded in the first column of the space matrix
+  vec2 clip_planes = shadow.space[0].xy;
+  vec3 light_position = shadow.space[3].xyz;
+  vec3 direction = position - light_position;
+  float distance = length(direction);
+  vec3 norm_distance = direction / distance;
+  float near = clip_planes.x;
+  float far = clip_planes.y;
+  float current_depth = distance / far;
+  
+  vec3 ndc_uv = map_cube_from_array_texture_ndc(direction);
+  vec2 shadow_uv = ndc_uv.xy * 0.5 + 0.5;
+  
+  float normal_bias = shadow.normal_bias * (1.0 - NdotL);
+  float bias = shadow.bias + normal_bias;
+
+  if (shadow.mode == 0u) {
+    return shadow_compare_cube(shadow, shadow_atlas, direction, current_depth, bias);
+  }
+  if (shadow.mode == 1u) {
+    return shadow_pcf_cube(shadow, shadow_atlas, direction, current_depth, bias);
+  }
+  if (shadow.mode == 2u) {
+    return shadow_pcss_cube(shadow, shadow_atlas, direction, current_depth, bias);
+  }
+  return shadow_pcf_cube(shadow, shadow_atlas, direction, current_depth, bias);
+}

package/src/shader/common/math.glsl

@@ -0,0 +1,12 @@
+const float PI = 3.14159265359;
+
+// functions
+float sq(float x) {
+  return x * x;
+}
+
+// https://learnopengl.com/Advanced-OpenGL/Depth-testing
+float linearize_depth(float depth, float near, float far){
+  float ndc = depth * 2.0 - 1.0;
+  return (2.0 * near * far) / (far + near - ndc * (far - near));
+}

package/src/shader/debug/index.js

@@ -0,0 +1,2 @@
+export { default as skeletonVertex } from './skeletonVertex.glsl'
+export { default as skeletonFragment } from './skeletonFragment.glsl'

package/src/shader/debug/skeletonFragment.glsl

@@ -0,0 +1,8 @@
+precision mediump float;
+
+in vec3 color;
+out vec4 fragment_color;
+
+void main() {
+  fragment_color = vec4(color, 1.0);
+}

package/src/shader/debug/skeletonVertex.glsl

@@ -0,0 +1,27 @@
+precision mediump float;
+
+#include <common>
+
+uniform CameraBlock {
+Camera camera;
+};
+uniform sampler2D transforms;
+uniform mat4 model;
+uniform uint parent_index;
+uniform uint child_index;
+
+out vec3 color;
+
+void main() {
+  mat4 parent_matrix = get_value_from_texture(parent_index, transforms);
+  mat4 child_matrix  = get_value_from_texture(child_index, transforms);
+
+  vec3 parent_position = parent_matrix[3].xyz;
+  vec3 child_position  = child_matrix[3].xyz;
+
+  // Each bone line is made of two vertices.
+  vec3 world_position = (gl_VertexID % 2 == 0) ? parent_position : child_position;
+
+  color = (gl_VertexID % 2 == 0) ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+  gl_Position = camera.projection * camera.view * model * vec4(world_position, 1.0);
+}

package/src/shader/depthFragment.glsl

@@ -0,0 +1,37 @@
+precision mediump float;
+precision mediump sampler2DArray;
+
+#include <math>
+#include <common>
+
+struct CameraParams {
+  float near;
+  float far;
+};
+
+#ifdef VERTEX_UVS
+  in vec2 v_uv;
+#endif
+
+uniform MaterialBlock {
+  CameraParams params;
+};
+uniform sampler2D depth_texture;
+
+out vec4 fragment_color;
+
+void main(){
+  #ifdef VERTEX_UVS
+    float sample_depth = texture(depth_texture, v_uv).r / 1.0;
+    float linear_depth = linearize_depth(sample_depth, params.near, params.far) / params.far;
+    float visual_depth = (sample_depth - params.near) / (params.far - params.near); 
+    fragment_color = vec4(
+      linear_depth,
+      linear_depth,
+      linear_depth,
+      1.0
+    );
+  #else
+    fragment_color = vec4(1.0, 0.0, 0.0, 1.0);
+  #endif
+}

package/src/shader/index.js

@@ -0,0 +1,11 @@
+export * from './common/index.js'
+export * from './debug/index.js'
+export { default as basicVertex } from './basicVertex.glsl'
+export { default as basicFragment } from './basicFragment.glsl'
+export { default as normalFragment } from './normalFragment.glsl'
+export { default as lambertFragment } from './lambertFragment.glsl'
+export { default as phongFragment } from './phongFragment.glsl'
+export { default as standardFragment } from './standardFragment.glsl'
+export { default as skyboxVertex } from './skyboxVertex.glsl'
+export { default as skyboxFragment } from './skyboxFragment.glsl'
+export { default as depthFragment } from './depthFragment.glsl'