@reactvision/react-viro 2.43.0 → 2.43.1

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/ddlaser.obj

@@ -0,0 +1,48 @@
+# This file uses centimeters as units for non-parametric coordinates.
+
+mtllib ddlaser.mtl
+g default
+v 0.000000 -0.052070 -0.514142
+v -0.010000 -0.042411 -0.516730
+v -0.000000 -0.032752 -0.519318
+v 0.010000 -0.042411 -0.516730
+v 0.000000 -1.785092 -6.981866
+v -0.010000 -1.775433 -6.984455
+v -0.000000 -1.765774 -6.987043
+v 0.010000 -1.775433 -6.984455
+v 0.000000 -0.042411 -0.516730
+vt 0.851912 0.937630
+vt 0.831888 0.957654
+vt 0.851912 0.977679
+vt 0.871937 0.957654
+vt 0.204060 0.007101
+vt 0.352030 0.007101
+vt 0.500000 0.007101
+vt 0.647970 0.007101
+vt 0.795940 0.007101
+vt 0.204060 0.988412
+vt 0.352030 0.988412
+vt 0.500000 0.988412
+vt 0.647970 0.988412
+vt 0.795940 0.988412
+vt 0.851912 0.956853
+vn 0.000000 -0.965829 0.259180
+vn -1.000000 0.000098 0.000360
+vn -1.000000 0.000004 -0.000001
+vn 0.000000 -0.965926 0.258819
+vn 0.000000 0.966022 -0.258458
+vn 0.000000 0.965926 -0.258819
+vn 1.000000 0.000098 0.000360
+vn 1.000000 0.000004 -0.000001
+vn 0.000000 0.258818 0.965926
+s 1
+g pCylinder1
+usemtl lambert2SG
+f 1/5/1 2/6/2 6/11/3 5/10/4
+f 2/6/2 3/7/5 7/12/6 6/11/3
+f 3/7/5 4/8/7 8/13/8 7/12/6
+f 4/8/7 1/9/1 5/14/4 8/13/8
+f 2/2/2 1/1/1 9/15/9
+f 3/3/5 2/2/2 9/15/9
+f 4/4/7 3/3/5 9/15/9
+f 1/1/1 4/4/7 9/15/9

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/equirect_to_cube_fsh.glsl

@@ -0,0 +1,20 @@
+#version 300 es
+
+in highp vec3 v_world_position;
+out highp vec4 frag_color;
+uniform sampler2D equirectangular_map;
+
+const highp vec2 inv_atan = vec2(0.1591, 0.3183);
+
+highp vec2 sample_spherical_map(highp vec3 v) {
+    highp vec2 uv = vec2(atan(v.z, v.x), asin(v.y));
+    uv *= inv_atan;
+    uv += 0.5;
+    return uv;
+}
+
+void main() {
+    highp vec2 uv = sample_spherical_map(normalize(v_world_position));
+    highp vec3 color = texture(equirectangular_map, uv).rgb;
+    frag_color = vec4(color, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/equirect_to_cube_vsh.glsl

@@ -0,0 +1,12 @@
+#version 300 es
+
+in vec3 position;
+out vec3 v_world_position;
+
+uniform mat4 projection_matrix;
+uniform mat4 view_matrix;
+
+void main() {
+    v_world_position = position;
+	gl_Position = projection_matrix * view_matrix * vec4(position, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/image_fsh.glsl

@@ -0,0 +1,12 @@
+#version 300 es
+
+in highp vec2 v_texcoord;
+out highp vec4 frag_color;
+
+#pragma image_modifier_uniforms
+
+void main() {
+    
+#pragma image_modifier_body
+
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/image_vsh.glsl

@@ -0,0 +1,11 @@
+#version 300 es
+
+in vec2 position;
+in vec2 texcoord;
+
+out vec2 v_texcoord;
+
+void main() {
+    v_texcoord = texcoord;
+	gl_Position = vec4(position.xy, 0.0, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/irradiance_convolution_fsh.glsl

@@ -0,0 +1,34 @@
+#version 300 es
+
+in highp vec3 v_world_position;
+out highp vec4 frag_color;
+uniform samplerCube environment_map;
+
+const highp float PI = 3.14159265359;
+
+void main() {
+    highp vec3 N = normalize(v_world_position);
+    highp vec3 irradiance = vec3(0.0);
+    
+    highp vec3 up    = vec3(0.0, 1.0, 0.0);
+    highp vec3 right = cross(up, N);
+    up               = cross(N, right);
+    
+    // This value controls how much we sample the cubemap for convolution.
+    // Using 0.025 is too low, causes GPU hang errors on iOS
+    highp float sample_delta = 0.05;
+    highp float sample_count = 0.0f;
+    
+    for (highp float phi = 0.0; phi < 2.0 * PI; phi += sample_delta) {
+        for (highp float theta = 0.0; theta < 0.5 * PI; theta += sample_delta) {
+            highp vec3 tangent_sample = vec3(sin(theta) * cos(phi),  sin(theta) * sin(phi), cos(theta));
+            highp vec3 sample_vec = tangent_sample.x * right + tangent_sample.y * up + tangent_sample.z * N;
+            
+            irradiance += texture(environment_map, sample_vec).rgb * cos(theta) * sin(theta);
+            sample_count++;
+        }
+    }
+    
+    irradiance = PI * irradiance * (1.0 / sample_count);
+    frag_color = vec4(irradiance, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/irradiance_convolution_vsh.glsl

@@ -0,0 +1,12 @@
+#version 300 es
+
+in vec3 position;
+out vec3 v_world_position;
+
+uniform mat4 projection_matrix;
+uniform mat4 view_matrix;
+
+void main() {
+    v_world_position = position;
+	gl_Position = projection_matrix * view_matrix * vec4(position, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/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));
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/particles_fsh.glsl

@@ -0,0 +1,4 @@
+// Grouped in 4N slots, should match VROParticlesUBOFragmentData structure defined in VROParticleUBO.h
+layout(std140) uniform particles_fragment_data{
+   mediump vec4 particles_fragment_color[180];
+};

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/particles_vsh.glsl

@@ -0,0 +1,4 @@
+// Grouped in 4N slots, should match VROParticlesUBOVertexData structure defined in VROParticleUBO.h
+layout(std140) uniform particles_vertex_data{
+   mat4 particles_vertex_transform[180];
+};

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/pbr_fsh.glsl

@@ -0,0 +1,123 @@
+/*
+ Implementation for the Cook-Torrance specular BRDF. Consists of a Distribution function, a
+ Fresnel equation, and a Geometry function.
+ */
+
+/*
+ Fresnel equation: describes the ratio of surface reflection at different surface angles.
+ */
+highp vec3 fresnel_schlick(highp float cosTheta, highp vec3 F0) {
+    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+highp vec3 fresnel_schlick_roughness(highp float cosTheta, highp vec3 F0, highp float roughness) {
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+/*
+ Trowbridge-Reitz GGX normal distribution function: approximates the amount the surface's
+ microfacets are aligned to the halfway vector influenced by the roughness of the surface.
+ Primary function approximating microfacets.
+ */
+highp float distribution_ggx(highp vec3 N, highp vec3 H, highp float roughness) {
+    highp float a      = roughness * roughness;
+    highp float a2     = a * a;
+    highp float NdotH  = max(dot(N, H), 0.0);
+    highp float NdotH2 = NdotH * NdotH;
+    
+    highp float nom   = a2;
+    highp float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+    
+    return nom / denom;
+}
+
+/*
+ Schlick GGX geometry function: describes the self-shadowing property of the microfacets. When
+ a surface is relatively rough the surface's microfacets can overshadow other microfacets, reducing
+ the light the surface reflects.
+ */
+highp float geometry_schlick_ggx(highp float NdotV, highp float roughness) {
+    highp float r = (roughness + 1.0);
+    highp float k = (r * r) / 8.0;
+    highp float nom   = NdotV;
+    highp float denom = NdotV * (1.0 - k) + k;
+    
+    return nom / denom;
+}
+
+/*
+ Smith method combines the obstruction from the view direction with the shadowing from the light
+ direction vector. Each is computed with Schlick and combined through Smith.
+ */
+highp float geometry_smith(highp vec3 N, highp vec3 V, highp vec3 L, highp float roughness) {
+    highp float NdotV = max(dot(N, V), 0.0);
+    highp float NdotL = max(dot(N, L), 0.0);
+    highp float ggx2  = geometry_schlick_ggx(NdotV, roughness);
+    highp float ggx1  = geometry_schlick_ggx(NdotL, roughness);
+    
+    return ggx1 * ggx2;
+}
+
+highp float smooth_distance_attenuation(highp float squared_distance, highp float inv_squared_attenuation_radius) {
+    highp float factor = squared_distance * inv_squared_attenuation_radius;
+    highp float smooth_factor = clamp(1.0f - factor * factor, 0.0, 1.0);
+    return smooth_factor * smooth_factor;
+}
+
+highp float compute_distance_attenuation(highp vec3 unnormalized_light_vector, highp float inv_squared_attenuation_radius) {
+    highp float squared_distance = dot(unnormalized_light_vector, unnormalized_light_vector);
+    highp float attenuation = 1.0 / (max(squared_distance, 0.01 * 0.01));
+    attenuation *= smooth_distance_attenuation(squared_distance, inv_squared_attenuation_radius);
+    
+    return attenuation;
+}
+
+highp float compute_attenuation_pbr(const VROLightUniforms light, highp vec3 surface_pos,
+                                    out highp vec3 L) {
+    
+    highp float attenuation = 1.0;
+    
+    // Directional light
+    if (light.type == 1) {
+        L = -normalize(light.direction.xyz);
+        
+        // For directional light luminous intensity is simply a scalar (as if we're
+        // using Lambert)
+        highp float luminous_intensity = light.intensity / (1000.0);
+        attenuation = luminous_intensity;
+    }
+    
+    // Omni Light
+    else if (light.type == 2) {
+        highp vec3 unnormalized_light_vector = light.position.xyz - surface_pos;
+        L = normalize(unnormalized_light_vector);
+        
+        // Intensity is integrated over the solid angle to get power (luminous flux)
+        // For a point light this simplifies to I = phi / (4.0 * PI). We use PI
+        // becuase we don't want spotlight intensity to differ from omni intensity
+        highp float luminous_intensity = light.intensity / PI;
+
+        highp float inverse_square_attenuation_radius = 1.0 / (light.attenuation_end_distance * light.attenuation_end_distance);
+        attenuation *= compute_distance_attenuation(unnormalized_light_vector, inverse_square_attenuation_radius);
+        attenuation *= luminous_intensity;
+    }
+    
+    // Spotlight
+    else if (light.type == 3) {
+        highp vec3 unnormalized_light_vector = light.position.xyz - surface_pos;
+        L = normalize(unnormalized_light_vector);
+        
+        // For a spotlight we use a simple equation for intensity since we don't want
+        // intensity to be stronger for smaller cones given the same power (luminous flux)
+        highp float luminous_intensity = light.intensity / PI;
+        
+        highp float inverse_square_attenuation_radius = 1.0 / (light.attenuation_end_distance * light.attenuation_end_distance);
+        attenuation *= compute_distance_attenuation(unnormalized_light_vector, inverse_square_attenuation_radius);
+        attenuation *= compute_angle_attenuation(L, light.direction.xyz, light.spot_inner_angle, light.spot_outer_angle);
+        attenuation *= luminous_intensity;
+    }
+    
+    return attenuation;
+}
+

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/prefilter_convolution_fsh.glsl

@@ -0,0 +1,106 @@
+#version 300 es
+
+in highp vec3 v_world_position;
+out highp vec4 frag_color;
+uniform samplerCube environment_map;
+uniform highp float material_roughness;
+
+const highp float PI = 3.14159265359;
+
+highp float distribution_ggx(highp vec3 N, highp vec3 H, highp float roughness) {
+    highp float a = roughness*roughness;
+    highp float a2 = a*a;
+    highp float nDotH = max(dot(N, H), 0.0);
+    highp float nDotH2 = nDotH*nDotH;
+
+    highp float nom   = a2;
+    highp float denom = (nDotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+
+    return nom / denom;
+}
+
+highp float vanDerCorpus(uint n, uint base) {
+    highp float invBase = 1.0 / float(base);
+    highp float denom   = 1.0;
+    highp float result  = 0.0;
+
+    for(uint i = 0u; i < 32u; ++i) {
+        if(n > 0u) {
+            denom   = mod(float(n), 2.0);
+            result += denom * invBase;
+            invBase = invBase / 2.0;
+            n       = uint(float(n) / 2.0);
+        }
+    }
+
+    return result;
+}
+
+highp vec2 hammersley_no_bitOps(uint i, uint N) {
+    return vec2(float(i)/float(N), vanDerCorpus(i, 2u));
+}
+
+highp vec3 importance_sample_ggx(highp vec2 Xi, highp vec3 N, highp float roughness) {
+    highp float a = roughness*roughness;
+
+    highp float phi = 2.0 * PI * Xi.x;
+    highp float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a*a - 1.0) * Xi.y));
+    highp float sinTheta = sqrt(1.0 - cosTheta*cosTheta);
+
+    // from spherical coordinates to cartesian coordinates - halfway vector
+    highp vec3 H;
+    H.x = cos(phi) * sinTheta;
+    H.y = sin(phi) * sinTheta;
+    H.z = cosTheta;
+
+    // from tangent-space H vector to world-space sample vector
+    highp vec3 up        = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
+    highp vec3 tangent   = normalize(cross(up, N));
+    highp vec3 bitangent = cross(N, tangent);
+
+    highp vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z;
+    return normalize(sampleVec);
+}
+
+void main() {
+    highp vec3 N = normalize(v_world_position);
+
+    // make the simplyfying assumption that V equals R equals the normal
+    highp vec3 R = N;
+    highp vec3 V = R;
+
+    const uint SAMPLE_COUNT = 256u;
+    highp vec3 prefilteredColor = vec3(0.0);
+    highp float totalWeight = 0.0;
+
+    for(uint i = 0u; i < SAMPLE_COUNT; ++i)
+    {
+        // generates a sample vector that's biased towards the preferred alignment direction (importance sampling).
+        highp vec2 Xi = hammersley_no_bitOps(i, SAMPLE_COUNT);
+        highp vec3 H  = importance_sample_ggx(Xi, N, material_roughness);
+        highp vec3 L  = normalize(2.0 * dot(V, H) * H - V);
+
+        highp float NdotL = max(dot(N, L), 0.0);
+        if(NdotL > 0.0)
+        {
+            // sample from the environment's mip level based on roughness/pdf
+            highp float D     = distribution_ggx(N, H, material_roughness);
+            highp float nDotH = max(dot(N, H), 0.0);
+            highp float hdotV = max(dot(H, V), 0.0);
+            highp float pdf   = D * nDotH / (4.0 * hdotV) + 0.0001;
+
+            highp float resolution = 512.0; // resolution of source cubemap (per face)
+            highp float saTexel  = 4.0 * PI / (6.0 * resolution * resolution);
+            highp float saSample = 1.0 / (float(SAMPLE_COUNT) * pdf + 0.0001);
+
+            highp float mipLevel = material_roughness == 0.0 ? 0.0 : 0.5 * log2(saSample / saTexel);
+
+            prefilteredColor += textureLod(environment_map, L, mipLevel).rgb * NdotL;
+            totalWeight      += NdotL;
+        }
+    }
+
+    prefilteredColor = prefilteredColor / totalWeight;
+    frag_color = vec4(prefilteredColor, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/prefilter_convolution_vsh.glsl

@@ -0,0 +1,11 @@
+#version 300 es
+in vec3 position;
+out vec3 v_world_position;
+
+uniform mat4 projection_matrix;
+uniform mat4 view_matrix;
+
+void main() {
+    v_world_position = position;
+    gl_Position = projection_matrix * view_matrix * vec4(position, 1.0);
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/skinning_vsh.glsl

@@ -0,0 +1,56 @@
+layout (std140) uniform bones {
+    mat4 bone_matrices[192];
+};
+
+layout (std140) uniform bones_dq {
+    vec4 bone_transforms_dq[192 * 3];
+};
+
+vec4 get_blended_scale(ivec4 bone_indices, vec4 bone_weights) {
+    vec4 s0 = bone_transforms_dq[bone_indices.x * 3 + 2];
+    vec4 s1 = bone_transforms_dq[bone_indices.y * 3 + 2];
+    vec4 s2 = bone_transforms_dq[bone_indices.z * 3 + 2];
+    vec4 s3 = bone_transforms_dq[bone_indices.w * 3 + 2];
+    
+    vec4 blended_s = s0 * bone_weights.x +
+                     s1 * bone_weights.y +
+                     s2 * bone_weights.z +
+                     s3 * bone_weights.w;
+    return blended_s;
+}
+
+mat2x4 get_bone_dual_quaternion(int bone_index) {
+    return mat2x4(bone_transforms_dq[bone_index * 3 + 0],
+                  bone_transforms_dq[bone_index * 3 + 1]);
+}
+
+mat2x4 get_blended_dual_quaternion(ivec4 bone_indices, vec4 bone_weights) {
+    mat2x4 dq0 = get_bone_dual_quaternion(bone_indices.x);
+    mat2x4 dq1 = get_bone_dual_quaternion(bone_indices.y);
+    mat2x4 dq2 = get_bone_dual_quaternion(bone_indices.z);
+    mat2x4 dq3 = get_bone_dual_quaternion(bone_indices.w);
+    
+    if (dot(dq0[0], dq1[0]) < 0.0) bone_weights.y *= -1.0;
+    if (dot(dq0[0], dq2[0]) < 0.0) bone_weights.z *= -1.0;
+    if (dot(dq0[0], dq3[0]) < 0.0) bone_weights.w *= -1.0;
+    
+    mat2x4 blended_dq = dq0 * bone_weights.x +
+                        dq1 * bone_weights.y +
+                        dq2 * bone_weights.z +
+                        dq3 * bone_weights.w;
+    
+    float norm = length(blended_dq[0]);
+    return blended_dq / norm;
+}
+
+vec3 quat_rotate_vector(vec3 v, vec4 real_dq) {
+    return v + 2.0 * cross(real_dq.w * v + cross(v, real_dq.xyz), real_dq.xyz);
+}
+
+vec3 dual_quat_transform_point(vec3 p, vec4 real_dq, vec4 dual_dq) {
+    // Reconstruct translation from the dual quaternion
+    vec3 t = 2.0 * (real_dq.w * dual_dq.xyz - dual_dq.w * real_dq.xyz + cross(real_dq.xyz, dual_dq.xyz));
+
+    // Combine with rotation of the input point
+    return quat_rotate_vector(p, real_dq) + t;
+}

package/android/viro_renderer/build/.transforms/3e36c7c1d5e76d6c106d5ac66bbdf042/transformed/jetified-viro_renderer-release/assets/standard_fsh.glsl

@@ -0,0 +1,73 @@
+#version 300 es
+#include lighting_general_functions_fsh
+#include pbr_fsh
+
+uniform highp vec3 camera_position;
+uniform highp vec4 material_diffuse_surface_color;
+uniform highp float material_diffuse_intensity;
+uniform lowp float material_alpha;
+uniform lowp float material_shininess;
+uniform highp float material_roughness;
+uniform highp float material_roughness_intensity;
+uniform highp float material_metalness;
+uniform highp float material_metalness_intensity;
+uniform highp float material_ao;
+
+#pragma surface_modifier_uniforms
+#pragma fragment_modifier_uniforms
+#pragma lighting_model_modifier_uniforms
+
+in lowp mat3 v_tbn;
+in highp vec2 v_texcoord;
+in highp vec3 v_surface_position;
+
+layout (location = 0) out highp vec4 frag_color;
+
+void main() {
+    _surface.diffuse_color = material_diffuse_surface_color;
+    _surface.diffuse_texcoord = v_texcoord;
+    _surface.diffuse_intensity = material_diffuse_intensity;
+    _surface.shininess = material_shininess;
+    _surface.specular_color = vec3(0.0, 0.0, 0.0);
+    _surface.specular_texcoord = v_texcoord;
+    _surface.roughness = max(material_roughness, 0.04); // Clamp to avoid potential divide by 0
+    _surface.roughness_intensity = material_roughness_intensity;
+    _surface.metalness = material_metalness;
+    _surface.metalness_intensity = material_metalness_intensity;
+    _surface.ao = material_ao;
+    _surface.alpha = material_alpha;
+    _surface.normal = normalize(v_tbn[2]);
+    _surface.position = v_surface_position;
+    _surface.view = normalize(camera_position - _surface.position);
+    
+    highp vec3 _ambient  = ambient_light_color.xyz;
+    highp vec3 _diffuse  = vec3(0, 0, 0);
+    highp vec3 _specular = vec3(0, 0, 0);
+    
+#pragma surface_modifier_body
+  
+    for (int i = 0; i < num_lights; i++) {
+        _lightingContribution.ambient  = vec3(0.0);
+        _lightingContribution.diffuse  = vec3(0.0);
+        _lightingContribution.specular = vec3(0.0);
+        _lightingContribution.visibility = 1.0;
+        
+        VROLightUniforms _light = lights[i];
+        
+#pragma lighting_model_modifier_body
+        
+        _ambient  += _lightingContribution.ambient;
+        _diffuse  += _lightingContribution.diffuse  * _lightingContribution.visibility;
+        _specular += _lightingContribution.specular * _lightingContribution.visibility;
+    }
+    
+    highp vec4 _output_color = vec4(_ambient  * _surface.diffuse_color.xyz +
+                                    _diffuse  * _surface.diffuse_color.xyz * _surface.diffuse_intensity +
+                                    _specular * _surface.specular_color,
+                                    _surface.alpha * _surface.diffuse_color.a);
+    
+#pragma fragment_modifier_body
+    
+    frag_color = _output_color;
+}
+