Adding ViroKit. Needs AWSCore :(

mobile/ios/ViroKit.framework/lighting_general_functions_fsh.glsl

@@ -0,0 +1,90 @@
+#extension GL_OES_EGL_image_external : enable
+#extension GL_OES_EGL_image_external_essl3 : enable
+
+#include surface_functions_fsh
+
+const highp float PI = 3.14159265359;
+
+// Grouped in 4N slots (int and float take 1N, vec3 takes 3N, vec4 takes 4N)
+struct VROLightUniforms {
+    int type;
+    highp float attenuation_start_distance;
+    highp float attenuation_end_distance;
+    highp float attenuation_falloff_exp;
+    
+    highp vec4 position;
+    highp vec4 direction;
+    
+    highp vec3 color;
+    highp float intensity;
+    
+    highp float spot_inner_angle;
+    highp float spot_outer_angle;
+    int shadow_map_index;
+    lowp float shadow_bias;
+    
+    lowp float shadow_opacity;
+    lowp float light_padding0, light_padding1, light_padding2;
+};
+
+layout (std140) uniform lighting_fragment {
+    int num_lights;
+    lowp float padding0, padding1, padding2;
+    
+    highp vec4 ambient_light_color;
+    VROLightUniforms lights[8];
+};
+
+struct VROLightingContribution {
+    highp vec3 ambient;
+    highp vec3 diffuse;
+    highp vec3 specular;
+    highp float visibility; // Fades light, e.g. due to shadows
+} _lightingContribution;
+
+highp float compute_angle_attenuation(highp vec3 L, highp vec3 light_direction,
+                                      highp float spot_inner, highp float spot_outer) {
+    highp float theta = dot(L, normalize(-light_direction));
+    highp float epsilon = max(0.0001, spot_inner - spot_outer);
+    return clamp((theta - spot_outer) / epsilon, 0.0, 1.0);
+}
+
+highp float compute_attenuation(const VROLightUniforms light,
+                                highp vec3 surface_pos,
+                                out highp vec3 surface_to_light) {
+    
+    highp float attenuation = 1.0;
+    
+    // Directional light
+    if (light.type == 1) {
+        surface_to_light = -normalize(light.direction.xyz);
+        attenuation = 1.0;
+    }
+    
+    // Omni + Spot lights
+    else {
+        surface_to_light = normalize(light.position.xyz - surface_pos);
+        highp float distance_to_light = length(light.position.xyz - surface_pos);
+        highp float d = clamp((distance_to_light - light.attenuation_start_distance) /
+                              (light.attenuation_end_distance - light.attenuation_start_distance),
+                               0.0, 1.0);
+        
+        attenuation = 1.0 - pow(d, 1.0 / light.attenuation_falloff_exp);
+        
+        // Spot light
+        if (light.type == 3) {
+            attenuation *= compute_angle_attenuation(surface_to_light, light.direction.xyz, light.spot_inner_angle, light.spot_outer_angle);
+        }
+    }
+    
+    return attenuation;
+}
+
+lowp vec4 compute_reflection(highp vec3 surface_position, highp vec3 camera_position, lowp vec3 normal,
+                             samplerCube reflect_sampler) {
+    
+    highp vec3 surface_to_camera = normalize(surface_position - camera_position);
+    highp vec3 reflect_ray = reflect(surface_to_camera, -normal);
+    
+    return texture(reflect_sampler, vec3(reflect_ray.xy, -reflect_ray.z));
+}