Initial commit

Win32.DX11.Release/data/shaders/glsl/end_portal.vertex

@@ -0,0 +1,115 @@
+// __multiversion__
+// This signals the loading code to prepend either #version 100 or #version 300 es as apropriate.
+
+// To use centroid sampling we need to have version 300 es shaders, which requires changing:
+// attribute to in
+// varying to out when in vertex shaders or in when in fragment shaders
+// defining an out vec4 FragColor and replacing uses of gl_FragColor with FragColor
+// texture2D to texture
+
+precision highp float;
+
+#include "shaders/vertexVersionCentroid.h"
+
+#if __VERSION__ >= 300
+	#ifndef BYPASS_PIXEL_SHADER
+		_centroid out vec2 colorLookupUV;
+		_centroid out vec2 parallaxUV;
+	#endif
+#else
+	#ifndef BYPASS_PIXEL_SHADER
+		varying vec2 colorLookupUV;
+		varying vec2 parallaxUV;
+	#endif
+#endif
+
+#ifndef BYPASS_PIXEL_SHADER
+	varying lowp vec4 encodedPlane;
+	#ifdef FOG
+		varying vec4 fogColor;
+	#endif
+#endif
+
+#include "shaders/uniformWorldConstants.h"
+#include "shaders/uniformPerFrameConstants.h"
+#include "shaders/uniformShaderConstants.h"
+#include "shaders/uniformRenderChunkConstants.h"
+
+#ifndef BYPASS_PIXEL_SHADER
+	attribute POS4 POSITION;
+	attribute vec4 COLOR;
+	attribute vec2 TEXCOORD_0;
+	attribute vec2 TEXCOORD_1;
+#endif
+
+const float MAX_LAYER_DEPTH = 32.0;
+
+void main() {
+	///// Vertex Transformation
+	POS4 worldPos = vec4((POSITION.xyz * CHUNK_ORIGIN_AND_SCALE.w) + CHUNK_ORIGIN_AND_SCALE.xyz, 1);
+	POS4 pos = PROJ * (WORLDVIEW * worldPos);
+	gl_Position = pos;
+
+	#ifndef BYPASS_PIXEL_SHADER
+		///// End Portal Data
+		colorLookupUV = TEXCOORD_0;
+		encodedPlane = COLOR; // Color value is used to encode the starfield plane
+
+		vec3 planeNormal = (encodedPlane.xyz - vec3(0.5,0.5,0.5)) * 2.0;
+		float planeDistance = encodedPlane.w * MAX_LAYER_DEPTH;
+
+		// Calculate view direction from the surface position and the eye position
+		POS3 viewRay = worldPos.xyz;
+
+		///// Ray-cast for parallax-offset UV
+		// Perform ray-plane intersection to find the position on the parallax plane
+		float t = (dot(viewRay - (planeDistance * planeNormal), planeNormal)) / dot(viewRay, planeNormal);
+		POS3 parallaxPositionInWorld = (t * viewRay) + VIEW_POS;
+
+		///// Ridiculous UV-remapping
+		// Create a mask with a 1 wherever the normal would have a non-zero value
+		// All normals are orthonormal on <x,y,z>, so there should be two 0's and a 1
+		vec3 normalMask = floor(abs(planeNormal) + vec3(0.5,0.5,0.5));
+		// Mask out the correct uv result
+		vec2 raycastUV = parallaxPositionInWorld.yz * normalMask[0] + parallaxPositionInWorld.xz * normalMask[1] + parallaxPositionInWorld.xy * normalMask[2];
+
+		// Scale the UVs to Minecraft pixel size
+		raycastUV = raycastUV / 16.0; // TODO: Use TEXTURE_DIMENSIONS
+
+		const float rotor = 3.1415926535897 * (5.0 / 7.0);
+		float rotS = sin(planeDistance * rotor);
+		float rotC = cos(planeDistance * rotor);
+
+		parallaxUV = mat2(vec2(rotC, rotS), vec2(-rotS, rotC)) * raycastUV;
+
+		parallaxUV += vec2(rotC, rotS) * planeDistance;
+		parallaxUV.y += TIME / 256.0;
+
+		const float modVal = 64.0;
+		parallaxUV = vec2(mod(parallaxUV.x, modVal), mod(parallaxUV.y, modVal));
+
+		///// Fog
+		#ifdef FOG
+			#ifdef FANCY
+				vec3 relPos = -worldPos.xyz;
+				float cameraDepth = length(relPos);
+				#ifdef NEAR_WATER
+					cameraDist = cameraDepth / FAR_CHUNKS_DISTANCE;
+				#endif
+			#else
+				float cameraDepth = pos.z;
+				#ifdef NEAR_WATER
+					vec3 relPos = -worldPos.xyz;
+					float camDist = length(relPos);
+					cameraDist = camDist / FAR_CHUNKS_DISTANCE;
+				#endif
+			#endif
+			float len = cameraDepth / RENDER_DISTANCE;
+			#ifdef ALLOW_FADE
+				len += CURRENT_COLOR.r;
+			#endif
+				fogColor.rgb = FOG_COLOR.rgb;
+			fogColor.a = clamp((len - FOG_CONTROL.x) / (FOG_CONTROL.y - FOG_CONTROL.x), 0.0, 1.0);
+		#endif
+	#endif
+}