0% found this document useful (0 votes)

54 views396 pages

Minecraft Launcher Debug Log Analysis

Uploaded by

lourenzlepardo

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

54 views396 pages

Minecraft Launcher Debug Log Analysis

Uploaded by

lourenzlepardo

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

--------- beginning with launcher debug

Info: Launcher version: foxglove-20240922-a6a6a29-v3_openjdk

Info: Architecture: arm64
Info: Device model: OPPO CPH2269
Info: API version: 30
Info: Selected Minecraft version: 1.21
Info: Custom Java arguments: ""
Added custom env: TMPDIR=/data/user/0/[Link]/cache
Added custom env: AWTSTUB_WIDTH=1544
Added custom env: FORCE_VSYNC=false
Added custom env: POJAV_BIG_CORE_AFFINITY=1
Added custom env:
POJAV_NATIVEDIR=/data/app/~~aBfZ231ddOryFAp37C3cow==/[Link]-
HJZ4jTxVxBJfo6DVRtF2dQ==/lib/arm64
Added custom env: LIBGL_MIPMAP=3
Added custom env: allow_higher_compat_version=true
Added custom env: MESA_GLSL_CACHE_DIR=/data/user/0/[Link]/cache
Added custom env: HOME=/storage/emulated/0/Android/data/[Link]/files
Added custom env:
PATH=/data/user/0/[Link]/runtimes/Internal-21/bin:/product/bin:/apex/
[Link]/bin:/apex/[Link]/bin:/system_ext/bin:/system/bin:/
system/xbin:/odm/bin:/vendor/bin:/vendor/xbin
Added custom env: LIBGL_NOINTOVLHACK=1
Added custom env: force_glsl_extensions_warn=true
Added custom env: LIBGL_NORMALIZE=1
Added custom env: LIBGL_VGPU_DUMP=1
Added custom env: POJAV_VSYNC_IN_ZINK=1
Added custom env:
LD_LIBRARY_PATH=/data/user/0/[Link]/runtimes/Internal-21/lib/jli:/
data/user/0/[Link]/runtimes/Internal-21/lib:/system/lib64:/vendor/
lib64:/vendor/lib64/hw:/data/app/~~aBfZ231ddOryFAp37C3cow==/[Link]-
HJZ4jTxVxBJfo6DVRtF2dQ==/lib/arm64
Added custom env: LIBGL_NOERROR=1
Added custom env: POJAV_RENDERER=opengles2
Added custom env: LIBGL_ES=2
Added custom env:
VTEST_SOCKET_NAME=/data/user/0/[Link]/cache/.virgl_test
Added custom env: MESA_LOADER_DRIVER_OVERRIDE=zink
Added custom env: JAVA_HOME=/data/user/0/[Link]/runtimes/Internal-21
Added custom env: allow_glsl_extension_directive_midshader=true
Added custom env: AWTSTUB_HEIGHT=720
Initialising gl4es
v1.1.5 built on Jul 14 2024 [Link]
Using GLES 2.0 backend
loaded: [Link]
loaded: [Link]
Using GLES 2.0 backend
Hardware Full NPOT detected and used
Extension GL_EXT_blend_minmax detected and used
Extension GL_EXT_draw_buffers detected and used
FBO are in core, and so used
PointSprite are in core, and so used
CubeMap are in core, and so used
BlendColor is in core, and so used
Blend Subtract is in core, and so used
Blend Function and Equation Separation is in core, and so used
Texture Mirrored Repeat is in core, and so used
Extension GL_OES_mapbuffer detected
Extension GL_OES_element_index_uint detected and used
Extension GL_OES_packed_depth_stencil detected and used
Extension GL_OES_depth24 detected and used
Extension GL_OES_rgb8_rgba8 detected and used
Extension GL_EXT_multi_draw_arrays detected
Extension GL_EXT_texture_format_BGRA8888 detected and used
Extension GL_OES_depth_texture detected and used
Extension GL_OES_texture_stencil8 detected and used
Extension GL_EXT_texture_rg detected and used
Extension GL_OES_texture_float detected and used
Extension GL_OES_texture_half_float detected and used
Extension GL_EXT_color_buffer_float detected and used
Extension GL_EXT_color_buffer_half_float detected and used
Extension GL_OES_fragment_precision_high detected and used
Extension GL_EXT_shader_texture_lod detected and used
Max vertex attrib: 16
Extension GL_OES_standard_derivatives detected and used
Extension GL_OES_get_program_binary detected and used
Number of supported Program Binary Format: 1
Max texture size: 8192
Max Varying Vector: 15
Texture Units: 16/16 (hardware: 16), Max lights: 8, Max planes: 6
Hardware vendor is Imagination Technologies
GLSL 300 es supported
GLSL 310 es supported and used
GLSL 320 es supported
Max Color Attachments: 8 / Draw buffers: 8
sRGB surface supported
EGLImage to Texture2D supported
EGLImage to RenderBuffer supported
ignore MipMap
glGetError() always return GL_NOERROR
Targeting OpenGL 2.1
No hack in shader converter to define overloaded function with int
Not trying to batch small subsequent glDrawXXXX
try to use VBO
FBO workaround for using binded texture enabled
Force texture for Attachment color0 on FBO
Hack to trigger a SwapBuffers when a Full Framebuffer Blit on default FBO is done
Force normals to be normalized on FPE shaders
Dump the content of VGPU shader conversion
glX Will try to recycle EGL Surface
Current folder is:/
[Link]
at [Link]/[Link]([Link])
at
[Link](CTCPrelo
[Link])
at
[Link].<clinit>(CTCPreloadCl
[Link])
at [Link]/[Link].ensureClassInitialized0(Native Method)
at
[Link]/[Link]([Link])
at
[Link]/[Link](M
[Link])
at
[Link]/[Link](M
[Link])
at
[Link]/[Link](ReflectionF
[Link])
at
[Link]/[Link]([Link]
:549)
at
[Link]/[Link]([Link])
at [Link]/[Link]([Link])
at
[Link]/[Link]([Link])
at [Link]/[Link].initPhase3([Link])
ERROR StatusConsoleListener appender Console has no parameter that matches element
Policies
[Link] [main/WARN]: Failed retrieving info for group processor
[Link]:

There is an incompatible JNA native library installed on this system

Expected: 7.0.0
Found: 6.1.6
(at /data/app/~~aBfZ231ddOryFAp37C3cow==/[Link]-
HJZ4jTxVxBJfo6DVRtF2dQ==/lib/arm64/[Link]).
To resolve this issue you may do one of the following:
- remove or uninstall the offending library
- set the system property [Link]=true
- set [Link] to include the path to the version of the
jnidispatch library included with the JNA jar file you are using
[in thread "main"]
at [Link].<clinit>([Link]) ~[[Link].14.0 (b0)]
at [Link].<clinit>([Link]) ~[jna-platform-
[Link].14.0 (b0)]
at
[Link].<clinit>([Link])
~[[Link].4.10]
at
[Link](LinuxCentral
[Link]) ~[[Link].4.10]
at
[Link].<init>([Link]:
67) ~[[Link].4.10]
at
[Link].<init>([Link]
a:58) ~[[Link].4.10]
at
[Link](LinuxHar
[Link]) ~[[Link].4.10]
at [Link]$[Link]([Link]) ~[[Link].4.10]
at
[Link](AbstractHardware
[Link]) ~[[Link].4.10]
at ac.c(SourceFile:79) ~[[Link]:?]
at ac.a(SourceFile:87) ~[[Link]:?]
at ac.a(SourceFile:79) ~[[Link]:?]
... 6 more
[Link] [Datafixer Bootstrap/INFO]: 226 Datafixer optimizations took 2424
milliseconds
[Link] [Render thread/INFO]: [STDERR]: [LWJGL] [ERROR] Incompatible Java and
native library versions detected.
Possible reasons:
a) -[Link] is set to a folder containing shared libraries of an
older LWJGL version.
b) The classpath contains jar files of an older LWJGL version.
Possible solutions:
a) Make sure to not set -[Link] (it is not needed for developing
with LWJGL 3) or make
sure the folder it points to contains the shared libraries of the correct
LWJGL version.
b) Check the classpath and make sure to only have jar files of the same LWJGL
version in it.
[LWJGL] Failed to load a library. Possible solutions:
a) Add the directory that contains the shared library to -[Link]
or -[Link].
b) Add the JAR that contains the shared library to the classpath.
[LWJGL] Enable debug mode with -[Link]=true for better diagnostics.
[LWJGL] Enable the SharedLibraryLoader debug mode with -
[Link]=true for better diagnostics.
[Link] [Render thread/INFO]: Environment:
Environment[sessionHost=[Link]
servicesHost=[Link] name=PROD]
[Link] [Render thread/INFO]: Setting user: Lorinzo99999
Registered forkAndExec
[Link] [Render thread/ERROR]: Error parsing option value off for option
Fullscreen: Not a boolean: "off"
[Link] [Render thread/INFO]: Backend library: LWJGL version 3.3.3-snapshot
EGLBridge: Binding to OpenGL ES
[Link] [Download-2/ERROR]: Failed to fetch user properties
[Link]: null
at
[Link](Mi
[Link]) ~[[Link]:?]
at
[Link](YggdrasilUserA
[Link]) ~[[Link]:?]
at [Link](SourceFile:458) ~[[Link]:?]
at
[Link]/[Link]$[Link](CompletableFuture.
java:1768) ~[?:?]
at
[Link]/[Link]([Link]
:1144) ~[?:?]
at
[Link]/[Link]$[Link]([Link]
a:642) ~[?:?]
at [Link]/[Link]([Link]) [?:?]
[Link] [Download-1/WARN]: Couldn't look up profile properties for 00000000-
0000-0000-0000-000000000000
[Link]: Failed to read from
[Link]
00000000?unsigned=false due to [Link]
at
[Link](MinecraftClient
.java:108) ~[[Link]:?]
at
[Link]([Link])
~[[Link]:?]
at
[Link](
[Link]) ~[[Link]:?]
at
[Link](Yggdrasi
[Link]) ~[[Link]:?]
at [Link](SourceFile:454) ~[[Link]:?]
at
[Link]/[Link]$[Link](CompletableFuture.
java:1768) ~[?:?]
at
[Link]/[Link]([Link]
:1144) ~[?:?]
at
[Link]/[Link]$[Link]([Link]
a:642) ~[?:?]
at [Link]/[Link]([Link]) [?:?]
Caused by: [Link]: [Link]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link].<init>([Link])
~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link]
lient([Link]) ~[?:?]
at
[Link]/[Link].plainConnect0(HttpURLConnecti
[Link]) ~[?:?]
at
[Link]/[Link](HttpURLConnectio
[Link]) ~[?:?]
at
[Link]/[Link](Abs
[Link]) ~[?:?]
at
[Link]/[Link].getInputStream0(HttpURLConnec
[Link]) ~[?:?]
at
[Link]/[Link](HttpURLConnect
[Link]) ~[?:?]
at
[Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link](HttpsUR
[Link]) ~[?:?]
at
[Link](MinecraftClient
.java:84) ~[[Link]:?]
... 8 more
[Link] [Yggdrasil Key Fetcher/ERROR]: Failed to request yggdrasil public key
[Link]: Failed to read from
[Link] due to [Link]
at
[Link](MinecraftClient
.java:108) ~[[Link]:?]
at
[Link]([Link])
~[[Link]:?]
at
[Link](YggdrasilServicesKeyInf
[Link]) ~[[Link]:?]
at
[Link]$[Link](YggdrasilServicesKeyInf
[Link]) ~[[Link]:?]
at
[Link]/[Link]$[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at
[Link]/[Link]$[Link](
[Link]) ~[?:?]
at
[Link]/[Link]([Link]
:1144) ~[?:?]
at
[Link]/[Link]$[Link]([Link]
a:642) ~[?:?]
at [Link]/[Link]([Link]) [?:?]
Caused by: [Link]: [Link]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link].<init>([Link])
~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link]
lient([Link]) ~[?:?]
at
[Link]/[Link].plainConnect0(HttpURLConnecti
[Link]) ~[?:?]
at
[Link]/[Link](HttpURLConnectio
[Link]) ~[?:?]
at
[Link]/[Link](Abs
[Link]) ~[?:?]
at
[Link]/[Link].getInputStream0(HttpURLConnec
[Link]) ~[?:?]
at
[Link]/[Link](HttpURLConnect
[Link]) ~[?:?]
at
[Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link](HttpsUR
[Link]) ~[?:?]
at
[Link](MinecraftClient
.java:84) ~[[Link]:?]
... 9 more
[Link] [Render thread/INFO]: [STDERR]: [LWJGL] [ERROR] Incompatible Java and
native library versions detected.
Possible reasons:
a) -[Link] is set to a folder containing shared libraries of an
older LWJGL version.
b) The classpath contains jar files of an older LWJGL version.
Possible solutions:
a) Make sure to not set -[Link] (it is not needed for developing
with LWJGL 3) or make
sure the folder it points to contains the shared libraries of the correct
LWJGL version.
b) Check the classpath and make sure to only have jar files of the same LWJGL
version in it.
[Link] [Render thread/INFO]: [STDERR]: [LWJGL] [ERROR] Incompatible Java and
native library versions detected.
Possible reasons:
a) -[Link] is set to a folder containing shared libraries of an
older LWJGL version.
b) The classpath contains jar files of an older LWJGL version.
Possible solutions:
a) Make sure to not set -[Link] (it is not needed for developing
with LWJGL 3) or make
sure the folder it points to contains the shared libraries of the correct
LWJGL version.
b) Check the classpath and make sure to only have jar files of the same LWJGL
version in it.
[Link] [Render thread/INFO]: [STDERR]: [LWJGL] [ERROR] Incompatible Java and
native library versions detected.
Possible reasons:
a) -[Link] is set to a folder containing shared libraries of an
older LWJGL version.
b) The classpath contains jar files of an older LWJGL version.
Possible solutions:
a) Make sure to not set -[Link] (it is not needed for developing
with LWJGL 3) or make
sure the folder it points to contains the shared libraries of the correct
LWJGL version.
b) Check the classpath and make sure to only have jar files of the same LWJGL
version in it.
VGPU Shader source:
#version 150

in vec3 Position;

out vec2 texCoord;

void main() {
vec2 screenPos = [Link] * 2.0 - 1.0;
gl_Position = vec4(screenPos.x, screenPos.y, 1.0, 1.0);
texCoord = [Link];
}

New VGPU Shader output:

#version 320 es
#ifdef GL_OES_texture_storage_multisample_2d_array
#extension GL_OES_texture_storage_multisample_2d_array : enable
#endif
#ifdef GL_EXT_texture_buffer
#extension GL_EXT_texture_buffer : enable
#endif
#ifdef GL_EXT_texture_cube_map_array
#extension GL_EXT_texture_cube_map_array : enable
#endif
#ifdef GL_EXT_shader_non_constant_global_initializers
#extension GL_EXT_shader_non_constant_global_initializers : enable
#endif
precision highp float;
precision highp int;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

uniform sampler2D DiffuseSampler;

in vec2 texCoord;

out vec4 fragColor;

void main() {
fragColor = texture(DiffuseSampler, texCoord);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D DiffuseSampler;
in vec2 texCoord;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (DiffuseSampler, texCoord);
fragColor = tmpvar_3;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vertexColor = Color;
}

VGPU Shader source:

#version 150

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec4 vertexColor;
uniform vec4 ColorModulator;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
bool tmpvar_3;
tmpvar_3 = bool(0);
if ((vertexColor.w == 0.0)){
tmpvar_3 = bool(1);
}
;
tmpvar_2 = tmpvar_3;
tmpvar_1 = tmpvar_3;
if ( tmpvar_1) {discard; };
fragColor = (vertexColor * ColorModulator);
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;

uniform mat4 ProjMat;

uniform mat4 ModelViewMat;
uniform int FogShape;

out float vertexDistance;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
uniform mat4 ProjMat;
uniform mat4 ModelViewMat;
uniform int FogShape;
out float vertexDistance;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_28;
gl_Position = ((((ProjMat[0] * tmpvar_27.x) + (ProjMat[1] * tmpvar_27.y)) +
(ProjMat[2] * tmpvar_27.z)) + (ProjMat[3] * tmpvar_27.w));
float tmpvar_29;
tmpvar_29 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_29;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;

out vec4 fragColor;

void main() {
fragColor = linear_fog(ColorModulator, vertexDistance, FogStart, FogEnd,
FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = linear_fog (ColorModulator, vertexDistance, FogStart, FogEnd,
FogColor);
fragColor = tmpvar_27;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec2 UV0;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec2 texCoord0;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
in vec2 texCoord0;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (Sampler0, texCoord0);
bool tmpvar_4;
tmpvar_4 = bool(0);
if ((tmpvar_3.w == 0.0)){
tmpvar_4 = bool(1);
}
;
tmpvar_2 = tmpvar_4;
tmpvar_1 = tmpvar_4;
if ( tmpvar_1) {discard; };
fragColor = (tmpvar_3 * ColorModulator);
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec2 UV0;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec2 texCoord0;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

texCoord0 = UV0;
vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec2 UV0;
in vec4 Color;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec2 texCoord0;
out vec4 vertexColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
texCoord0 = UV0;
vertexColor = Color;
}

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec2 texCoord0;
in vec4 vertexColor;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
in vec2 texCoord0;
in vec4 vertexColor;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_3;
vec4 tmpvar_4;
tmpvar_4 = texture (Sampler0, texCoord0);
color_3 = (tmpvar_4 * vertexColor);
bool tmpvar_5;
tmpvar_5 = bool(0);
if ((color_3.w < 0.1)){
tmpvar_5 = bool(1);
}
;
tmpvar_2 = tmpvar_5;
tmpvar_1 = tmpvar_5;
if ( tmpvar_1) {discard; };
fragColor = (color_3 * ColorModulator);
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}
New VGPU Shader output:
#version 320 es
#ifdef GL_OES_texture_storage_multisample_2d_array
#extension GL_OES_texture_storage_multisample_2d_array : enable
#endif
#ifdef GL_EXT_texture_buffer
#extension GL_EXT_texture_buffer : enable
#endif
#ifdef GL_EXT_texture_cube_map_array
#extension GL_EXT_texture_cube_map_array : enable
#endif
#ifdef GL_EXT_shader_non_constant_global_initializers
#extension GL_EXT_shader_non_constant_global_initializers : enable
#endif
precision highp float;
precision highp int;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = ((tmpvar_28 * vertexColor) * ColorModulator);
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((color_27.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
vec4 tmpvar_30;
tmpvar_30 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_30;
}

[Link] [Render thread/ERROR]: Error while loading the narrator

[Link]$InitializeException: Failed to load library flite
at
[Link]$[Link]([Link])
~[[Link]:?]
at [Link].<init>([Link])
~[[Link]:?]
at [Link]([Link])
[[Link]:?]
at fgg.<init>(SourceFile:19) [[Link]:?]
at fgo.<init>(SourceFile:675) [[Link]:?]
at [Link](SourceFile:239) [[Link]:?]
Caused by: [Link]: Could not initialize class
[Link]
at [Link].<clinit>([Link]) ~[jna-
[Link].14.0 (b0)]
at
[Link]$[Link]([Link])
~[[Link]:?]
... 5 more
Caused by: [Link]: Exception [Link]:

There is an incompatible JNA native library installed on this system

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;
in vec4 Color;
in ivec2 UV2;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec2 texCoord0;
out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

texCoord0 = UV0;
vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec2 UV0;
in vec4 Color;
in vec2 UV2;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
out float vertexDistance;
out vec2 texCoord0;
out vec4 vertexColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}
float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){
bool tmpvar_16;
tmpvar_16 = bool(1);
float tmpvar_17;
if ((fogStart_14 >= vertexDistance_13)){
tmpvar_17 = 1.0;
tmpvar_16 = bool(0);
}
else
{
if ((vertexDistance_13 >= fogEnd_15)){
tmpvar_17 = 0.0;
tmpvar_16 = bool(0);
}
;
}
if (tmpvar_16){
float tmpvar_18;
tmpvar_18 = smoothstep (fogEnd_15, fogStart_14, vertexDistance_13);
tmpvar_17 = tmpvar_18;
tmpvar_16 = bool(0);
}
;
return tmpvar_17;
}

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec2 texCoord0;
in vec4 vertexColor;
out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec2 texCoord0;
in vec4 vertexColor;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;

uniform mat4 ProjMat;

uniform mat4 ModelViewMat;
uniform int FogShape;

out float vertexDistance;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

}

New VGPU Shader output:

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;

out vec4 fragColor;

void main() {
fragColor = linear_fog(ColorModulator, vertexDistance, FogStart, FogEnd,
FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = linear_fog (ColorModulator, vertexDistance, FogStart, FogEnd,
FogColor);
fragColor = tmpvar_27;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord2;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord2 = UV2;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
out vec2 texCoord2;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vertexColor = Color;
texCoord2 = UV2;
}
VGPU Shader source:
#version 150

uniform sampler2D Sampler2;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord2;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler2, texCoord2) * vertexColor;
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler2;
uniform vec4 ColorModulator;
in vec4 vertexColor;
in vec2 texCoord2;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (Sampler2, texCoord2);
fragColor = ((tmpvar_3 * vertexColor) * ColorModulator);
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;
out vec2 texCoord2;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
texCoord2 = UV2;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord2;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vertexColor = Color;
texCoord0 = UV0;
texCoord2 = UV2;
}
VGPU Shader source:
#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord2;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord2;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_3;
vec4 tmpvar_4;
tmpvar_4 = texture (Sampler0, texCoord0);
color_3 = (tmpvar_4 * vertexColor);
bool tmpvar_5;
tmpvar_5 = bool(0);
if ((color_3.w < 0.1)){
tmpvar_5 = bool(1);
}
;
tmpvar_2 = tmpvar_5;
tmpvar_1 = tmpvar_5;
if ( tmpvar_1) {discard; };
fragColor = (color_3 * ColorModulator);
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

texCoord0 = UV0;
}
New VGPU Shader output:
#version 320 es
#ifdef GL_OES_texture_storage_multisample_2d_array
#extension GL_OES_texture_storage_multisample_2d_array : enable
#endif
#ifdef GL_EXT_texture_buffer
#extension GL_EXT_texture_buffer : enable
#endif
#ifdef GL_EXT_texture_cube_map_array
#extension GL_EXT_texture_cube_map_array : enable
#endif
#ifdef GL_EXT_shader_non_constant_global_initializers
#extension GL_EXT_shader_non_constant_global_initializers : enable
#endif
precision highp float;
precision highp int;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec2 UV0;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec2 texCoord0;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
texCoord0 = UV0;
vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec2 texCoord0;
in vec4 vertexColor;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;
precision lowp sampler2D;
precision lowp sampler3D;
precision lowp sampler2DShadow;
precision lowp samplerCubeShadow;
precision lowp sampler2DArray;
precision lowp sampler2DArrayShadow;
precision lowp samplerCube;
#ifdef GL_EXT_texture_buffer
precision lowp samplerBuffer;
precision lowp imageBuffer;
#endif
#ifdef GL_EXT_texture_cube_map_array
precision lowp imageCubeArray;
precision lowp samplerCubeArray;
precision lowp samplerCubeArrayShadow;
#endif
#ifdef GL_OES_texture_storage_multisample_2d_array
precision lowp sampler2DMS;
precision lowp sampler2DMSArray;
#endif

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

float light0 = max(0.0, dot(lightDir0, normal));
float light1 = max(0.0, dot(lightDir1, normal));
float lightAccum = min(1.0, (light0 + light1) * MINECRAFT_LIGHT_POWER +
MINECRAFT_AMBIENT_LIGHT);
return vec4([Link] * lightAccum, color.a);
}

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform vec3 ChunkOffset;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
vec3 pos = Position + ChunkOffset;
gl_Position = ProjMat * ModelViewMat * vec4(pos, 1.0);

vertexDistance = fog_distance(pos, FogShape);

vertexColor = Color * minecraft_sample_lightmap(Sampler2, UV2);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform vec3 ChunkOffset;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

fogEnd_21, vec4 fogColor_22){
vec4 tmpvar_23;
if ((fogStart_20 >= vertexDistance_19)){
tmpvar_23 = inColor_18;
}
else
{
float tmpvar_24;
if ((vertexDistance_19 < fogEnd_21)){
float tmpvar_25;
tmpvar_25 = smoothstep (fogStart_20, fogEnd_21, vertexDistance_19);
tmpvar_24 = tmpvar_25;
}
else
{
tmpvar_24 = 1.0;
}
vec3 tmpvar_26;
tmpvar_26 = mix (inColor_18.xyz, fogColor_22.xyz, (tmpvar_24 * fogColor_22.w));
vec4 tmpvar_27;
tmpvar_27.xyz = tmpvar_26;
tmpvar_27.w = inColor_18.w;
tmpvar_23 = tmpvar_27;
}
return tmpvar_23;
}

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

bool tmpvar_31;
tmpvar_31 = bool(1);
float tmpvar_32;
if ((fogStart_29 >= vertexDistance_28)){
tmpvar_32 = 1.0;
tmpvar_31 = bool(0);
}
else
{
if ((vertexDistance_28 >= fogEnd_30)){
tmpvar_32 = 0.0;
tmpvar_31 = bool(0);
}
;
}
if (tmpvar_31){
float tmpvar_33;
tmpvar_33 = smoothstep (fogEnd_30, fogStart_29, vertexDistance_28);
tmpvar_32 = tmpvar_33;
tmpvar_31 = bool(0);
}
;
return tmpvar_32;
}

float fog_distance(vec3 pos_34, int shape_35){

float tmpvar_36;
if ((shape_35 == 0)){
float tmpvar_37;
tmpvar_37 = length (pos_34);
tmpvar_36 = tmpvar_37;
}
else
{
float distXZ_38;
float tmpvar_39;
tmpvar_39 = length (pos_34.xz);
distXZ_38 = tmpvar_39;
float tmpvar_40;
tmpvar_40 = abs (pos_34.y);
float tmpvar_41;
tmpvar_41 = max (distXZ_38, tmpvar_40);
tmpvar_36 = tmpvar_41;
}
return tmpvar_36;
}

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec3 pos_42;
pos_42 = (Position + ChunkOffset);
vec4 tmpvar_43;
tmpvar_43 = ((((ModelViewMat[0] * pos_42.x) + (ModelViewMat[1] * pos_42.y)) +
(ModelViewMat[2] * pos_42.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_44;
gl_Position = ((((ProjMat[0] * tmpvar_43.x) + (ProjMat[1] * tmpvar_43.y)) +
(ProjMat[2] * tmpvar_43.z)) + (ProjMat[3] * tmpvar_43.w));
float tmpvar_45;
tmpvar_45 = fog_distance (pos_42, FogShape);
vertexDistance = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = minecraft_sample_lightmap (Sampler2, ivec2(UV2));
vertexColor = (Color * tmpvar_46);
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}
float fog_distance(vec3 pos, int shape) {
if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = texture (Sampler0, texCoord0);
vec4 tmpvar_28;
tmpvar_28 = linear_fog (((tmpvar_27 * vertexColor) * ColorModulator),
vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_28;
}
VGPU Shader source:
#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform vec3 ChunkOffset;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
vec3 pos = Position + ChunkOffset;
gl_Position = ProjMat * ModelViewMat * vec4(pos, 1.0);

vertexDistance = fog_distance(pos, FogShape);

vertexColor = Color * minecraft_sample_lightmap(Sampler2, UV2);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}
return smoothstep(fogEnd, fogStart, vertexDistance);
}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.5) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = ((tmpvar_28 * vertexColor) * ColorModulator);
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((color_27.w < 0.5)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
vec4 tmpvar_30;
tmpvar_30 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_30;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}
return smoothstep(fogEnd, fogStart, vertexDistance);
}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform vec3 ChunkOffset;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
vec3 pos = Position + ChunkOffset;
gl_Position = ProjMat * ModelViewMat * vec4(pos, 1.0);

vertexDistance = fog_distance(pos, FogShape);

vertexColor = Color * minecraft_sample_lightmap(Sampler2, UV2);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/
vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,
vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform vec3 ChunkOffset;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
vec3 pos = Position + ChunkOffset;
gl_Position = ProjMat * ModelViewMat * vec4(pos, 1.0);

vertexDistance = fog_distance(pos, FogShape);

vertexColor = Color * minecraft_sample_lightmap(Sampler2, UV2);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);

texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
out vec2 texCoord0;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vec4 tmpvar_5;
tmpvar_5 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
vertexColor = (Color * tmpvar_5);
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform sampler2D Sampler2;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform sampler2D Sampler2;
uniform vec4 ColorModulator;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (Sampler0, texCoord0);
fragColor = ((tmpvar_3 * vertexColor) * ColorModulator);
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord1;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color) * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
texCoord1 = UV1;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
vertexColor = (tmpvar_45 * tmpvar_46);
texCoord0 = UV0;
texCoord1 = UV1;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}
float fog_distance(vec3 pos, int shape) {
if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color);
lightMapColor = texelFetch(Sampler2, UV2 / 16, 0);
overlayColor = texelFetch(Sampler1, UV1, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler1;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_46;
vec4 tmpvar_47;
tmpvar_47 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_47;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
[Link] = mix([Link], [Link], overlayColor.a);
color *= lightMapColor;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = ((tmpvar_28 * vertexColor) * ColorModulator);
vec3 tmpvar_29;
tmpvar_29 = mix ([Link], color_27.xyz, overlayColor.w);
color_27.xyz = tmpvar_29;
color_27 = (color_27 * lightMapColor);
vec4 tmpvar_30;
tmpvar_30 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_30;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_46;
vec4 tmpvar_47;
tmpvar_47 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_47;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a < 0.1) {
discard;
}
color *= vertexColor * ColorModulator;
[Link] = mix([Link], [Link], overlayColor.a);
color *= lightMapColor;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = tmpvar_28;
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((tmpvar_28.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
color_27 = (tmpvar_28 * (vertexColor * ColorModulator));
vec3 tmpvar_30;
tmpvar_30 = mix ([Link], color_27.xyz, overlayColor.w);
color_27.xyz = tmpvar_30;
color_27 = (color_27 * lightMapColor);
vec4 tmpvar_31;
tmpvar_31 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_31;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
vertexDistance = fog_distance(Position, FogShape);
vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color);
lightMapColor = texelFetch(Sampler2, UV2 / 16, 0);
overlayColor = texelFetch(Sampler1, UV1, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_46;
vec4 tmpvar_47;
tmpvar_47 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_47;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}
float fog_distance(vec3 pos, int shape) {
if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}
float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {
if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_46;
vec4 tmpvar_47;
tmpvar_47 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_47;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord1;
out vec2 texCoord2;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color) * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
texCoord1 = UV1;
texCoord2 = UV2;
}

New VGPU Shader output:

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord1;
out vec2 texCoord2;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

bool tmpvar_16;
tmpvar_16 = bool(1);
float tmpvar_17;
if ((fogStart_14 >= vertexDistance_13)){
tmpvar_17 = 1.0;
tmpvar_16 = bool(0);
}
else
{
if ((vertexDistance_13 >= fogEnd_15)){
tmpvar_17 = 0.0;
tmpvar_16 = bool(0);
}
;
}
if (tmpvar_16){
float tmpvar_18;
tmpvar_18 = smoothstep (fogEnd_15, fogStart_14, vertexDistance_13);
tmpvar_17 = tmpvar_18;
tmpvar_16 = bool(0);
}
;
return tmpvar_17;
}
float fog_distance(vec3 pos_19, int shape_20){
float tmpvar_21;
if ((shape_20 == 0)){
float tmpvar_22;
tmpvar_22 = length (pos_19);
tmpvar_21 = tmpvar_22;
}
else
{
float distXZ_23;
float tmpvar_24;
tmpvar_24 = length (pos_19.xz);
distXZ_23 = tmpvar_24;
float tmpvar_25;
tmpvar_25 = abs (pos_19.y);
float tmpvar_26;
tmpvar_26 = max (distXZ_23, tmpvar_25);
tmpvar_21 = tmpvar_26;
}
return tmpvar_21;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord1;
out vec2 texCoord2;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color) * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
texCoord1 = UV1;
texCoord2 = UV2;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_46;
vec4 tmpvar_47;
tmpvar_47 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_47;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = length((ModelViewMat * vec4(Position, 1.0)).xyz);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color);
overlayColor = texelFetch(Sampler1, UV1, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler1;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec4 overlayColor;
out vec2 texCoord0;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_18;
tmpvar_18 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_19;
gl_Position = ((((ProjMat[0] * tmpvar_18.x) + (ProjMat[1] * tmpvar_18.y)) +
(ProjMat[2] * tmpvar_18.z)) + (ProjMat[3] * tmpvar_18.w));
float tmpvar_20;
vec4 tmpvar_21;
tmpvar_20 = length (((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] *
Position.y)) + (ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0)).xyz);
vertexDistance = tmpvar_20;
vec4 tmpvar_22;
tmpvar_22 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_22;
vec4 tmpvar_23;
tmpvar_23 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_23;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;

in float vertexDistance;
in vec4 vertexColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a < 0.1) {
discard;
}
color *= vertexColor * ColorModulator;
[Link] = mix([Link], [Link], overlayColor.a);
fragColor = color * linear_fog_fade(vertexDistance, FogStart, FogEnd);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
in float vertexDistance;
in vec4 vertexColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = tmpvar_28;
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((tmpvar_28.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
color_27 = (tmpvar_28 * (vertexColor * ColorModulator));
vec3 tmpvar_30;
tmpvar_30 = mix ([Link], color_27.xyz, overlayColor.w);
color_27.xyz = tmpvar_30;
float tmpvar_31;
tmpvar_31 = linear_fog_fade (vertexDistance, FogStart, FogEnd);
fragColor = (color_27 * tmpvar_31);
}

[Link] [Render thread/WARN]: Shader rendertype_entity_translucent_emissive

could not find sampler named Sampler2 in the specified shader program.
VGPU Shader source:
#version 150

#line 0 1
/*#version 150*/
#define MINECRAFT_LIGHT_POWER (0.6)
#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = minecraft_mix_light (Light0_Direction, Light1_Direction, Normal,
Color);
vertexColor = tmpvar_45;
vec4 tmpvar_46;
tmpvar_46 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_46;
vec4 tmpvar_47;
tmpvar_47 = texelFetch (Sampler1, ivec2(UV1), 0);
overlayColor = tmpvar_47;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 lightMapColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
out vec2 texCoord0;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vertexColor = Color;
texCoord0 = UV0;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform mat4 ProjMat;

uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
color *= vertexColor * ColorModulator;
float fragmentDistance = -ProjMat[3].z / ((gl_FragCoord.z) * -2.0 + 1.0 -
ProjMat[2].z);
fragColor = linear_fog(color, fragmentDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
vec4 tmpvar_29;
tmpvar_29 = linear_fog ((tmpvar_28 * (vertexColor * ColorModulator)), (-
(ProjMat[3].z) / (((gl_FragCoord.z * -2.0) + 1.0) - ProjMat[2].z)), FogStart,
FogEnd, FogColor);
fragColor = tmpvar_29;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV1;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler1;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec4 overlayColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color) * texelFetch(Sampler2, UV2 / 16, 0);
overlayColor = texelFetch(Sampler1, UV1, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler1;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec4 overlayColor;
out vec2 texCoord0;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec4 overlayColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a < 0.1) {
discard;
}
[Link] = mix([Link], [Link], overlayColor.a);
color *= vertexColor * ColorModulator;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
in vec4 overlayColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

float tmpvar_21;
if ((shape_20 == 0)){
float tmpvar_22;
tmpvar_22 = length (pos_19);
tmpvar_21 = tmpvar_22;
}
else
{
float distXZ_23;
float tmpvar_24;
tmpvar_24 = length (pos_19.xz);
distXZ_23 = tmpvar_24;
float tmpvar_25;
tmpvar_25 = abs (pos_19.y);
float tmpvar_26;
tmpvar_26 = max (distXZ_23, tmpvar_25);
tmpvar_21 = tmpvar_26;
}
return tmpvar_21;
}
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = tmpvar_28;
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((tmpvar_28.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
vec3 tmpvar_30;
tmpvar_30 = mix ([Link], tmpvar_28.xyz, overlayColor.w);
color_27.xyz = tmpvar_30;
color_27 = (color_27 * (vertexColor * ColorModulator));
vec4 tmpvar_31;
tmpvar_31 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_31;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

uniform vec3 Light0_Direction;

uniform vec3 Light1_Direction;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = minecraft_mix_light(Light0_Direction, Light1_Direction, Normal,
Color) * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
in vec3 Normal;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
uniform vec3 Light0_Direction;
uniform vec3 Light1_Direction;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}
return smoothstep(fogEnd, fogStart, vertexDistance);
}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color;
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, clamp(texCoord0, 0.0, 1.0));
color *= vertexColor * ColorModulator;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec2 tmpvar_28;
tmpvar_28 = clamp (texCoord0, 0.0, 1.0);
vec4 tmpvar_29;
tmpvar_29 = texture (Sampler0, tmpvar_28);
vec4 tmpvar_30;
tmpvar_30 = linear_fog ((tmpvar_29 * (vertexColor * ColorModulator)),
vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_30;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in vec2 UV2;
in vec3 Normal;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;
out vec2 texCoord1;
out vec2 texCoord2;
void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
texCoord1 = UV1;
texCoord2 = UV2;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV1;
in vec2 UV2;
in vec3 Normal;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord1;
out vec2 texCoord2;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vertexColor = Color;
texCoord0 = UV0;
texCoord1 = UV1;
texCoord2 = UV2;
}

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;
in vec2 texCoord2;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a < vertexColor.a) {
discard;
}
fragColor = color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord1;
in vec2 texCoord2;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (Sampler0, texCoord0);
bool tmpvar_4;
tmpvar_4 = bool(0);
if ((tmpvar_3.w < vertexColor.w)){
tmpvar_4 = bool(1);
}
;
tmpvar_2 = tmpvar_4;
tmpvar_1 = tmpvar_4;
if ( tmpvar_1) {discard; };
fragColor = tmpvar_3;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
vertexDistance = fog_distance(Position, FogShape);
vertexColor = Color;
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
fragColor = color * ColorModulator * linear_fog_fade(vertexDistance, FogStart,
FogEnd);
}

New VGPU Shader output:

precision lowp image2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = (tmpvar_28 * vertexColor);
float tmpvar_29;
tmpvar_29 = linear_fog_fade (vertexDistance, FogStart, FogEnd);
fragColor = ((color_27 * ColorModulator) * tmpvar_29);
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;
void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color;
texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
out vec2 texCoord0;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}
float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,
vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = color * linear_fog_fade(vertexDistance, FogStart, FogEnd);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = ((tmpvar_28 * vertexColor) * ColorModulator);
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((color_27.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
float tmpvar_30;
tmpvar_30 = linear_fog_fade (vertexDistance, FogStart, FogEnd);
fragColor = (color_27 * tmpvar_30);
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in ivec2 UV2;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform vec4 ColorModulator;
uniform int FogShape;

out float vertexDistance;

flat out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color * ColorModulator * texelFetch(Sampler2, UV2 / 16, 0);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV2;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform vec4 ColorModulator;
uniform int FogShape;
out float vertexDistance;
flat out vec4 vertexColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform float FogStart;

uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
flat in vec4 vertexColor;

out vec4 fragColor;

void main() {
fragColor = linear_fog(vertexColor, vertexDistance, FogStart, FogEnd,
FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
flat in vec4 vertexColor;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = linear_fog (vertexColor, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_27;
}

VGPU Shader source:

#version 150

in vec3 Position;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
}

VGPU Shader source:

#version 150

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
fragColor = ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform vec4 ColorModulator;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
fragColor = ColorModulator;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0);
if (color.a == 0.0) {
discard;
}
fragColor = vec4([Link] * [Link], ColorModulator.a);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (Sampler0, texCoord0);
bool tmpvar_4;
tmpvar_4 = bool(0);
if ((tmpvar_3.w == 0.0)){
tmpvar_4 = bool(1);
}
;
tmpvar_2 = tmpvar_4;
tmpvar_1 = tmpvar_4;
if ( tmpvar_1) {discard; };
vec4 tmpvar_5;
tmpvar_5.xyz = ([Link] * [Link]);
tmpvar_5.w = ColorModulator.w;
fragColor = tmpvar_5;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec2 UV0;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;
out float vertexDistance;
out vec2 texCoord0;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform float GlintAlpha;

in float vertexDistance;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * ColorModulator;
if (color.a < 0.1) {
discard;
}
float fade = linear_fog_fade(vertexDistance, FogStart, FogEnd) * GlintAlpha;
fragColor = vec4([Link] * fade, color.a);
}

New VGPU Shader output:

precision lowp image2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform float GlintAlpha;
in float vertexDistance;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = (tmpvar_28 * ColorModulator);
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((color_27.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
float tmpvar_30;
tmpvar_30 = linear_fog_fade (vertexDistance, FogStart, FogEnd);
vec4 tmpvar_31;
tmpvar_31.xyz = (color_27.xyz * (tmpvar_30 * GlintAlpha));
tmpvar_31.w = color_27.w;
fragColor = tmpvar_31;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform float GlintAlpha;

in float vertexDistance;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}
return smoothstep(fogEnd, fogStart, vertexDistance);
}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform float GlintAlpha;

in float vertexDistance;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform float GlintAlpha;

in float vertexDistance;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform float GlintAlpha;

in float vertexDistance;
in vec2 texCoord0;

out vec4 fragColor;

New VGPU Shader output:

precision lowp image2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in ivec2 UV2;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);
}

New VGPU Shader output:

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV2;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
color_27 = (vertexColor * ColorModulator);
bool tmpvar_28;
tmpvar_28 = bool(0);
if ((color_27.w < 0.1)){
tmpvar_28 = bool(1);
}
;
tmpvar_2 = tmpvar_28;
tmpvar_1 = tmpvar_28;
if ( tmpvar_1) {discard; };
vec4 tmpvar_29;
tmpvar_29 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_29;
}

VGPU Shader source:

#version 150
#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color * texelFetch(Sampler2, UV2 / 16, 0);
texCoord0 = UV0;
}
New VGPU Shader output:
#version 320 es
#ifdef GL_OES_texture_storage_multisample_2d_array
#extension GL_OES_texture_storage_multisample_2d_array : enable
#endif
#ifdef GL_EXT_texture_buffer
#extension GL_EXT_texture_buffer : enable
#endif
#ifdef GL_EXT_texture_cube_map_array
#extension GL_EXT_texture_cube_map_array : enable
#endif
#ifdef GL_EXT_shader_non_constant_global_initializers
#extension GL_EXT_shader_non_constant_global_initializers : enable
#endif
precision highp float;
precision highp int;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0).rrrr * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = ((tmpvar_28.xxxx * vertexColor) * ColorModulator);
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((color_27.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
vec4 tmpvar_30;
tmpvar_30 = linear_fog (color_27, vertexDistance, FogStart, FogEnd, FogColor);
fragColor = tmpvar_30;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

uniform vec4 ColorModulator;

in vec4 vertexColor;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0).rrrr * vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_3;
vec4 tmpvar_4;
tmpvar_4 = texture (Sampler0, texCoord0);
color_3 = (tmpvar_4.xxxx * vertexColor);
bool tmpvar_5;
tmpvar_5 = bool(0);
if ((color_3.w < 0.1)){
tmpvar_5 = bool(1);
}
;
tmpvar_2 = tmpvar_5;
tmpvar_1 = tmpvar_5;
if ( tmpvar_1) {discard; };
fragColor = (color_3 * ColorModulator);
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}
float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){
bool tmpvar_16;
tmpvar_16 = bool(1);
float tmpvar_17;
if ((fogStart_14 >= vertexDistance_13)){
tmpvar_17 = 1.0;
tmpvar_16 = bool(0);
}
else
{
if ((vertexDistance_13 >= fogEnd_15)){
tmpvar_17 = 0.0;
tmpvar_16 = bool(0);
}
;
}
if (tmpvar_16){
float tmpvar_18;
tmpvar_18 = smoothstep (fogEnd_15, fogStart_14, vertexDistance_13);
tmpvar_17 = tmpvar_18;
tmpvar_16 = bool(0);
}
;
return tmpvar_17;
}

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;

in float vertexDistance;
in vec4 vertexColor;

out vec4 fragColor;

void main() {
fragColor = vertexColor * ColorModulator * linear_fog_fade(vertexDistance,
FogStart, FogEnd);
}
New VGPU Shader output:
#version 320 es
#ifdef GL_OES_texture_storage_multisample_2d_array
#extension GL_OES_texture_storage_multisample_2d_array : enable
#endif
#ifdef GL_EXT_texture_buffer
#extension GL_EXT_texture_buffer : enable
#endif
#ifdef GL_EXT_texture_cube_map_array
#extension GL_EXT_texture_cube_map_array : enable
#endif
#ifdef GL_EXT_shader_non_constant_global_initializers
#extension GL_EXT_shader_non_constant_global_initializers : enable
#endif
precision highp float;
precision highp int;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
in float vertexDistance;
in vec4 vertexColor;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
float tmpvar_27;
tmpvar_27 = linear_fog_fade (vertexDistance, FogStart, FogEnd);
fragColor = ((vertexColor * ColorModulator) * tmpvar_27);
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;
in vec3 Normal;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform vec3 ChunkOffset;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec2 texCoord0;

void main() {
vec3 pos = Position + ChunkOffset;
gl_Position = ProjMat * ModelViewMat * vec4(pos, 1.0);

vertexDistance = fog_distance(pos, FogShape);

vertexColor = Color * minecraft_sample_lightmap(Sampler2, UV2);
texCoord0 = UV0;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 projection_from_position(vec4 position) {

vec4 projection = position * 0.5;
[Link] = vec2(projection.x + projection.w, projection.y + projection.w);
[Link] = [Link];
return projection;
}
#line 3 0

in vec3 Position;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
out vec4 texProj0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

texProj0 = projection_from_position(gl_Position);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 texProj0;
vec4 projection_from_position(vec4 position_3){
vec4 projection_4;
projection_4 = (position_3 * 0.5);
vec2 tmpvar_5;
tmpvar_5.x = (projection_4.x + projection_4.w);
tmpvar_5.y = (projection_4.y + projection_4.w);
projection_4.xy = tmpvar_5;
projection_4.zw = position_3.zw;
return projection_4;
}

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_6;
tmpvar_6 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_7;
tmpvar_7 = ((((ProjMat[0] * tmpvar_6.x) + (ProjMat[1] * tmpvar_6.y)) +
(ProjMat[2] * tmpvar_6.z)) + (ProjMat[3] * tmpvar_6.w));
gl_Position = tmpvar_7;
vec4 tmpvar_8;
tmpvar_8 = projection_from_position (tmpvar_7);
texProj0 = tmpvar_8;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

mat2 mat2_rotate_z(float radians) {

return mat2(
cos(radians), -sin(radians),
sin(radians), cos(radians)
);
}
#line 3 0

uniform sampler2D Sampler0;

uniform sampler2D Sampler1;

uniform float GameTime;

uniform int EndPortalLayers;

in vec4 texProj0;

const vec3[] COLORS = vec3[](

vec3(0.022087, 0.098399, 0.110818),
vec3(0.011892, 0.095924, 0.089485),
vec3(0.027636, 0.101689, 0.100326),
vec3(0.046564, 0.109883, 0.114838),
vec3(0.064901, 0.117696, 0.097189),
vec3(0.063761, 0.086895, 0.123646),
vec3(0.084817, 0.111994, 0.166380),
vec3(0.097489, 0.154120, 0.091064),
vec3(0.106152, 0.131144, 0.195191),
vec3(0.097721, 0.110188, 0.187229),
vec3(0.133516, 0.138278, 0.148582),
vec3(0.070006, 0.243332, 0.235792),
vec3(0.196766, 0.142899, 0.214696),
vec3(0.047281, 0.315338, 0.321970),
vec3(0.204675, 0.390010, 0.302066),
vec3(0.080955, 0.314821, 0.661491)
);

const mat4 SCALE_TRANSLATE = mat4(

0.5, 0.0, 0.0, 0.25,
0.0, 0.5, 0.0, 0.25,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
);

mat4 end_portal_layer(float layer) {

mat4 translate = mat4(
1.0, 0.0, 0.0, 17.0 / layer,
0.0, 1.0, 0.0, (2.0 + layer / 1.5) * (GameTime * 1.5),
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
);

mat2 rotate = mat2_rotate_z(radians((layer * layer * 4321.0 + layer * 9.0) *

2.0));

mat2 scale = mat2((4.5 - layer / 4.0) * 2.0);

return mat4(scale * rotate) * translate * SCALE_TRANSLATE;

}

out vec4 fragColor;

void main() {
vec3 color = textureProj(Sampler0, texProj0).rgb * COLORS[0];
for (int i = 0; i < EndPortalLayers; i++) {
color += textureProj(Sampler1, texProj0 * end_portal_layer(float(i +
1))).rgb * COLORS[i];
}
fragColor = vec4(color, 1.0);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform sampler2D Sampler1;
uniform float GameTime;
uniform int EndPortalLayers;
in vec4 texProj0;
vec3 COLORS[16] = vec3[16](vec3(0.022087, 0.098399, 0.110818), vec3(0.011892,
0.095924, 0.089485), vec3(0.027636, 0.101689, 0.100326), vec3(0.046564, 0.109883,
0.114838), vec3(0.064901, 0.117696, 0.097189), vec3(0.063761, 0.086895, 0.123646),
vec3(0.084817, 0.111994, 0.16638), vec3(0.097489, 0.15412, 0.091064),
vec3(0.106152, 0.131144, 0.195191), vec3(0.097721, 0.110188, 0.187229),
vec3(0.133516, 0.138278, 0.148582), vec3(0.070006, 0.243332, 0.235792),
vec3(0.196766, 0.142899, 0.214696), vec3(0.047281, 0.315338, 0.32197),
vec3(0.204675, 0.39001, 0.302066), vec3(0.080955, 0.314821, 0.661491));
mat4 SCALE_TRANSLATE = mat4(0.5, 0.0, 0.0, 0.25, 0.0, 0.5, 0.0, 0.25, 0.0, 0.0,
1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
out vec4 fragColor;
mat2 mat2_rotate_z(float radians_3){
float tmpvar_4;
tmpvar_4 = cos (radians_3);
float tmpvar_5;
tmpvar_5 = sin (radians_3);
float tmpvar_6;
tmpvar_6 = sin (radians_3);
float tmpvar_7;
tmpvar_7 = cos (radians_3);
mat2 tmpvar_8;
tmpvar_8[uint(0)].x = tmpvar_4;
tmpvar_8[uint(0)].y = -(tmpvar_5);
tmpvar_8[1u].x = tmpvar_6;
tmpvar_8[1u].y = tmpvar_7;
return tmpvar_8;
}

mat4 end_portal_layer(float layer_9){

mat4 translate_10;
mat4 tmpvar_11;
tmpvar_11[uint(0)].x = 1.0;
tmpvar_11[uint(0)].y = 0.0;
tmpvar_11[uint(0)].z = 0.0;
tmpvar_11[uint(0)].w = (17.0 / layer_9);
tmpvar_11[1u].x = 0.0;
tmpvar_11[1u].y = 1.0;
tmpvar_11[1u].z = 0.0;
tmpvar_11[1u].w = ((2.0 + (layer_9 / 1.5)) * (GameTime * 1.5));
tmpvar_11[2u].x = 0.0;
tmpvar_11[2u].y = 0.0;
tmpvar_11[2u].z = 1.0;
tmpvar_11[2u].w = 0.0;
tmpvar_11[3u].x = 0.0;
tmpvar_11[3u].y = 0.0;
tmpvar_11[3u].z = 0.0;
tmpvar_11[3u].w = 1.0;
translate_10 = tmpvar_11;
float tmpvar_12;
tmpvar_12 = radians (((((layer_9 * layer_9) * 4321.0) + (layer_9 * 9.0)) * 2.0));
mat2 tmpvar_13;
tmpvar_13 = mat2_rotate_z (tmpvar_12);
mat2 tmpvar_14;
vec4 tmpvar_15;
tmpvar_15.yzw = vec3(0.0, 0.0, 0.0);
tmpvar_15.x = ((4.5 - (layer_9 / 4.0)) * 2.0);
tmpvar_14[uint(0)] = tmpvar_15.xy;
tmpvar_14[1u] = tmpvar_15.yx;
mat4 tmpvar_16;
tmpvar_16[uint(0)] = vec4(1.0, 0.0, 0.0, 0.0);
tmpvar_16[1u] = vec4(0.0, 1.0, 0.0, 0.0);
tmpvar_16[2u] = vec4(0.0, 0.0, 1.0, 0.0);
tmpvar_16[3u] = vec4(0.0, 0.0, 0.0, 1.0);
mat2 tmpvar_17;
tmpvar_17[0] = ((tmpvar_14[0] * tmpvar_13[0].x) + (tmpvar_14[1] *
tmpvar_13[0].y));
tmpvar_17[1] = ((tmpvar_14[0] * tmpvar_13[1].x) + (tmpvar_14[1] *
tmpvar_13[1].y));
tmpvar_16[uint(0)].xy = tmpvar_17[uint(0)];
tmpvar_16[1u].xy = tmpvar_17[1u];
mat4 tmpvar_18;
tmpvar_18[0] = ((((tmpvar_16[0] * translate_10[0].x) + (tmpvar_16[1] *
translate_10[0].y)) + (tmpvar_16[2] * translate_10[0].z)) + (tmpvar_16[3] *
translate_10[0].w));
tmpvar_18[1] = ((((tmpvar_16[0] * translate_10[1].x) + (tmpvar_16[1] *
translate_10[1].y)) + (tmpvar_16[2] * translate_10[1].z)) + (tmpvar_16[3] *
translate_10[1].w));
tmpvar_18[2] = ((((tmpvar_16[0] * translate_10[2].x) + (tmpvar_16[1] *
translate_10[2].y)) + (tmpvar_16[2] * translate_10[2].z)) + (tmpvar_16[3] *
translate_10[2].w));
tmpvar_18[3] = ((((tmpvar_16[0] * translate_10[3].x) + (tmpvar_16[1] *
translate_10[3].y)) + (tmpvar_16[2] * translate_10[3].z)) + (tmpvar_16[3] *
translate_10[3].w));
mat4 tmpvar_19;
tmpvar_19[0] = ((((tmpvar_18[0] * 0.5) + (tmpvar_18[1] * 0.0)) + (tmpvar_18[2] *
0.0)) + (tmpvar_18[3] * 0.25));
tmpvar_19[1] = ((((tmpvar_18[0] * 0.0) + (tmpvar_18[1] * 0.5)) + (tmpvar_18[2] *
0.0)) + (tmpvar_18[3] * 0.25));
tmpvar_19[2] = ((((tmpvar_18[0] * 0.0) + (tmpvar_18[1] * 0.0)) + (tmpvar_18[2] *
1.0)) + (tmpvar_18[3] * 0.0));
tmpvar_19[3] = ((((tmpvar_18[0] * 0.0) + (tmpvar_18[1] * 0.0)) + (tmpvar_18[2] *
0.0)) + (tmpvar_18[3] * 1.0));
return tmpvar_19;
}

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
COLORS = vec3[16](vec3(0.022087, 0.098399, 0.110818), vec3(0.011892, 0.095924,
0.089485), vec3(0.027636, 0.101689, 0.100326), vec3(0.046564, 0.109883, 0.114838),
vec3(0.064901, 0.117696, 0.097189), vec3(0.063761, 0.086895, 0.123646),
vec3(0.084817, 0.111994, 0.16638), vec3(0.097489, 0.15412, 0.091064),
vec3(0.106152, 0.131144, 0.195191), vec3(0.097721, 0.110188, 0.187229),
vec3(0.133516, 0.138278, 0.148582), vec3(0.070006, 0.243332, 0.235792),
vec3(0.196766, 0.142899, 0.214696), vec3(0.047281, 0.315338, 0.32197),
vec3(0.204675, 0.39001, 0.302066), vec3(0.080955, 0.314821, 0.661491));
SCALE_TRANSLATE = mat4(0.5, 0.0, 0.0, 0.25, 0.0, 0.5, 0.0, 0.25, 0.0, 0.0, 1.0,
0.0, 0.0, 0.0, 0.0, 1.0);
int i_20;
vec3 color_21;
vec4 tmpvar_22;
tmpvar_22 = textureProj (Sampler0, texProj0);
color_21 = (tmpvar_22.xyz * COLORS[0]);
i_20 = 0;
while (true){
if (!((i_20 < EndPortalLayers))){
break;
}
;
mat4 tmpvar_23;
tmpvar_23 = end_portal_layer (float((i_20 + 1)));
vec4 tmpvar_24;
vec4 tmpvar_25;
tmpvar_25.x = dot (texProj0, tmpvar_23[0]);
tmpvar_25.y = dot (texProj0, tmpvar_23[1]);
tmpvar_25.z = dot (texProj0, tmpvar_23[2]);
tmpvar_25.w = dot (texProj0, tmpvar_23[3]);
tmpvar_24 = textureProj (Sampler1, tmpvar_25);
color_21 = (color_21 + (tmpvar_24.xyz * COLORS[i_20]));
i_20++;
if (tmpvar_2){
break;
}
;
if (tmpvar_1){
break;
}
;
}
;
vec4 tmpvar_26;
tmpvar_26.w = 1.0;
tmpvar_26.xyz = color_21;
fragColor = tmpvar_26;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec2 UV0;
in vec4 Color;
in vec3 Normal;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform int FogShape;

out vec2 texCoord0;

out float vertexDistance;
out vec4 vertexColor;

void main() {
vec4 pos = ModelViewMat * vec4(Position, 1.0);
gl_Position = ProjMat * pos;

texCoord0 = UV0;
vertexDistance = fog_distance([Link], FogShape);
vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_28;
gl_Position = ((((ProjMat[0] * tmpvar_27.x) + (ProjMat[1] * tmpvar_27.y)) +
(ProjMat[2] * tmpvar_27.z)) + (ProjMat[3] * tmpvar_27.w));
texCoord0 = UV0;
float tmpvar_29;
tmpvar_29 = fog_distance (tmpvar_27.xyz, FogShape);
vertexDistance = tmpvar_29;
vertexColor = Color;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in vec2 texCoord0;
in float vertexDistance;
in vec4 vertexColor;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in vec2 texCoord0;
in float vertexDistance;
in vec4 vertexColor;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}
float fog_distance(vec3 pos, int shape) {
if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

in vec3 Position;
in vec4 Color;
in vec3 Normal;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform float LineWidth;
uniform vec2 ScreenSize;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;

const float VIEW_SHRINK = 1.0 - (1.0 / 256.0);

const mat4 VIEW_SCALE = mat4(
VIEW_SHRINK, 0.0, 0.0, 0.0,
0.0, VIEW_SHRINK, 0.0, 0.0,
0.0, 0.0, VIEW_SHRINK, 0.0,
0.0, 0.0, 0.0, 1.0
);

void main() {
vec4 linePosStart = ProjMat * VIEW_SCALE * ModelViewMat * vec4(Position, 1.0);
vec4 linePosEnd = ProjMat * VIEW_SCALE * ModelViewMat * vec4(Position + Normal,
1.0);

vec3 ndc1 = [Link] / linePosStart.w;

vec3 ndc2 = [Link] / linePosEnd.w;

vec2 lineScreenDirection = normalize(([Link] - [Link]) * ScreenSize);

vec2 lineOffset = vec2(-lineScreenDirection.y, lineScreenDirection.x) *
LineWidth / ScreenSize;

if (lineOffset.x < 0.0) {

lineOffset *= -1.0;
}

if (gl_VertexID % 2 == 0) {
gl_Position = vec4((ndc1 + vec3(lineOffset, 0.0)) * linePosStart.w,
linePosStart.w);
} else {
gl_Position = vec4((ndc1 - vec3(lineOffset, 0.0)) * linePosStart.w,
linePosStart.w);
}

vertexDistance = fog_distance(Position, FogShape);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec3 Normal;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform float LineWidth;
uniform vec2 ScreenSize;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
float VIEW_SHRINK = 0.9960938;
mat4 VIEW_SCALE = mat4(0.9960938, 0.0, 0.0, 0.0, 0.0, 0.9960938, 0.0, 0.0, 0.0,
0.0, 0.9960938, 0.0, 0.0, 0.0, 0.0, 1.0);
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
VIEW_SHRINK = 0.9960938;
VIEW_SCALE = mat4(0.9960938, 0.0, 0.0, 0.0, 0.0, 0.9960938, 0.0, 0.0, 0.0, 0.0,
0.9960938, 0.0, 0.0, 0.0, 0.0, 1.0);
vec2 lineOffset_27;
vec3 ndc1_28;
vec4 linePosStart_29;
mat4 tmpvar_30;
tmpvar_30[0] = ((((ProjMat[0] * 0.9960938) + (ProjMat[1] * 0.0)) + (ProjMat[2] *
0.0)) + (ProjMat[3] * 0.0));
tmpvar_30[1] = ((((ProjMat[0] * 0.0) + (ProjMat[1] * 0.9960938)) + (ProjMat[2] *
0.0)) + (ProjMat[3] * 0.0));
tmpvar_30[2] = ((((ProjMat[0] * 0.0) + (ProjMat[1] * 0.0)) + (ProjMat[2] *
0.9960938)) + (ProjMat[3] * 0.0));
tmpvar_30[3] = ((((ProjMat[0] * 0.0) + (ProjMat[1] * 0.0)) + (ProjMat[2] * 0.0))
+ (ProjMat[3] * 1.0));
vec4 tmpvar_31;
tmpvar_31 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_32;
tmpvar_32 = ((((tmpvar_30[0] * tmpvar_31.x) + (tmpvar_30[1] * tmpvar_31.y)) +
(tmpvar_30[2] * tmpvar_31.z)) + (tmpvar_30[3] * tmpvar_31.w));
linePosStart_29 = tmpvar_32;
vec4 tmpvar_33;
tmpvar_33.w = 1.0;
tmpvar_33.xyz = (Position + Normal);
mat4 tmpvar_34;
tmpvar_34[0] = ((((ProjMat[0] * 0.9960938) + (ProjMat[1] * 0.0)) + (ProjMat[2] *
0.0)) + (ProjMat[3] * 0.0));
tmpvar_34[1] = ((((ProjMat[0] * 0.0) + (ProjMat[1] * 0.9960938)) + (ProjMat[2] *
0.0)) + (ProjMat[3] * 0.0));
tmpvar_34[2] = ((((ProjMat[0] * 0.0) + (ProjMat[1] * 0.0)) + (ProjMat[2] *
0.9960938)) + (ProjMat[3] * 0.0));
tmpvar_34[3] = ((((ProjMat[0] * 0.0) + (ProjMat[1] * 0.0)) + (ProjMat[2] * 0.0))
+ (ProjMat[3] * 1.0));
vec4 tmpvar_35;
tmpvar_35 = ((((ModelViewMat[0] * tmpvar_33.x) + (ModelViewMat[1] * tmpvar_33.y))
+ (ModelViewMat[2] * tmpvar_33.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_36;
tmpvar_36 = ((((tmpvar_34[0] * tmpvar_35.x) + (tmpvar_34[1] * tmpvar_35.y)) +
(tmpvar_34[2] * tmpvar_35.z)) + (tmpvar_34[3] * tmpvar_35.w));
ndc1_28 = (tmpvar_32.xyz / tmpvar_32.w);
vec2 tmpvar_37;
tmpvar_37 = normalize ((((tmpvar_36.xyz / tmpvar_36.w).xy - ndc1_28.xy) *
ScreenSize));
vec2 tmpvar_38;
tmpvar_38.x = -(tmpvar_37.y);
tmpvar_38.y = tmpvar_37.x;
lineOffset_27 = ((tmpvar_38 * LineWidth) / ScreenSize);
if ((lineOffset_27.x < 0.0)){
lineOffset_27 = (lineOffset_27 * -1.0);
}
;
if (((int(mod (float(gl_VertexID), float(2)))) == 0)){
vec3 tmpvar_39;
tmpvar_39.z = 0.0;
tmpvar_39.xy = lineOffset_27;
vec4 tmpvar_40;
tmpvar_40.xyz = ((ndc1_28 + tmpvar_39) * linePosStart_29.w);
tmpvar_40.w = linePosStart_29.w;
gl_Position = tmpvar_40;
}
else
{
vec3 tmpvar_41;
tmpvar_41.z = 0.0;
tmpvar_41.xy = lineOffset_27;
vec4 tmpvar_42;
tmpvar_42.xyz = ((ndc1_28 - tmpvar_41) * linePosStart_29.w);
tmpvar_42.w = linePosStart_29.w;
gl_Position = tmpvar_42;
}
float tmpvar_43;
tmpvar_43 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_43;
vertexColor = Color;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;

in float vertexDistance;
in vec4 vertexColor;

out vec4 fragColor;

void main() {
vec4 color = vertexColor * ColorModulator;
fragColor = linear_fog(color, vertexDistance, FogStart, FogEnd, FogColor);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
uniform vec4 FogColor;
in float vertexDistance;
in vec4 vertexColor;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_27;
tmpvar_27 = linear_fog ((vertexColor * ColorModulator), vertexDistance, FogStart,
FogEnd, FogColor);
fragColor = tmpvar_27;
}

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
in vec3 Normal;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

out vec2 texCoord0;
out vec2 texCoord2;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
texCoord0 = UV0;
texCoord2 = UV2;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
in vec3 Normal;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
out vec4 vertexColor;
out vec2 texCoord0;
out vec2 texCoord2;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_4;
gl_Position = ((((ProjMat[0] * tmpvar_3.x) + (ProjMat[1] * tmpvar_3.y)) +
(ProjMat[2] * tmpvar_3.z)) + (ProjMat[3] * tmpvar_3.w));
vertexColor = Color;
texCoord0 = UV0;
texCoord2 = UV2;
}

VGPU Shader source:

#version 150

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

in vec4 vertexColor;
in vec2 texCoord0;
in vec2 texCoord2;
out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor;
if (color.a < 0.1) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec4 vertexColor;
uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

VGPU Shader source:

#version 150

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec3 Position;
in vec4 Color;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;

out vec4 vertexColor;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexColor = Color;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

in vec4 vertexColor;

uniform vec4 ColorModulator;

out vec4 fragColor;

void main() {
vec4 color = vertexColor;
if (color.a == 0.0) {
discard;
}
fragColor = color * ColorModulator;
}
New VGPU Shader output:
#version 320 es
#ifdef GL_OES_texture_storage_multisample_2d_array
#extension GL_OES_texture_storage_multisample_2d_array : enable
#endif
#ifdef GL_EXT_texture_buffer
#extension GL_EXT_texture_buffer : enable
#endif
#ifdef GL_EXT_texture_cube_map_array
#extension GL_EXT_texture_cube_map_array : enable
#endif
#ifdef GL_EXT_shader_non_constant_global_initializers
#extension GL_EXT_shader_non_constant_global_initializers : enable
#endif
precision highp float;
precision highp int;

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

#define MINECRAFT_LIGHT_POWER (0.6)

#define MINECRAFT_AMBIENT_LIGHT (0.4)

vec4 minecraft_mix_light(vec3 lightDir0, vec3 lightDir1, vec3 normal, vec4 color) {

vec4 minecraft_sample_lightmap(sampler2D lightMap, ivec2 uv) {

return texture(lightMap, clamp(uv / 256.0, vec2(0.5 / 16.0), vec2(15.5 /
16.0)));
}
#line 0 2
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 4 0

in vec3 Position;
in vec4 Color;
in vec2 UV0;
in ivec2 UV2;

uniform sampler2D Sampler0;

uniform sampler2D Sampler2;

uniform mat4 ModelViewMat;

uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;

out float vertexDistance;

out vec4 vertexColor;
out vec4 lightMapColor;
out vec2 texCoord0;

void main() {
gl_Position = ProjMat * ModelViewMat * vec4(Position, 1.0);

vertexDistance = fog_distance(Position, FogShape);

lightMapColor = texelFetch(Sampler2, UV2 / 16, 0);
vertexColor = Color * lightMapColor;

texCoord0 = (TextureMat * vec4(UV0, 0.0, 1.0)).xy;

}

New VGPU Shader output:

precision lowp image2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec3 Position;
in vec4 Color;
in vec2 UV0;
in vec2 UV2;
uniform sampler2D Sampler0;
uniform sampler2D Sampler2;
uniform mat4 ModelViewMat;
uniform mat4 ProjMat;
uniform mat4 TextureMat;
uniform int FogShape;
out float vertexDistance;
out vec4 vertexColor;
out vec4 lightMapColor;
out vec2 texCoord0;
vec4 minecraft_mix_light(vec3 lightDir0_3, vec3 lightDir1_4, vec3 normal_5, vec4
color_6){
float light0_7;
float tmpvar_8;
tmpvar_8 = dot (lightDir0_3, normal_5);
float tmpvar_9;
tmpvar_9 = max (0.0, tmpvar_8);
light0_7 = tmpvar_9;
float tmpvar_10;
tmpvar_10 = dot (lightDir1_4, normal_5);
float tmpvar_11;
tmpvar_11 = max (0.0, tmpvar_10);
float tmpvar_12;
tmpvar_12 = min (1.0, (((light0_7 + tmpvar_11) * 0.6) + 0.4));
vec4 tmpvar_13;
tmpvar_13.xyz = (color_6.xyz * tmpvar_12);
tmpvar_13.w = color_6.w;
return tmpvar_13;
}

vec4 minecraft_sample_lightmap(sampler2D lightMap_14, ivec2 uv_15){

vec2 tmpvar_16;
tmpvar_16 = clamp ((vec2(uv_15) / 256.0), vec2(0.03125, 0.03125), vec2(0.96875,
0.96875));
vec4 tmpvar_17;
tmpvar_17 = texture (lightMap_14, tmpvar_16);
return tmpvar_17;
}

vec4 linear_fog(vec4 inColor_18, float vertexDistance_19, float fogStart_20, float

float linear_fog_fade(float vertexDistance_28, float fogStart_29, float fogEnd_30){

float fog_distance(vec3 pos_34, int shape_35){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_42;
tmpvar_42 = ((((ModelViewMat[0] * Position.x) + (ModelViewMat[1] * Position.y)) +
(ModelViewMat[2] * Position.z)) + (ModelViewMat[3] * 1.0));
vec4 tmpvar_43;
gl_Position = ((((ProjMat[0] * tmpvar_42.x) + (ProjMat[1] * tmpvar_42.y)) +
(ProjMat[2] * tmpvar_42.z)) + (ProjMat[3] * tmpvar_42.w));
float tmpvar_44;
tmpvar_44 = fog_distance (Position, FogShape);
vertexDistance = tmpvar_44;
vec4 tmpvar_45;
tmpvar_45 = texelFetch (Sampler2, (ivec2(UV2) / 16), 0);
lightMapColor = tmpvar_45;
vertexColor = (Color * tmpvar_45);
vec4 tmpvar_46;
texCoord0 = ((((TextureMat[0] * UV0.x) + (TextureMat[1] * UV0.y)) +
(TextureMat[2] * 0.0)) + (TextureMat[3] * 1.0)).xy;
}

VGPU Shader source:

#version 150

#line 0 1
/*#version 150*/

vec4 linear_fog(vec4 inColor, float vertexDistance, float fogStart, float fogEnd,

vec4 fogColor) {
if (vertexDistance <= fogStart) {
return inColor;
}

float fogValue = vertexDistance < fogEnd ? smoothstep(fogStart, fogEnd,

vertexDistance) : 1.0;
return vec4(mix([Link], [Link], fogValue * fogColor.a), inColor.a);
}

float linear_fog_fade(float vertexDistance, float fogStart, float fogEnd) {

if (vertexDistance <= fogStart) {
return 1.0;
} else if (vertexDistance >= fogEnd) {
return 0.0;
}

return smoothstep(fogEnd, fogStart, vertexDistance);

}

float fog_distance(vec3 pos, int shape) {

if (shape == 0) {
return length(pos);
} else {
float distXZ = length([Link]);
float distY = abs(pos.y);
return max(distXZ, distY);
}
}
#line 3 0

uniform sampler2D Sampler0;

uniform vec4 ColorModulator;

uniform float FogStart;
uniform float FogEnd;

in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;

out vec4 fragColor;

void main() {
vec4 color = texture(Sampler0, texCoord0) * vertexColor * ColorModulator;
if (color.a < 0.1) {
discard;
}
fragColor = color * linear_fog_fade(vertexDistance, FogStart, FogEnd);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D Sampler0;
uniform vec4 ColorModulator;
uniform float FogStart;
uniform float FogEnd;
in float vertexDistance;
in vec4 vertexColor;
in vec2 texCoord0;
out vec4 fragColor;
vec4 linear_fog(vec4 inColor_3, float vertexDistance_4, float fogStart_5, float
fogEnd_6, vec4 fogColor_7){
vec4 tmpvar_8;
if ((fogStart_5 >= vertexDistance_4)){
tmpvar_8 = inColor_3;
}
else
{
float tmpvar_9;
if ((vertexDistance_4 < fogEnd_6)){
float tmpvar_10;
tmpvar_10 = smoothstep (fogStart_5, fogEnd_6, vertexDistance_4);
tmpvar_9 = tmpvar_10;
}
else
{
tmpvar_9 = 1.0;
}
vec3 tmpvar_11;
tmpvar_11 = mix (inColor_3.xyz, fogColor_7.xyz, (tmpvar_9 * fogColor_7.w));
vec4 tmpvar_12;
tmpvar_12.xyz = tmpvar_11;
tmpvar_12.w = inColor_3.w;
tmpvar_8 = tmpvar_12;
}
return tmpvar_8;
}

float linear_fog_fade(float vertexDistance_13, float fogStart_14, float fogEnd_15){

float fog_distance(vec3 pos_19, int shape_20){

void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 color_27;
vec4 tmpvar_28;
tmpvar_28 = texture (Sampler0, texCoord0);
color_27 = ((tmpvar_28 * vertexColor) * ColorModulator);
bool tmpvar_29;
tmpvar_29 = bool(0);
if ((color_27.w < 0.1)){
tmpvar_29 = bool(1);
}
;
tmpvar_2 = tmpvar_29;
tmpvar_1 = tmpvar_29;
if ( tmpvar_1) {discard; };
float tmpvar_30;
tmpvar_30 = linear_fog_fade (vertexDistance, FogStart, FogEnd);
fragColor = (color_27 * tmpvar_30);
}

VGPU Shader source:

#version 150

in vec4 Position;

uniform mat4 ProjMat;

uniform vec2 InSize;
uniform vec2 OutSize;
uniform vec2 BlurDir;

out vec2 texCoord;

out vec2 sampleStep;

void main() {
vec4 outPos = ProjMat * vec4([Link], 0.0, 1.0);
gl_Position = vec4([Link], 0.2, 1.0);

vec2 oneTexel = 1.0 / InSize;

sampleStep = oneTexel * BlurDir;

texCoord = [Link] / OutSize;

}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec4 Position;
uniform mat4 ProjMat;
uniform vec2 InSize;
uniform vec2 OutSize;
uniform vec2 BlurDir;
out vec2 texCoord;
out vec2 sampleStep;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3.zw = vec2(0.2, 1.0);
vec4 tmpvar_4;
tmpvar_3.xy = ((((ProjMat[0] * Position.x) + (ProjMat[1] * Position.y)) +
(ProjMat[2] * 0.0)) + (ProjMat[3] * 1.0)).xy;
gl_Position = tmpvar_3;
sampleStep = ((1.0 / InSize) * BlurDir);
texCoord = ([Link] / OutSize);
}

VGPU Shader source:

#version 150

uniform sampler2D DiffuseSampler;

in vec2 texCoord;
in vec2 sampleStep;

uniform float Radius;

uniform float RadiusMultiplier;

out vec4 fragColor;

// This shader relies on GL_LINEAR sampling to reduce the amount of texture samples
in half.
// Instead of sampling each pixel position with a step of 1 we sample between
pixels with a step of 2.
// In the end we sample the last pixel with a half weight, since the amount of
pixels to sample is always odd (actualRadius * 2 + 1).
void main() {
vec4 blurred = vec4(0.0);
float actualRadius = round(Radius * RadiusMultiplier);
for (float a = -actualRadius + 0.5; a <= actualRadius; a += 2.0) {
blurred += texture(DiffuseSampler, texCoord + sampleStep * a);
}
blurred += texture(DiffuseSampler, texCoord + sampleStep * actualRadius) / 2.0;
fragColor = blurred / (actualRadius + 0.5);
}

New VGPU Shader output:

precision lowp image2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D DiffuseSampler;
in vec2 texCoord;
in vec2 sampleStep;
uniform float Radius;
uniform float RadiusMultiplier;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
float a_3;
float actualRadius_4;
vec4 blurred_5;
blurred_5 = vec4(0.0, 0.0, 0.0, 0.0);
float tmpvar_6;
tmpvar_6 = round ((Radius * RadiusMultiplier));
actualRadius_4 = tmpvar_6;
a_3 = (-(tmpvar_6) + 0.5);
while (true){
if (!((actualRadius_4 >= a_3))){
break;
}
;
vec4 tmpvar_7;
tmpvar_7 = texture (DiffuseSampler, (texCoord + (sampleStep * a_3)));
blurred_5 = (blurred_5 + tmpvar_7);
a_3 += 2.0;
if (tmpvar_2){
break;
}
;
if (tmpvar_1){
break;
}
;
}
;
vec4 tmpvar_8;
tmpvar_8 = texture (DiffuseSampler, (texCoord + (sampleStep * actualRadius_4)));
blurred_5 = (blurred_5 + (tmpvar_8 / 2.0));
fragColor = (blurred_5 / (actualRadius_4 + 0.5));
}

VGPU Shader source:

#version 150

in vec4 Position;

uniform mat4 ProjMat;

uniform vec2 InSize;
uniform vec2 OutSize;

out vec2 texCoord;

out vec2 oneTexel;

void main(){
vec4 outPos = ProjMat * vec4([Link], 0.0, 1.0);
gl_Position = vec4([Link], 0.2, 1.0);

oneTexel = 1.0 / InSize;

texCoord = [Link] / OutSize;

}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec4 Position;
uniform mat4 ProjMat;
uniform vec2 InSize;
uniform vec2 OutSize;
out vec2 texCoord;
out vec2 oneTexel;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3.zw = vec2(0.2, 1.0);
vec4 tmpvar_4;
tmpvar_3.xy = ((((ProjMat[0] * Position.x) + (ProjMat[1] * Position.y)) +
(ProjMat[2] * 0.0)) + (ProjMat[3] * 1.0)).xy;
gl_Position = tmpvar_3;
oneTexel = (1.0 / InSize);
texCoord = ([Link] / OutSize);
}

VGPU Shader source:

#version 150

uniform sampler2D DiffuseSampler;

in vec2 texCoord;
in vec2 oneTexel;

out vec4 fragColor;

void main(){
vec4 center = texture(DiffuseSampler, texCoord);
vec4 left = texture(DiffuseSampler, texCoord - vec2(oneTexel.x, 0.0));
vec4 right = texture(DiffuseSampler, texCoord + vec2(oneTexel.x, 0.0));
vec4 up = texture(DiffuseSampler, texCoord - vec2(0.0, oneTexel.y));
vec4 down = texture(DiffuseSampler, texCoord + vec2(0.0, oneTexel.y));
float leftDiff = abs(center.a - left.a);
float rightDiff = abs(center.a - right.a);
float upDiff = abs(center.a - up.a);
float downDiff = abs(center.a - down.a);
float total = clamp(leftDiff + rightDiff + upDiff + downDiff, 0.0, 1.0);
vec3 outColor = [Link] * center.a + [Link] * left.a + [Link] * right.a
+ [Link] * up.a + [Link] * down.a;
fragColor = vec4(outColor * 0.2, total);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

precision lowp sampler3D;
precision lowp sampler2DShadow;
precision lowp samplerCubeShadow;
precision lowp sampler2DArray;
precision lowp sampler2DArrayShadow;
precision lowp samplerCube;
#ifdef GL_EXT_texture_buffer
precision lowp samplerBuffer;
precision lowp imageBuffer;
#endif
#ifdef GL_EXT_texture_cube_map_array
precision lowp imageCubeArray;
precision lowp samplerCubeArray;
precision lowp samplerCubeArrayShadow;
#endif
#ifdef GL_OES_texture_storage_multisample_2d_array
precision lowp sampler2DMS;
precision lowp sampler2DMSArray;
#endif
//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D DiffuseSampler;
in vec2 texCoord;
in vec2 oneTexel;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
float upDiff_3;
float rightDiff_4;
float leftDiff_5;
vec4 down_6;
vec4 up_7;
vec4 right_8;
vec4 left_9;
vec4 center_10;
vec4 tmpvar_11;
tmpvar_11 = texture (DiffuseSampler, texCoord);
center_10 = tmpvar_11;
vec2 tmpvar_12;
tmpvar_12.y = 0.0;
tmpvar_12.x = oneTexel.x;
vec4 tmpvar_13;
tmpvar_13 = texture (DiffuseSampler, (texCoord - tmpvar_12));
left_9 = tmpvar_13;
vec2 tmpvar_14;
tmpvar_14.y = 0.0;
tmpvar_14.x = oneTexel.x;
vec4 tmpvar_15;
tmpvar_15 = texture (DiffuseSampler, (texCoord + tmpvar_14));
right_8 = tmpvar_15;
vec2 tmpvar_16;
tmpvar_16.x = 0.0;
tmpvar_16.y = oneTexel.y;
vec4 tmpvar_17;
tmpvar_17 = texture (DiffuseSampler, (texCoord - tmpvar_16));
up_7 = tmpvar_17;
vec2 tmpvar_18;
tmpvar_18.x = 0.0;
tmpvar_18.y = oneTexel.y;
vec4 tmpvar_19;
tmpvar_19 = texture (DiffuseSampler, (texCoord + tmpvar_18));
down_6 = tmpvar_19;
float tmpvar_20;
tmpvar_20 = abs ((center_10.w - left_9.w));
leftDiff_5 = tmpvar_20;
float tmpvar_21;
tmpvar_21 = abs ((center_10.w - right_8.w));
rightDiff_4 = tmpvar_21;
float tmpvar_22;
tmpvar_22 = abs ((center_10.w - up_7.w));
upDiff_3 = tmpvar_22;
float tmpvar_23;
tmpvar_23 = abs ((center_10.w - down_6.w));
float tmpvar_24;
tmpvar_24 = clamp (((leftDiff_5 + rightDiff_4) + (upDiff_3 + tmpvar_23)), 0.0,
1.0);
vec4 tmpvar_25;
tmpvar_25.xyz = ((((((center_10.xyz * center_10.w) + (left_9.xyz * left_9.w)) +
(right_8.xyz * right_8.w)) + (up_7.xyz * up_7.w)) + (down_6.xyz * down_6.w)) *
0.2);
tmpvar_25.w = tmpvar_24;
fragColor = tmpvar_25;
}

VGPU Shader source:

#version 150

uniform sampler2D DiffuseSampler;

in vec2 texCoord;
in vec2 sampleStep;

out vec4 fragColor;

void main() {
vec4 blurred = vec4(0.0);
float radius = 2.0;
for (float a = -radius + 0.5; a <= radius; a += 2.0) {
blurred += texture(DiffuseSampler, texCoord + sampleStep * a);
}
blurred += texture(DiffuseSampler, texCoord + sampleStep * radius) / 2.0;
fragColor = vec4((blurred / (radius + 0.5)).rgb, blurred.a);
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D DiffuseSampler;
in vec2 texCoord;
in vec2 sampleStep;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
float a_3;
vec4 blurred_4;
blurred_4 = vec4(0.0, 0.0, 0.0, 0.0);
a_3 = -1.5;
while (true){
if (!((2.0 >= a_3))){
break;
}
;
vec4 tmpvar_5;
tmpvar_5 = texture (DiffuseSampler, (texCoord + (sampleStep * a_3)));
blurred_4 = (blurred_4 + tmpvar_5);
a_3 += 2.0;
if (tmpvar_2){
break;
}
;
if (tmpvar_1){
break;
}
;
}
;
vec4 tmpvar_6;
tmpvar_6 = texture (DiffuseSampler, (texCoord + (sampleStep * 2.0)));
blurred_4 = (blurred_4 + (tmpvar_6 / 2.0));
vec4 tmpvar_7;
tmpvar_7.xyz = (blurred_4 / 2.5).xyz;
tmpvar_7.w = blurred_4.w;
fragColor = tmpvar_7;
}
VGPU Shader source:
#version 150

in vec4 Position;

uniform mat4 ProjMat;

uniform vec2 OutSize;

out vec2 texCoord;

void main(){
vec4 outPos = ProjMat * vec4([Link], 0.0, 1.0);
gl_Position = vec4([Link], 0.2, 1.0);

texCoord = [Link] / OutSize;

}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
in vec4 Position;
uniform mat4 ProjMat;
uniform vec2 OutSize;
out vec2 texCoord;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3.zw = vec2(0.2, 1.0);
vec4 tmpvar_4;
tmpvar_3.xy = ((((ProjMat[0] * Position.x) + (ProjMat[1] * Position.y)) +
(ProjMat[2] * 0.0)) + (ProjMat[3] * 1.0)).xy;
gl_Position = tmpvar_3;
texCoord = ([Link] / OutSize);
}

VGPU Shader source:

#version 150

uniform sampler2D DiffuseSampler;

uniform vec4 ColorModulate;

in vec2 texCoord;

out vec4 fragColor;

void main(){
fragColor = texture(DiffuseSampler, texCoord) * ColorModulate;
}

New VGPU Shader output:

precision lowp image2D;

precision lowp image2DArray;
precision lowp image3D;
precision lowp imageCube;

precision lowp sampler2D;

//
bool tmpvar_1;
bool tmpvar_2;
uniform sampler2D DiffuseSampler;
uniform vec4 ColorModulate;
in vec2 texCoord;
out vec4 fragColor;
void main(){
tmpvar_1 = bool(0);
tmpvar_2 = bool(0);
vec4 tmpvar_3;
tmpvar_3 = texture (DiffuseSampler, texCoord);
fragColor = (tmpvar_3 * ColorModulate);
}

[Link] [IO-Worker-1/ERROR]: Couldn't connect to realms

fdj: Realms service error (500) with message 'Could not connect to Realms:
[Link]'
at fby.a(SourceFile:456) ~[[Link]:?]
at fby.g(SourceFile:232) ~[[Link]:?]
at fbs.c(SourceFile:51) ~[[Link]:?]
at
[Link]/[Link]$[Link](CompletableFuture.
java:1768) ~[?:?]
at
[Link]/[Link]([Link]
:1144) ~[?:?]
at
[Link]/[Link]$[Link]([Link]
a:642) ~[?:?]
at [Link]/[Link]([Link]) [?:?]
[Link] [Render thread/INFO]: Deleting level oldd
[Link] [Render thread/INFO]: Attempt 1...
[Link] [Render thread/INFO]: Loaded 1290 recipes
[Link] [Render thread/INFO]: Loaded 1399 advancements
[Link] [Render thread/INFO]: Loaded 1290 recipes
[Link] [Render thread/INFO]: Loaded 1399 advancements
[Link] [Sound engine/ERROR]: Stop: Invalid name parameter.
[Link] [Server thread/INFO]: Starting integrated minecraft server version 1.21
[Link] [Server thread/INFO]: Generating keypair
[Link] [Yggdrasil Key Fetcher/ERROR]: Failed to request yggdrasil public key
[Link]: Failed to read from
[Link] due to [Link]
at
[Link](MinecraftClient
.java:108) ~[[Link]:?]
at
[Link]([Link])
~[[Link]:?]
at
[Link](YggdrasilServicesKeyInf
[Link]) ~[[Link]:?]
at
[Link]$[Link](YggdrasilServicesKeyInf
[Link]) ~[[Link]:?]
at
[Link]/[Link]$[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at
[Link]/[Link]$[Link](
[Link]) ~[?:?]
at
[Link]/[Link]([Link]
:1144) ~[?:?]
at
[Link]/[Link]$[Link]([Link]
a:642) ~[?:?]
at [Link]/[Link]([Link]) [?:?]
Caused by: [Link]: [Link]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link]) ~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link].<init>([Link])
~[?:?]
at [Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link]
lient([Link]) ~[?:?]
at
[Link]/[Link].plainConnect0(HttpURLConnecti
[Link]) ~[?:?]
at
[Link]/[Link](HttpURLConnectio
[Link]) ~[?:?]
at
[Link]/[Link](Abs
[Link]) ~[?:?]
at
[Link]/[Link].getInputStream0(HttpURLConnec
[Link]) ~[?:?]
at
[Link]/[Link](HttpURLConnect
[Link]) ~[?:?]
at
[Link]/[Link]([Link])
~[?:?]
at
[Link]/[Link](HttpsUR
[Link]) ~[?:?]
at
[Link](MinecraftClient
.java:84) ~[[Link]:?]
... 9 more
[Link] [Server thread/INFO]: Preparing start region for dimension
minecraft:overworld
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 2%
[Link] [Render thread/INFO]: Preparing spawn area: 6%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 18%
[Link] [Render thread/INFO]: Preparing spawn area: 30%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 51%
[Link] [Render thread/INFO]: Preparing spawn area: 63%
[Link] [Render thread/INFO]: Preparing spawn area: 73%
[Link] [Render thread/INFO]: Time elapsed: 46519 ms
[Link] [Server thread/INFO]: Changing view distance to 5, from 10
[Link] [Server thread/INFO]: Changing simulation distance to 12, from 0
[Link] [Render thread/WARN]: Failed to find a usable hardware address from the
network interfaces; using random bytes: [Link]
[Link] [Server thread/INFO]: Lorinzo99999[local:E:969df4d4] logged in with
entity id 45 at (17.5, 71.0, -49.5)
[Link] [Server thread/INFO]: Lorinzo99999 joined the game
[Link] [Server thread/WARN]: Can't keep up! Is the server overloaded? Running
2092ms or 41 ticks behind
[Link] [Render thread/WARN]: Ignoring chat session from Lorinzo99999 due to
missing Services public key
[Link] [Render thread/INFO]: Loaded 2 advancements

Minecraft Debug Log Analysis
No ratings yet
Minecraft Debug Log Analysis
6 pages
Yggdrasil Key Fetcher for OptiFine 1.21.4
No ratings yet
Yggdrasil Key Fetcher for OptiFine 1.21.4
370 pages
JNA Version Conflict in Minecraft Launch
No ratings yet
JNA Version Conflict in Minecraft Launch
10 pages
Pojav Launcher Debug for Cobblemania
No ratings yet
Pojav Launcher Debug for Cobblemania
18 pages
VulkanMod Device Report: Fabric 0.16.14
No ratings yet
VulkanMod Device Report: Fabric 0.16.14
11 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
47 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
93 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
57 pages
Minecraft Launcher Debug Info ARM64
No ratings yet
Minecraft Launcher Debug Info ARM64
9 pages
Minecraft Launcher Debug Log
No ratings yet
Minecraft Launcher Debug Log
26 pages
Debugging OpenGL Minecraft Launcher
No ratings yet
Debugging OpenGL Minecraft Launcher
3 pages
Minecraft Launcher Debug Info
No ratings yet
Minecraft Launcher Debug Info
233 pages
Cobblemon Riding Fabric 1.3.7 Launch Log
No ratings yet
Cobblemon Riding Fabric 1.3.7 Launch Log
9 pages
Launcher Debug for Minecraft on Android
No ratings yet
Launcher Debug for Minecraft on Android
9 pages
Minecraft Launch Error: JNA Conflict
No ratings yet
Minecraft Launch Error: JNA Conflict
13 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
24 pages
Minecraft 1.20.1 Launcher Debug Info
No ratings yet
Minecraft 1.20.1 Launcher Debug Info
56 pages
Minecraft 1.19.2 Forge Launcher Log
No ratings yet
Minecraft 1.19.2 Forge Launcher Log
87 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
23 pages
Yggdrasil Key Fetcher Error on JRE21 ARM64
No ratings yet
Yggdrasil Key Fetcher Error on JRE21 ARM64
13 pages
Minecraft Fabric Loader 0.16.10 Setup
No ratings yet
Minecraft Fabric Loader 0.16.10 Setup
34 pages
Minecraft Launcher Debug Info
No ratings yet
Minecraft Launcher Debug Info
48 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
2 pages
PojavLauncher Debug Log Analysis
No ratings yet
PojavLauncher Debug Log Analysis
12 pages
MixinExtras Initialization Log
No ratings yet
MixinExtras Initialization Log
13 pages
Minecraft Launcher Debug Info
No ratings yet
Minecraft Launcher Debug Info
28 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
25 pages
OptiFine 1.21.4 Launch Debug Log
No ratings yet
OptiFine 1.21.4 Launch Debug Log
107 pages
IchunUtil Mod Launch on Minecraft 1.12.2
No ratings yet
IchunUtil Mod Launch on Minecraft 1.12.2
15 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
32 pages
Launching Minecraft with Fabric 0.16.10
No ratings yet
Launching Minecraft with Fabric 0.16.10
6 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
6 pages
Minecraft Launch Error: JNA Incompatibility
No ratings yet
Minecraft Launch Error: JNA Incompatibility
15 pages
Minecraft Profile Key Pair Error
No ratings yet
Minecraft Profile Key Pair Error
22 pages
Minecraft Launcher Core Error Log
No ratings yet
Minecraft Launcher Core Error Log
11 pages
Launcher Debug Info for Minecraft Game
No ratings yet
Launcher Debug Info for Minecraft Game
35 pages
JNA 7.0.2 Launch Issues on ARM64
No ratings yet
JNA 7.0.2 Launch Issues on ARM64
15 pages
Minecraft 1.7.10 Launcher Debug Info
No ratings yet
Minecraft 1.7.10 Launcher Debug Info
18 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
7 pages
Not Enough Fake Pixel Mod Info
No ratings yet
Not Enough Fake Pixel Mod Info
62 pages
PojavLauncher Debug Log Analysis
No ratings yet
PojavLauncher Debug Log Analysis
136 pages
Minecraft Launcher Debug Report
No ratings yet
Minecraft Launcher Debug Report
207 pages
Minecraft Launcher Debug Info
No ratings yet
Minecraft Launcher Debug Info
6 pages
JNA 7.0.2 Compatibility Issues
No ratings yet
JNA 7.0.2 Compatibility Issues
13 pages
Minecraft Launcher Debug Info
No ratings yet
Minecraft Launcher Debug Info
49 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
6 pages
Minecraft Shaders Setup for 1.12.2
No ratings yet
Minecraft Shaders Setup for 1.12.2
13 pages
LWJGL Game Launch Debug Log
No ratings yet
LWJGL Game Launch Debug Log
8 pages
PojavLauncher Debug Log v3.3.1.1
No ratings yet
PojavLauncher Debug Log v3.3.1.1
43 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
87 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
7 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
20 pages
Mojo Launcher Debug Log Analysis
No ratings yet
Mojo Launcher Debug Log Analysis
5 pages
Minecraft Mod Loader Debug Report
No ratings yet
Minecraft Mod Loader Debug Report
95 pages
Cobblemon Game Initialization Errors
No ratings yet
Cobblemon Game Initialization Errors
31 pages
Minecraft Arm64 Launcher Debug Log
No ratings yet
Minecraft Arm64 Launcher Debug Log
92 pages
Minecraft Launcher Debug Log Analysis
No ratings yet
Minecraft Launcher Debug Log Analysis
73 pages
Minecraft Launcher Debug Log
No ratings yet
Minecraft Launcher Debug Log
44 pages
First Steps in SAP HANA Data Modeling
No ratings yet
First Steps in SAP HANA Data Modeling
16 pages
SMSCP Hardware Requirements Overview
No ratings yet
SMSCP Hardware Requirements Overview
2 pages
Kashmir University Payment Acknowledgment
No ratings yet
Kashmir University Payment Acknowledgment
1 page
GameCenterBizApplication Startup Log
No ratings yet
GameCenterBizApplication Startup Log
7 pages
Kenwood
No ratings yet
Kenwood
75 pages
Understanding Distributed Computing
No ratings yet
Understanding Distributed Computing
15 pages
XMO2pro: Advanced Oxygen Analyzer
No ratings yet
XMO2pro: Advanced Oxygen Analyzer
6 pages
Transportation Engineering Lab Manual
No ratings yet
Transportation Engineering Lab Manual
81 pages
WD My Passport Ultra Metal Edition 1TB USB 3.0 2 PDF
No ratings yet
WD My Passport Ultra Metal Edition 1TB USB 3.0 2 PDF
17 pages
ANSAP IV Therapy Card Renewal Guide
No ratings yet
ANSAP IV Therapy Card Renewal Guide
2 pages
LG StudioWorks 710E Monitor Manual
No ratings yet
LG StudioWorks 710E Monitor Manual
36 pages
CKD Diagnosis: Feature Optimization Techniques
No ratings yet
CKD Diagnosis: Feature Optimization Techniques
12 pages
Delta Ia-Asd Asda-A2-e Um en 20210205
No ratings yet
Delta Ia-Asd Asda-A2-e Um en 20210205
135 pages
Cardable Websites for Carding Transactions
0% (1)
Cardable Websites for Carding Transactions
4 pages
CADPIPE Building Services Tutorial
No ratings yet
CADPIPE Building Services Tutorial
44 pages
KM-10 Elevator Door Controller Manual
No ratings yet
KM-10 Elevator Door Controller Manual
18 pages
Multiplying by the Conjugate Explained
No ratings yet
Multiplying by the Conjugate Explained
2 pages
Force Feedback System Patent Overview
No ratings yet
Force Feedback System Patent Overview
25 pages
Oracle RAC: Misleading Scalability Claims
No ratings yet
Oracle RAC: Misleading Scalability Claims
2 pages
PepsiCo Mobile Device Enrollment Guide
No ratings yet
PepsiCo Mobile Device Enrollment Guide
1 page
Thermal Inkjet Technology HP
No ratings yet
Thermal Inkjet Technology HP
4 pages
Installing ZeroMQ on Windows for Xibo
No ratings yet
Installing ZeroMQ on Windows for Xibo
7 pages
Random Variables: Sum and Density Functions
No ratings yet
Random Variables: Sum and Density Functions
33 pages
ASIC Design Methodology Overview
No ratings yet
ASIC Design Methodology Overview
10 pages
Senior SEO Marketing Position in Bangkok
No ratings yet
Senior SEO Marketing Position in Bangkok
2 pages
Preparation of Computer Aided Drawings (CAD)
100% (1)
Preparation of Computer Aided Drawings (CAD)
30 pages
Max-Min Hill-Climbing for Bayesian Networks
No ratings yet
Max-Min Hill-Climbing for Bayesian Networks
48 pages
WAH Virtual Server Overview and Benefits
No ratings yet
WAH Virtual Server Overview and Benefits
16 pages
VEGAPULS SR 68 Radar Sensor Guide
No ratings yet
VEGAPULS SR 68 Radar Sensor Guide
80 pages
Kendall Sad9 PP 16 Saaaad
No ratings yet
Kendall Sad9 PP 16 Saaaad
88 pages