chorama 0.0.0

package/src/shader/lambertFragment.glsl

@@ -0,0 +1,126 @@
+precision mediump float;
+precision mediump sampler2DArray;
+
+#include <math>
+#include <common>
+#include <light>
+
+struct LambertMaterial {
+  vec4 color;
+};
+
+in vec3 v_position;
+#ifdef VERTEX_UVS
+  in vec2 v_uv;
+#endif
+#ifdef VERTEX_NORMALS
+  in vec3 v_normal;
+#endif
+
+uniform MaterialBlock {
+  LambertMaterial material;
+};
+// Lights
+uniform AmbientLightBlock {
+  AmbientLight ambient_light;
+};
+uniform DirectionalLightBlock {
+  DirectionalLights directional_lights;
+};
+uniform PointLightBlock {
+  PointLights point_lights;
+};
+uniform SpotLightBlock {
+  SpotLights spot_lights;
+};
+
+#ifdef MAX_SHADOW_CASTERS
+  uniform ShadowCasterBlock {
+    Shadow shadow_casters[MAX_SHADOW_CASTERS];
+  };
+  uniform sampler2DArray shadow_atlas;
+#endif
+uniform sampler2D mainTexture;
+out vec4 fragment_color;
+
+void main(){
+  vec3 base_color =  material.color.rgb;
+  
+  #ifdef VERTEX_UVS
+    vec4 sample_color = texture(mainTexture,v_uv);
+    base_color *= sample_color.rgb;
+  #endif
+  #ifdef VERTEX_NORMALS
+    vec3 normal = normalize(v_normal);
+  #else
+    #error "Mesh vertex normals are required for lighting."
+  #endif
+  float opacity = material.color.a;
+  int directional_light_count = min(directional_lights.count,MAX_DIRECTIONAL_LIGHTS);
+  int point_light_count = min(point_lights.count,MAX_POINT_LIGHTS);
+  int spot_light_count = min(spot_lights.count,MAX_SPOT_LIGHTS);
+
+  vec3 ambient = ambient_light.color.rgb * ambient_light.intensity;
+  
+  vec3 total_exitance = vec3(0.0, 0.0, 0.0);
+  for (int i = 0; i < directional_light_count; i++) {
+    DirectionalLight light = directional_lights.lights[i];
+    //Remember you set the dir to negative because direction to light is the opposite direction of dir.
+    vec3 light_direction = -light.direction;
+    float brightness = calculate_brightness(normal, light_direction);
+    vec3 irradiance = light.color.rgb * brightness * light.intensity;
+    
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_2d(shadow, shadow_atlas, v_position, brightness);
+      }
+    #endif
+    total_exitance += base_color * irradiance;
+  }
+  
+  for (int i = 0; i < point_light_count; i++) {
+    PointLight light = point_lights.lights[i];
+    vec3 distance_vector = light.position - v_position;
+    float distance = length(distance_vector);
+    vec3 direction = distance_vector / distance;
+    float attenuation = attenuate_point_light(distance, light.radius, light.intensity, light.decay);
+    float brightness = calculate_brightness(normal, direction);
+    vec3 irradiance = light.color.rgb * attenuation;
+
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_cube(shadow, shadow_atlas, v_position, brightness);
+      }
+    #endif
+
+    total_exitance += base_color * brightness * irradiance;
+  }
+
+  for (int i = 0; i < spot_light_count; i++) {
+    SpotLight light = spot_lights.lights[i];
+    vec3 distance_vector = light.position - v_position;
+    float distance = length(distance_vector);
+    vec3 direction = distance_vector / distance;
+    float attenuation = attenuate_spot_light(light, direction, distance);
+    float brightness = calculate_brightness(normal, direction);
+    vec3 irradiance = light.color.rgb * attenuation;
+   
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_2d(shadow, shadow_atlas, v_position, brightness);
+      }
+    #endif
+    
+    total_exitance += base_color * brightness * irradiance;
+  }
+  
+  vec3 final_color = ambient * base_color + total_exitance;
+  
+  fragment_color = vec4(final_color,opacity);
+}

package/src/shader/normalFragment.glsl

@@ -0,0 +1,25 @@
+precision mediump float;
+precision mediump sampler2DArray;
+
+#include <common>
+
+struct NormalMaterial {
+  vec4 padding;
+};
+
+in vec3 v_normal;
+
+out vec4 fragment_color;
+
+uniform MaterialBlock {
+  NormalMaterial material;
+};
+
+void main(){
+  #ifdef VERTEX_NORMALS
+    vec3 normal = normalize(v_normal);
+  #else
+    #error "Mesh vertex normals are required for lighting."
+  #endif
+  fragment_color = vec4(normal, 1.0);
+}

package/src/shader/phongFragment.glsl

@@ -0,0 +1,140 @@
+precision mediump float;
+precision mediump sampler2DArray;
+
+#include <common>
+#include <math>
+#include <light>
+
+struct PhongMaterial {
+  vec4 color;
+  float specularShininess;
+  float specularStrength;
+};
+
+in vec3 v_position;
+#ifdef VERTEX_UVS
+  in vec2 v_uv;
+#endif
+in vec3 v_normal;
+in vec3 cam_direction;
+
+uniform MaterialBlock {
+  PhongMaterial material;
+};
+uniform AmbientLightBlock {
+  AmbientLight ambient_light;
+};
+uniform DirectionalLightBlock {
+  DirectionalLights directional_lights;
+};
+uniform PointLightBlock {
+  PointLights point_lights;
+};
+uniform SpotLightBlock {
+  SpotLights spot_lights;
+};
+#ifdef MAX_SHADOW_CASTERS
+  uniform ShadowCasterBlock {
+    Shadow shadow_casters[MAX_SHADOW_CASTERS];
+  };
+  uniform sampler2DArray shadow_atlas;
+#endif
+uniform sampler2D mainTexture;
+
+out vec4 fragment_color;
+ 
+void main(){
+  vec3 base_color = material.color.rgb;
+  #ifdef VERTEX_UVS
+    vec4 sample_color = texture(mainTexture,v_uv);
+    base_color *= sample_color.rgb;
+  #endif
+  #ifdef VERTEX_NORMALS
+    vec3 normal = normalize(v_normal);
+  #else
+    #error "Mesh vertex normals are required for lighting."
+  #endif
+  vec3 view_direction = normalize(cam_direction);
+  float opacity = material.color.a;
+  int directional_light_count = min(directional_lights.count,MAX_DIRECTIONAL_LIGHTS);
+  int point_light_count = min(point_lights.count,MAX_POINT_LIGHTS);
+  int spot_light_count = min(spot_lights.count,MAX_SPOT_LIGHTS);
+  
+  vec3 total_exitance = vec3(0.0);
+  for (int i = 0; i < directional_light_count; i++) {
+    DirectionalLight light = directional_lights.lights[i];
+    vec3 reflection_direction = reflect(light.direction, normal);
+    vec3 irradiance = light.color.rgb;
+    //Remember you set the dir to negative because light direction is the opposite direction of dir.
+    float diffuse_brightness = calculate_brightness(normal,-light.direction);    
+    
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_2d(shadow, shadow_atlas, v_position, diffuse_brightness);
+      }
+    #endif
+    
+    vec3 diffuse = base_color * irradiance * diffuse_brightness * light.intensity;
+  
+    float specular_brightness = calculate_brightness(reflection_direction,view_direction);
+    vec3 specular = pow(specular_brightness,material.specularShininess) * irradiance * material.specularStrength;
+
+    total_exitance += specular + diffuse;
+  }
+  for (int i = 0; i < point_light_count; i++) {
+    PointLight light = point_lights.lights[i];
+    vec3 distance_vector = light.position - v_position;
+    float distance = length(distance_vector);
+    vec3 direction = distance_vector / distance;
+    float attenuation = attenuate_point_light(distance, light.radius, light.intensity, light.decay);
+    float brightness = calculate_brightness(normal, direction);
+    vec3 irradiance = light.color.rgb * attenuation;
+
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_cube(shadow, shadow_atlas, v_position, brightness);
+      }
+    #endif
+
+    vec3 reflection_direction = reflect(direction, normal);
+    vec3 diffuse_exitance = base_color * brightness * irradiance;
+    
+    float specular_brightness = calculate_brightness(reflection_direction, -view_direction);
+    vec3 specular_exitance = pow(specular_brightness,material.specularShininess) * irradiance * material.specularStrength;
+    total_exitance += specular_exitance + diffuse_exitance;
+  }
+
+  for (int i = 0; i < spot_light_count; i++) {
+    SpotLight light = spot_lights.lights[i];
+    vec3 distance_vector = light.position - v_position;
+    float distance = length(distance_vector);
+    vec3 direction = distance_vector / distance;
+    float attenuation = attenuate_spot_light(light, direction, distance);
+    float brightness = calculate_brightness(normal, direction);
+    vec3 irradiance = light.color.rgb * attenuation;
+    
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_2d(shadow, shadow_atlas, v_position, brightness);
+      }
+    #endif
+
+    vec3 reflection_direction = reflect(direction, normal);
+    vec3 diffuse_exitance = base_color * brightness * irradiance;
+    float specular_brightness = calculate_brightness(reflection_direction, -view_direction);
+    vec3 specular_exitance = pow(specular_brightness,material.specularShininess) * irradiance * material.specularStrength;
+
+    total_exitance += specular_exitance + diffuse_exitance;
+  }
+  
+  vec3 ambient = base_color * ambient_light.color.rgb * ambient_light.intensity;
+  vec3 final_color = ambient + total_exitance;
+  
+  fragment_color = vec4(final_color, opacity);
+}

package/src/shader/skyboxFragment.glsl

@@ -0,0 +1,16 @@
+precision mediump float;
+precision mediump sampler2DArray;
+
+#include <common>
+
+in highp vec3 v_uv;
+
+uniform float lerp;
+uniform samplerCube day;
+uniform samplerCube night;
+
+out vec4 fragment_color;
+
+void main(){
+  fragment_color = mix(texture(day, v_uv), texture(night,v_uv), lerp);
+}

package/src/shader/skyboxVertex.glsl

@@ -0,0 +1,20 @@
+precision mediump float;
+
+#include <common>
+
+in vec3 position;
+
+uniform CameraBlock {
+  Camera camera;
+};
+uniform mat4 model;
+
+out highp vec3 v_uv;
+  
+void main(){
+  mat4 view = camera.view;
+  view[3].xyz = vec3(0.0);
+  v_uv = position;
+  gl_Position = camera.projection * view * model * vec4(position.xyz, 1.0);
+  gl_Position = gl_Position.xyww;
+}

package/src/shader/standardFragment.glsl

@@ -0,0 +1,274 @@
+precision mediump float;
+precision mediump sampler2DArray;
+
+#include <math>
+#include <color>
+#include <common>
+#include <light>
+
+struct PBRInput {
+  float NdotL;
+  float NdotV;
+  float NdotH;
+  float HdotV;
+};
+
+struct PBRProperties {
+  vec3 normal;
+  vec3 albedo;
+  vec3 emissive;
+  float opacity;
+  float metallic;
+  float roughness; 
+  float ambient_occlusion;
+};
+
+struct StandardMaterial {
+  vec4 color;
+  float metallic;
+  float roughness;
+  float ambient_occlusion_strength;
+  vec3 emissive_color;
+  float emissive_intensity;
+};
+
+in vec3 v_position;
+#ifdef VERTEX_UVS
+  in vec2 v_uv;
+#endif
+#ifdef VERTEX_NORMALS
+  in vec3 v_normal;
+#endif
+#ifdef VERTEX_TANGENTS
+  in vec3 v_tangent;
+#endif
+in vec3 cam_direction;
+
+uniform MaterialBlock {
+  StandardMaterial material;
+};
+uniform AmbientLightBlock {
+  AmbientLight ambient_light;
+};
+uniform DirectionalLightBlock {
+  DirectionalLights directional_lights;
+};
+uniform PointLightBlock {
+  PointLights point_lights;
+};
+uniform SpotLightBlock {
+  SpotLights spot_lights;
+};
+#ifdef MAX_SHADOW_CASTERS
+  uniform ShadowCasterBlock {
+    Shadow shadow_casters[MAX_SHADOW_CASTERS];
+  };
+  uniform sampler2DArray shadow_atlas;
+#endif
+uniform sampler2D mainTexture;
+uniform sampler2D normal_texture;
+uniform sampler2D occlusion_texture;
+uniform sampler2D roughness_texture;
+uniform sampler2D metallic_texture;
+uniform sampler2D emissive_texture;
+
+out vec4 fragment_color;
+
+vec3 fresnel_schlick(float HdotV, vec3 F0){
+  return F0 + (1.0 - F0) * pow(clamp(1.0 - HdotV, 0.0, 1.0), 5.0);
+}
+
+// Also the Trowbridge-Rietz normal distribution function
+float GGX_normal_distribution(float NdotH, float roughness){
+  float a = roughness * roughness;
+  float a2 = a * a;
+  float NdotH2 = NdotH * NdotH;  
+  float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+  denom = PI * denom * denom;
+
+  return a2 / denom;
+}
+
+float geometry_schlickGGX(float NdotV, float roughness){
+  float r = (roughness + 1.0);
+  float k = (r * r) / 8.0;
+  float denom = NdotV * (1.0 - k) + k;
+
+  return NdotV / denom;
+}
+
+float geometry_smith(float NdotV, float NdotL, float roughness){
+  float ggx2 = geometry_schlickGGX(NdotV, roughness);
+  float ggx1 = geometry_schlickGGX(NdotL, roughness);
+
+  return ggx1 * ggx2;
+}
+
+vec3 cook_torrance_BRDF(PBRProperties pbr_properties, PBRInput pbr_input){
+  vec3 F0 = mix(vec3(0.04), pbr_properties.albedo, pbr_properties.metallic);
+  vec3 F = fresnel_schlick(pbr_input.HdotV, F0);
+
+  float NDF = GGX_normal_distribution(pbr_input.NdotH, pbr_properties.roughness);
+  float G = geometry_smith(pbr_input.NdotV, pbr_input.NdotL, pbr_properties.roughness);
+
+  vec3 numerator = NDF * G * F;
+  float denominator = 4.0 * pbr_input.NdotV * pbr_input.NdotL  + 0.0001;
+  vec3 specular = numerator / denominator;
+  vec3 kS = F;
+  vec3 kD = (vec3(1.0) - kS) * (1.0 - pbr_properties.metallic);
+
+  return (kD * pbr_properties.albedo / PI + specular);
+}
+
+PBRInput calculate_pbr_input(vec3 N, vec3 V, vec3 L, vec3 H){
+  PBRInput pbr_input;
+
+  pbr_input.NdotV = max(dot(N, V), 0.0);
+  pbr_input.NdotL = max(dot(N, L), 0.0);
+  pbr_input.NdotH = max(dot(N, H), 0.0);
+  pbr_input.HdotV = max(dot(H, V), 0.0);
+
+  return pbr_input;
+}
+
+PBRProperties calculate_pbr_properties(){
+  PBRProperties properties;
+
+  properties.albedo = material.color.rgb;
+  properties.emissive = material.emissive_color;
+  properties.opacity = material.color.a;
+  properties.metallic = material.metallic;
+  properties.roughness = material.roughness;
+  properties.ambient_occlusion = 1.0;
+
+  #ifdef VERTEX_UVS
+    vec4 albedo_texture_color = texture(mainTexture,v_uv);
+    properties.albedo *= quick_sRGB_to_linear(albedo_texture_color.rgb);
+    properties.opacity *= albedo_texture_color.a;
+
+    vec4 metallic_texture_color = texture(metallic_texture,v_uv);
+    properties.metallic *= metallic_texture_color.b;
+    
+    vec4 roughness_texture_color = texture(roughness_texture,v_uv);
+    properties.roughness *= roughness_texture_color.g;
+    
+    vec4 occlusion_texture_color = texture(occlusion_texture,v_uv);
+    properties.ambient_occlusion = mix(1.0,occlusion_texture_color.r, material.ambient_occlusion_strength);
+    
+    vec4 emissive_texture_color = texture(emissive_texture,v_uv);
+    properties.emissive *= emissive_texture_color.rgb;  
+  #endif
+
+  properties.metallic = clamp(properties.metallic, 0.0, 1.0);
+  properties.roughness = clamp(properties.roughness, 0.05, 1.0);
+
+  #if defined(VERTEX_TANGENTS)
+    #ifdef VERTEX_NORMALS
+      vec3 normal = normalize(v_normal);
+    #else
+      #error "Mesh vertex normals are required for lighting."
+    #endif
+    #ifdef VERTEX_UVS
+      vec3 tangent = normalize(v_tangent);
+      vec3 bitangent = cross(normal, tangent);
+      mat3 tangent_space = mat3(tangent, bitangent, normal);
+      vec3 surface_normal = texture(normal_texture, v_uv).rgb * 2.0 - 1.0;
+      properties.normal = tangent_space * surface_normal;
+    #else
+      properties.normal = normal;
+    #endif
+  #else
+    #ifdef VERTEX_NORMALS
+      properties.normal = v_normal;
+    #else
+      #error "Mesh vertex normals are required for lighting."
+    #endif
+  #endif
+
+  return properties;
+}
+
+void main(){
+  PBRProperties pbr_properties = calculate_pbr_properties();
+  vec3 N = pbr_properties.normal;
+  vec3 V = normalize(cam_direction);
+  int directional_light_count = min(directional_lights.count,MAX_DIRECTIONAL_LIGHTS);
+  int point_light_count = min(point_lights.count, MAX_POINT_LIGHTS);
+  int spot_light_count = min(spot_lights.count,MAX_SPOT_LIGHTS);
+
+  vec3 exitance = vec3(0.0);
+  for (int i = 0; i < directional_light_count; i++) {
+    DirectionalLight light = directional_lights.lights[i];
+    vec3 L = -light.direction;
+    vec3 H = normalize(L + V);
+    PBRInput pbr_input = calculate_pbr_input(N, V, L, H);
+    vec3 irradiance = light.color.rgb * light.intensity;
+
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_2d(shadow, shadow_atlas, v_position, pbr_input.NdotL);
+      }
+    #endif      
+    exitance += cook_torrance_BRDF(pbr_properties, pbr_input) * irradiance * pbr_input.NdotL;
+  }
+
+  for (int i = 0; i < point_light_count; i++) {
+    PointLight light = point_lights.lights[i];
+    vec3 normal = N;
+    vec3 distance_vector = light.position - v_position;
+    float distance = length(distance_vector);
+    vec3 L = distance_vector / distance;
+    vec3 H = normalize(L + V);
+    PBRInput pbr_input = calculate_pbr_input(N, V, L, H);
+    float attenuation = attenuate_point_light(distance, light.radius, light.intensity, light.decay);
+    vec3 irradiance = light.color.rgb * attenuation;
+    
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_cube(shadow, shadow_atlas, v_position, pbr_input.NdotL);
+      }
+    #endif
+
+    exitance += cook_torrance_BRDF(pbr_properties, pbr_input) * irradiance * pbr_input.NdotL;
+  }
+
+  for (int i = 0; i < spot_light_count; i++) {
+    SpotLight light = spot_lights.lights[i];
+    vec3 normal = N;
+    vec3 distance_vector = light.position - v_position;
+    float distance = length(distance_vector);
+    vec3 L = distance_vector / distance;
+    vec3 H = normalize(L + V);
+    PBRInput pbr_input = calculate_pbr_input(N, V, L, H);
+    float attenuation = attenuate_spot_light(light, L, distance);
+    vec3 irradiance = light.color.rgb * attenuation;
+    
+    #ifdef MAX_SHADOW_CASTERS
+      if(light.shadow_index != -1){
+        Shadow shadow = shadow_casters[light.shadow_index];
+        
+        irradiance *= shadow_contribution_2d(shadow, shadow_atlas, v_position, pbr_input.NdotL);
+      }
+    #endif
+
+    exitance += cook_torrance_BRDF(pbr_properties, pbr_input) * irradiance * pbr_input.NdotL;
+  }
+
+  vec3 emissive_exitance = pbr_properties.emissive * material.emissive_intensity;
+  vec3 ambient_exitance = pbr_properties.albedo * ambient_light.color.rgb * ambient_light.intensity * pbr_properties.ambient_occlusion;
+  vec3 final_color = emissive_exitance + ambient_exitance + exitance;
+
+  // tonemapping output
+  // this is temporary until a post processing step is introduced
+  final_color = final_color / (final_color + vec3(1.0));
+
+  // gamma correction
+  // this is temporary until a post processing step is introduced
+  final_color = quick_linear_to_sRGB(final_color); 
+
+  fragment_color = vec4(final_color, pbr_properties.opacity);
+}

package/src/texture/index.js

@@ -0,0 +1,2 @@
+export * from "./texture.js"
+export * from "./sampler.js"