CompiledProgram (0a8c9efdfa4357dfdff72dc9b262d863)

Input Blocks:
- vertexBlockUber - GetAnimatedUVCoords - GetEmissiveAndTintingFromVertexColor -
light_sh_0 - TangentSpaceNormalToViewAndWorldSpace - SimpleAlphaTested -
RuntimeTinting - IllumLambert - LightAtlas - light-dir-0
Vertex Shader Source:
#version 300 es

//////////////////////////////////////////////
// Osiris CL-16, shadercore: 2.5
// ------------------------------------
// block: vertexBlockUber
// block: GetAnimatedUVCoords
// block: GetEmissiveAndTintingFromVertexColor
// block: light_sh_0
// block: TangentSpaceNormalToViewAndWorldSpace
// block: SimpleAlphaTested
// block: RuntimeTinting
// block: IllumLambert
// block: LightAtlas
// block: light-dir-0
//
//////////////////////////////////////////////

precision highp float;

precision highp int;

// Attributes
//==========================
in vec4 a_Position0;
in vec3 a_Normal0;
in vec2 a_TexCoord0;

// Uniforms
//==========================

// Uniforms
//==========================
uniform highp mat4 sys_Model;
uniform highp mat4 sys_ModelViewProjection;
uniform highp mat4 sys_InverseView;
uniform highp mat3 sys_InverseModelT;
uniform highp mat3 sys_InverseModelViewT;
uniform highp float sys_Time;

uniform highp vec4 gSpecialControl_VS;

uniform highp vec4 aux_ScaleBias[4];

// Varyings
//==========================
out mediump vec4 v_Varying6;
out highp vec3 v_Varying5;
out highp vec3 v_Varying1;
out mediump vec3 v_Varying4;
out highp vec3 v_Varying2;
out highp vec3 v_Varying3;
out highp vec2 v_Varying0;
//==========================================
// Vertex Shader
//==========================================
void main()
{
vec3 tmp0 = normalize(sys_InverseModelViewT * a_Normal0);
vec3 tmp1 = normalize(sys_InverseModelT * a_Normal0);
mat3 tmp3 = mat3(sys_InverseView);
vec3 tmp2 = tmp3 * normalize(tmp0);
vec3 tmp6 = aux_ScaleBias[uint(0)].xyz * a_Position0.xyz;
vec3 tmp5 = tmp6 + aux_ScaleBias[uint(1)].xyz;
vec4 tmp4 = sys_Model * vec4(tmp5, 1.0);
vec2 tmp8 = vec2(sys_Time, sys_Time) * gSpecialControl_VS.xy;
vec2 tmp7 = aux_ScaleBias[uint(2)].xy
* a_TexCoord0 + aux_ScaleBias[uint(3)].xy + tmp8;

// Varyings
v_Varying6 = vec4(0.0, 0.0, 0.0, 1.0);
v_Varying5 = tmp0;
v_Varying1 = tmp1;
v_Varying4 = vec3(1.0, 1.0, 1.0);
v_Varying2 = tmp2;
v_Varying3 = tmp4.xyz;
v_Varying0 = tmp7;

// Outputs
gl_Position = sys_ModelViewProjection * vec4(tmp5, 1.0);
}

Fragment Shader Source:

#version 300 es

//////////////////////////////////////////////
// Osiris CL-16, shadercore: 2.5
// ------------------------------------
// block: vertexBlockUber
// block: GetAnimatedUVCoords
// block: GetEmissiveAndTintingFromVertexColor
// block: light_sh_0
// block: TangentSpaceNormalToViewAndWorldSpace
// block: SimpleAlphaTested
// block: RuntimeTinting
// block: IllumLambert
// block: LightAtlas
// block: light-dir-0
//
//////////////////////////////////////////////

precision mediump float;

precision mediump sampler2DShadow;

out mediump vec4 frag_color0;

// Uniforms
//==========================

// Uniforms
//==========================
uniform highp vec4 sys_LightColor[4];
uniform highp vec4 sys_LightDirection[4];
uniform highp vec4 sys_LightSH0[7];

uniform lowp sampler2D gBaseTexture_FS;

uniform highp vec4 gRuntimeTint;

uniform highp vec3 gFloorPosition_FS;
uniform highp vec3 gSurfaceNormal_FS;
uniform highp vec3 gSurfacePosition_FS;
uniform highp vec2 gSurfaceSize_FS;
uniform highp float gAlphaTest_FS;
uniform highp float gObjectLightIntensityScale;
uniform lowp sampler2D gLightAtlasTextureMultistory_FS;
uniform lowp sampler2D gLightAtlasTextureOne_FS;
uniform lowp sampler2D gMaskTexture_FS;

// Varyings
//==========================
in mediump vec4 v_Varying6;
in highp vec3 v_Varying5;
in highp vec3 v_Varying1;
in mediump vec3 v_Varying4;
in highp vec3 v_Varying2;
in highp vec3 v_Varying3;
in highp vec2 v_Varying0;

//==========================================
// Pixel Shader Main
//==========================================
void main()
{
highp float tmp0 = texture(gMaskTexture_FS, v_Varying0).y;
if (tmp0 < gAlphaTest_FS)
{
discard;
}
highp vec4 tmp1 = v_Varying1.yzzx * v_Varying1.xyzz;
highp vec3 tmp2 = vec3(dot(sys_LightSH0[3], tmp1), dot(sys_LightSH0[4], tmp1),
dot(sys_LightSH0[5], tmp1));
highp float tmp4 = max(dot(gSurfaceNormal_FS, v_Varying2), 0.75);
highp float tmp6 = v_Varying3.y - gSurfacePosition_FS.y;
highp float tmp7 = gFloorPosition_FS.y - gSurfacePosition_FS.y;
highp float tmp5 = clamp(2.0 * (1.0
- tmp6 / tmp7) * sign(tmp7 - 1.0), 0.0, 1.0);
highp float tmp3 = mix(tmp4, 0.0, tmp5);
highp float tmp13 = v_Varying3.x - gSurfacePosition_FS.x;
highp float tmp12 = tmp13 / gSurfaceSize_FS.x;
highp float tmp16 = v_Varying3.z - gSurfacePosition_FS.z;
highp float tmp15 = tmp16 / gSurfaceSize_FS.x;
highp float tmp17 = abs(gSurfaceNormal_FS.x);
highp float tmp14 = mix(tmp12, tmp15, tmp17);
highp float tmp18 = 1.0 - gSurfaceNormal_FS.y;
highp float tmp11 = mix(tmp12, tmp14, tmp18);
highp float tmp10 = clamp(tmp11, 0.0, 1.0);
highp float tmp21 = tmp16 / gSurfaceSize_FS.y;
highp float tmp22 = tmp6 / gSurfaceSize_FS.y;
highp float tmp20 = mix(tmp21, tmp22, tmp18);
highp float tmp19 = clamp(tmp20, 0.0, 1.0);
highp vec2 tmp9 = vec2(tmp10, tmp19);
 highp vec4 tmp8 = texture(gLightAtlasTextureMultistory_FS, tmp9);
highp float tmp23 = mix(0.0, tmp4, tmp5);
highp vec4 tmp24 = texture(gLightAtlasTextureOne_FS, tmp9);
highp vec3 tmp25 = (vec4(gObjectLightIntensityScale,
gObjectLightIntensityScale, gObjectLightIntensityScale, gObjectLightIntensityScale)
* (vec4(1.5, 1.5, 1.5, 1.5) * vec4(tmp3, tmp3, tmp3, tmp3) * tmp8
+ vec4(1.5, 1.5, 1.5, 1.5) * vec4(tmp23, tmp23, tmp23, tmp23) * tmp24)).xyz;
vec4 tmp28 = texture(gBaseTexture_FS, v_Varying0);
highp vec3 tmp27 = v_Varying4 * tmp28.xyz * gRuntimeTint.xyz;
highp vec3 tmp26 = tmp27 * tmp27;
highp vec3 tmp29 = clamp(dot(-(sys_LightDirection[0].xyz),
normalize(normalize(v_Varying5))), 0.0, 1.0)
* sys_LightColor[0].xyz;
highp vec4 tmp30 = v_Varying6;
highp float tmp32 = tmp28.w * gRuntimeTint.w;

// Outputs
frag_color0 = vec4(sqrt(((vec3(dot(sys_LightSH0[0], vec4(v_Varying1, 1.0)),
dot(sys_LightSH0[1], vec4(v_Varying1, 1.0)), dot(sys_LightSH0[2], vec4(v_Varying1,
1.0)))
+ tmp2 + (v_Varying1.x * v_Varying1.x - v_Varying1.y * v_Varying1.y)
* sys_LightSH0[6].xyz + tmp25) * tmp26
+ tmp26 * tmp29) * tmp30.w + tmp26 * tmp30.xyz), tmp32);
}