diff --git a/shaders/dimensions/physics_ocean.fsh b/shaders/dimensions/physics_ocean.fsh new file mode 100644 index 00000000..02be15ac --- /dev/null +++ b/shaders/dimensions/physics_ocean.fsh @@ -0,0 +1,789 @@ +#define RENDER_FRAGMENT + +#include "/lib/settings.glsl" + +#ifdef IS_LPV_ENABLED + #extension GL_EXT_shader_image_load_store: enable + #extension GL_ARB_shading_language_packing: enable +#endif + +#include "/lib/physics_ocean.glsl" +#include "/lib/res_params.glsl" + +varying vec3 physics_localPosition; +varying float physics_localWaviness; + +varying vec4 lmtexcoord; +varying vec4 color; +uniform vec4 entityColor; + +#ifdef OVERWORLD_SHADER + const bool shadowHardwareFiltering = true; + uniform sampler2DShadow shadow; + + #ifdef TRANSLUCENT_COLORED_SHADOWS + uniform sampler2D shadowcolor0; + uniform sampler2DShadow shadowtex0; + uniform sampler2DShadow shadowtex1; + #endif + + uniform float lightSign; + flat varying vec3 WsunVec; + + flat varying vec3 averageSkyCol_Clouds; + flat varying vec4 lightCol; +#endif + + + +flat varying float HELD_ITEM_BRIGHTNESS; + +const bool colortex4MipmapEnabled = true; +uniform sampler2D noisetex; +uniform sampler2D depthtex1; +uniform sampler2D depthtex0; + +#ifdef DISTANT_HORIZONS + uniform sampler2D dhDepthTex1; +#endif +uniform sampler2D colortex7; +uniform sampler2D colortex12; +uniform sampler2D colortex14; +uniform sampler2D colortex5; +uniform sampler2D colortex3; +uniform sampler2D colortex4; +uniform sampler2D colortex6; + +uniform sampler2D texture; +uniform sampler2D specular; +uniform sampler2D normals; + +#ifdef IS_LPV_ENABLED + uniform usampler1D texBlockData; + uniform sampler3D texLpv1; + uniform sampler3D texLpv2; +#endif + +varying vec4 tangent; +varying vec4 normalMat; +varying vec3 binormal; +varying vec3 flatnormal; +varying vec3 shitnormal; + + +flat varying float exposure; + + +uniform vec3 sunVec; +uniform float near; +// uniform float far; +uniform float sunElevation; + +uniform int isEyeInWater; +uniform float rainStrength; +uniform float skyIntensityNight; +uniform float skyIntensity; +uniform ivec2 eyeBrightnessSmooth; + +uniform int frameCounter; +uniform float frameTimeCounter; +uniform vec2 texelSize; +uniform int framemod8; + +uniform mat4 gbufferPreviousModelView; +uniform vec3 previousCameraPosition; + + +uniform float moonIntensity; +uniform float sunIntensity; +uniform vec3 sunColor; +uniform vec3 nsunColor; + +#include "/lib/util.glsl" +#include "/lib/Shadow_Params.glsl" +#include "/lib/color_transforms.glsl" +#include "/lib/projections.glsl" +#include "/lib/sky_gradient.glsl" +#include "/lib/waterBump.glsl" + + +#ifdef OVERWORLD_SHADER + flat varying float Flashing; + #include "/lib/lightning_stuff.glsl" + + #define CLOUDSHADOWSONLY + #include "/lib/volumetricClouds.glsl" +#else + uniform float nightVision; +#endif + +#ifdef END_SHADER + #include "/lib/end_fog.glsl" +#endif + +#ifdef IS_LPV_ENABLED + uniform int heldItemId; + uniform int heldItemId2; + + #include "/lib/hsv.glsl" + #include "/lib/lpv_common.glsl" + #include "/lib/lpv_render.glsl" +#endif + +#include "/lib/diffuse_lighting.glsl" + +float blueNoise(){ + return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter); +} +vec4 blueNoise(vec2 coord){ + return texelFetch2D(colortex6, ivec2(coord)%512 , 0) ; +} +float interleaved_gradientNoise_temporal(){ + return fract(52.9829189*fract(0.06711056*gl_FragCoord.x + 0.00583715*gl_FragCoord.y)+frameTimeCounter*51.9521); +} +float interleaved_gradientNoise(){ + vec2 coord = gl_FragCoord.xy; + float noise = fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y)); + return noise; +} +float R2_dither(){ + vec2 coord = gl_FragCoord.xy + (frameCounter%40000) * 2.0; + vec2 alpha = vec2(0.75487765, 0.56984026); + return fract(alpha.x * coord.x + alpha.y * coord.y ) ; +} + +const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.), + vec2(-1.,3.)/8., + vec2(5.0,1.)/8., + vec2(-3,-5.)/8., + vec2(-5.,5.)/8., + vec2(-7.,-1.)/8., + vec2(3,7.)/8., + vec2(7.,-7.)/8.); + + + + + + + +#define PW_DEPTH 1.5 //[0.5 1.0 1.5 2.0 2.5 3.0] +#define PW_POINTS 2 //[2 4 6 8 16 32] + +varying vec3 viewVector; + +vec2 CleanSample( + int samples, float totalSamples, float noise +){ + + // this will be used to make 1 full rotation of the spiral. the mulitplication is so it does nearly a single rotation, instead of going past where it started + float variance = noise * 0.897; + + // for every sample input, it will have variance applied to it. + float variedSamples = float(samples) + variance; + + // for every sample, the sample position must change its distance from the origin. + // otherwise, you will just have a circle. + float spiralShape = pow(variedSamples / (totalSamples + variance),0.5); + + float shape = 2.26; // this is very important. 2.26 is very specific + float theta = variedSamples * (PI * shape); + + float x = cos(theta) * spiralShape; + float y = sin(theta) * spiralShape; + + return vec2(x, y); +} + +vec3 viewToWorld(vec3 viewPos) { + vec4 pos; + pos.xyz = viewPos; + pos.w = 0.0; + pos = gbufferModelViewInverse * pos; + return pos.xyz; +} + +vec3 worldToView(vec3 worldPos) { + vec4 pos = vec4(worldPos, 0.0); + pos = gbufferModelView * pos; + return pos.xyz; +} +vec4 encode (vec3 n, vec2 lightmaps){ + n.xy = n.xy / dot(abs(n), vec3(1.0)); + n.xy = n.z <= 0.0 ? (1.0 - abs(n.yx)) * sign(n.xy) : n.xy; + vec2 encn = clamp(n.xy * 0.5 + 0.5,-1.0,1.0); + + return vec4(encn,vec2(lightmaps.x,lightmaps.y)); +} + +//encoding by jodie +float encodeVec2(vec2 a){ + const vec2 constant1 = vec2( 1., 256.) / 65535.; + vec2 temp = floor( a * 255. ); + return temp.x*constant1.x+temp.y*constant1.y; +} +float encodeVec2(float x,float y){ + return encodeVec2(vec2(x,y)); +} + + +float invLinZ (float lindepth){ + return -((2.0*near/lindepth)-far-near)/(far-near); +} +float ld(float dist) { + return (2.0 * near) / (far + near - dist * (far - near)); +} + +vec3 rayTrace(vec3 dir, vec3 position,float dither, float fresnel, bool inwater, inout float reflectLength){ + + float quality = mix(15,SSR_STEPS,fresnel); + + // quality = SSR_STEPS; + + vec3 clipPosition = toClipSpace3(position); + float rayLength = ((position.z + dir.z * far*sqrt(3.)) > -near) ? + (-near -position.z) / dir.z : far*sqrt(3.); + vec3 direction = normalize(toClipSpace3(position+dir*rayLength)-clipPosition); //convert to clip space + direction.xy = normalize(direction.xy); + + //get at which length the ray intersects with the edge of the screen + vec3 maxLengths = (step(0.,direction)-clipPosition) / direction; + float mult = min(min(maxLengths.x,maxLengths.y),maxLengths.z); + + + vec3 stepv = direction * mult / quality * vec3(RENDER_SCALE,1.0); + + + vec3 spos = clipPosition*vec3(RENDER_SCALE,1.0) + stepv*dither; + float minZ = clipPosition.z; + float maxZ = spos.z+stepv.z*0.5; + + spos.xy += offsets[framemod8]*texelSize*0.5/RENDER_SCALE; + + float dist = 1.0 + clamp(position.z*position.z/50.0,0,2); // shrink sample size as distance increases + for (int i = 0; i <= int(quality); i++) { + + // decode depth buffer + // float sp = sqrt(texelFetch2D(colortex4,ivec2(spos.xy/texelSize/4),0).w/65000.0); + + float sp = sqrt(texelFetch2D(colortex4,ivec2(spos.xy/texelSize/4.0),0).a/65000.0); + sp = invLinZ(sp); + + if(sp <= max(maxZ,minZ) && sp >= min(maxZ,minZ)) return vec3(spos.xy/RENDER_SCALE,sp); + + + + + spos += stepv; + //small bias + if(inwater) { + minZ = maxZ-0.00035/ld(spos.z); + }else{ + minZ = maxZ-0.0001/max(ld(spos.z), (0.0 + position.z*position.z*0.001)); + } + maxZ += stepv.z; + + + reflectLength += 1.0 / quality; // for shit + } + + return vec3(1.1); +} + +float GGX(vec3 n, vec3 v, vec3 l, float r, float f0) { + r = max(pow(r,2.5), 0.0001); + + vec3 h = l + v; + float hn = inversesqrt(dot(h, h)); + + float dotLH = clamp(dot(h,l)*hn,0.,1.); + float dotNH = clamp(dot(h,n)*hn,0.,1.) ; + float dotNL = clamp(dot(n,l),0.,1.); + float dotNHsq = dotNH*dotNH; + + float denom = dotNHsq * r - dotNHsq + 1.; + float D = r / (3.141592653589793 * denom * denom); + + float F = f0 + (1. - f0) * exp2((-5.55473*dotLH-6.98316)*dotLH); + float k2 = .25 * r; + + return dotNL * D * F / (dotLH*dotLH*(1.0-k2)+k2); +} + + + +uniform float dhFarPlane; + +#include "/lib/DistantHorizons_projections.glsl" + + + + +// #undef BASIC_SHADOW_FILTER + +#ifdef OVERWORLD_SHADER +float ComputeShadowMap(inout vec3 directLightColor, vec3 playerPos, float maxDistFade, float noise){ + + if(maxDistFade <= 0.0) return 1.0; + + // setup shadow projection + vec3 projectedShadowPosition = mat3(shadowModelView) * playerPos + shadowModelView[3].xyz; + projectedShadowPosition = diagonal3(shadowProjection) * projectedShadowPosition + shadowProjection[3].xyz; + + // un-distort + #ifdef DISTORT_SHADOWMAP + float distortFactor = calcDistort(projectedShadowPosition.xy); + projectedShadowPosition.xy *= distortFactor; + #else + float distortFactor = 1.0; + #endif + + // hamburger + projectedShadowPosition = projectedShadowPosition * vec3(0.5,0.5,0.5/6.0) + vec3(0.5); + + float shadowmap = 0.0; + vec3 translucentTint = vec3(0.0); + + projectedShadowPosition.z -= 0.0001; + + #ifdef BASIC_SHADOW_FILTER + int samples = int(SHADOW_FILTER_SAMPLE_COUNT * 0.5); + float rdMul = 14.0*distortFactor*d0*k/shadowMapResolution; + + for(int i = 0; i < samples; i++){ + vec2 offsetS = CleanSample(i, samples - 1, noise) * 0.3; + projectedShadowPosition.xy += rdMul*offsetS; + #else + int samples = 1; + #endif + + + #ifdef TRANSLUCENT_COLORED_SHADOWS + + // determine when opaque shadows are overlapping translucent shadows by getting the difference of opaque depth and translucent depth + float shadowDepthDiff = pow(clamp((shadow2D(shadowtex1, projectedShadowPosition).x - projectedShadowPosition.z) * 2.0,0.0,1.0),2.0); + + // get opaque shadow data to get opaque data from translucent shadows. + float opaqueShadow = shadow2D(shadowtex0, projectedShadowPosition).x; + shadowmap += max(opaqueShadow, shadowDepthDiff); + + // get translucent shadow data + vec4 translucentShadow = texture2D(shadowcolor0, projectedShadowPosition.xy); + + // this curve simply looked the nicest. it has no other meaning. + float shadowAlpha = pow(1.0 - pow(translucentShadow.a,5.0),0.2); + + // normalize the color to remove luminance, and keep the hue. remove all opaque color. + // mulitply shadow alpha to shadow color, but only on surfaces facing the lightsource. this is a tradeoff to protect subsurface scattering's colored shadow tint from shadow bias on the back of the caster. + translucentShadow.rgb = max(normalize(translucentShadow.rgb + 0.0001), max(opaqueShadow, 1.0-shadowAlpha)) * shadowAlpha; + + // make it such that full alpha areas that arent in a shadow have a value of 1.0 instead of 0.0 + translucentTint += mix(translucentShadow.rgb, vec3(1.0), opaqueShadow*shadowDepthDiff); + + #else + shadowmap += shadow2D(shadow, projectedShadowPosition).x; + #endif + + #ifdef BASIC_SHADOW_FILTER + } + #endif + + #ifdef TRANSLUCENT_COLORED_SHADOWS + // tint the lightsource color with the translucent shadow color + directLightColor *= mix(vec3(1.0), translucentTint.rgb / samples, maxDistFade); + #endif + + return mix(1.0, shadowmap / samples, maxDistFade); +} +#endif + + +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// + + +/* RENDERTARGETS:2,7,11,14 */ + + +void main() { +if (gl_FragCoord.x * texelSize.x < 1.0 && gl_FragCoord.y * texelSize.y < 1.0 ) { + + vec3 FragCoord = gl_FragCoord.xyz; + + vec2 tempOffset = offsets[framemod8]; + + vec3 viewPos = toScreenSpace(FragCoord*vec3(texelSize/RENDER_SCALE,1.0)-vec3(vec2(tempOffset)*texelSize*0.5, 0.0)); + + vec3 feetPlayerPos = mat3(gbufferModelViewInverse) * viewPos; + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// MATERIAL MASKS //////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + float MATERIALS = 1.0;//normalMat.w; + + // 1.0 = water mask + // 0.9 = entity mask + // 0.8 = reflective entities + // 0.7 = reflective blocks + // 0.1 = hand mask + + // #ifdef HAND + // MATERIALS = 0.1; + // #endif + + // bool isHand = abs(MATERIALS - 0.1) < 0.01; + bool isWater = true; //MATERIALS > 0.99; + bool isReflectiveEntity = false;//abs(MATERIALS - 0.8) < 0.01; + bool isReflective = true;//abs(MATERIALS - 0.7) < 0.01 || isWater || isReflectiveEntity; + bool isEntity = false;//abs(MATERIALS - 0.9) < 0.01 || isReflectiveEntity; + +//////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////// ALBEDO ///////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + gl_FragData[0] = texture2D(texture, lmtexcoord.xy, Texture_MipMap_Bias) * color; + + float UnchangedAlpha = gl_FragData[0].a; + + #ifdef WhiteWorld + gl_FragData[0].rgb = vec3(0.5); + gl_FragData[0].a = 1.0; + #endif + + vec3 Albedo = toLinear(gl_FragData[0].rgb); + + #ifndef WhiteWorld + #ifdef Vanilla_like_water + if (isWater) Albedo *= sqrt(luma(Albedo)); + #else + Albedo = vec3(0.0); + gl_FragData[0].a = 1.0/255.0; + #endif + #endif + + vec4 GLASS_TINT_COLORS = vec4(Albedo, UnchangedAlpha); + + #ifdef BIOME_TINT_WATER + if (isWater) GLASS_TINT_COLORS.rgb = toLinear(color.rgb); + #endif + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// NORMALS /////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + vec3 normal = normalMat.xyz; // in viewSpace + + normal = viewToWorld(normal); + normal.xz = shitnormal.xy; + normal = worldToView(normal); + + vec3 worldSpaceNormal = viewToWorld(normal).xyz; + vec2 TangentNormal = vec2(0); // for refractions + + vec3 tangent2 = normalize(cross(tangent.rgb,normal)*tangent.w); + mat3 tbnMatrix = mat3(tangent.x, tangent2.x, normal.x, + tangent.y, tangent2.y, normal.y, + tangent.z, tangent2.z, normal.z); + + // vec3 NormalTex = vec3(texture2D(normals, lmtexcoord.xy, Texture_MipMap_Bias).xy,0.0); + // NormalTex.xy = NormalTex.xy*2.0-1.0; + // NormalTex.z = clamp(sqrt(1.0 - dot(NormalTex.xy, NormalTex.xy)), 0.0, 1.0); + + // tangent space normals for refraction + //TangentNormal = NormalTex.xy*0.5+0.5; + + + // vec3 posxz = (mat3(gbufferModelViewInverse) * viewPos + gbufferModelViewInverse[3].xyz) + cameraPosition; + + // make the waves flow in the direction the water faces, except for perfectly up facing parts. + // if(abs(worldSpaceNormal.y) < 0.9995) posxz.xz -= (posxz.y + frameTimeCounter*3 * WATER_WAVE_SPEED) * normalize(worldSpaceNormal.xz) ; + + // posxz.xyz = getParallaxDisplacement(posxz); + // vec3 bump = normalize(getWaveNormal(posxz, false)); + + // float bumpmult = 10.0 * WATER_WAVE_STRENGTH; + // bump = bump * vec3(bumpmult, bumpmult, bumpmult) + vec3(0.0f, 0.0f, 1.0f - bumpmult); + + // NormalTex.xyz = bump; + + // tangent space normals for refraction + // TangentNormal = (bump.xy/3.0)*0.5+0.5; + + + float waviness = max(physics_localWaviness, 0.02); + WavePixelData wave = physics_wavePixel(physics_localPosition.xz, waviness, physics_iterationsNormal, physics_gameTime); + vec3 NormalTex = wave.normal; + + if (isEyeInWater == 1 && !gl_FrontFacing) NormalTex = -NormalTex; + + // tangent space normals for refraction + TangentNormal = NormalTex.xy*0.5+0.5; + + + // normal = applyBump(tbnMatrix, NormalTex.xyz, 1.0); + normal = worldToView(NormalTex.xzy); + + gl_FragData[2] = vec4(encodeVec2(TangentNormal), encodeVec2(GLASS_TINT_COLORS.rg), encodeVec2(GLASS_TINT_COLORS.ba), 1.0); + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// SPECULARS ///////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + vec3 SpecularTex = texture2D(specular, lmtexcoord.xy, Texture_MipMap_Bias).rga; + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// DIFFUSE LIGHTING ////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + vec2 lightmap = lmtexcoord.zw; + + // lightmap.y = 1.0; + + #ifndef OVERWORLD_SHADER + lightmap.y = 1.0; + #endif + + #ifdef Hand_Held_lights + lightmap.x = max(lightmap.x, HELD_ITEM_BRIGHTNESS*clamp( pow(max(1.0-length(feetPlayerPos)/HANDHELD_LIGHT_RANGE,0.0),1.5),0.0,1.0)); + #endif + + vec3 Indirect_lighting = vec3(0.0); + vec3 MinimumLightColor = vec3(1.0); + if(isEyeInWater == 1) MinimumLightColor = vec3(10.0); + + vec3 Direct_lighting = vec3(0.0); + + #ifdef OVERWORLD_SHADER + vec3 DirectLightColor = lightCol.rgb/80.0; + float NdotL = clamp(dot(normal, normalize(WsunVec*mat3(gbufferModelViewInverse))),0.0,1.0); NdotL = clamp((-15 + NdotL*255.0) / 240.0 ,0.0,1.0); + float Shadows = 1.0; + + float shadowMapFalloff = smoothstep(0.0, 1.0, min(max(1.0 - length(feetPlayerPos) / (shadowDistance+16),0.0)*5.0,1.0)); + float shadowMapFalloff2 = smoothstep(0.0, 1.0, min(max(1.0 - length(feetPlayerPos) / shadowDistance,0.0)*5.0,1.0)); + + float LM_shadowMapFallback = min(max(lightmap.y-0.8, 0.0) * 25,1.0); + + vec3 shadowPlayerPos = mat3(gbufferModelViewInverse) * viewPos + gbufferModelViewInverse[3].xyz; + + Shadows = ComputeShadowMap(DirectLightColor, shadowPlayerPos, shadowMapFalloff, blueNoise()); + + Shadows = mix(LM_shadowMapFallback, Shadows, shadowMapFalloff2); + + Shadows *= pow(GetCloudShadow(feetPlayerPos),3); + + Direct_lighting = DirectLightColor * NdotL * Shadows; + + vec3 AmbientLightColor = averageSkyCol_Clouds/30.0; + + vec3 ambientcoefs = worldSpaceNormal / dot(abs(worldSpaceNormal), vec3(1.0)); + float SkylightDir = ambientcoefs.y*1.5; + + float skylight = max(pow(viewToWorld(flatnormal).y*0.5+0.5,0.1) + SkylightDir, 0.2); + AmbientLightColor *= skylight; + #endif + + #ifdef NETHER_SHADER + // vec3 AmbientLightColor = skyCloudsFromTexLOD2(worldSpaceNormal, colortex4, 6).rgb / 15.0; + + // vec3 up = skyCloudsFromTexLOD2(vec3( 0, 1, 0), colortex4, 6).rgb/ 30.0; + // vec3 down = skyCloudsFromTexLOD2(vec3( 0,-1, 0), colortex4, 6).rgb/ 30.0; + + // up *= pow( max( worldSpaceNormal.y, 0), 2); + // down *= pow( max(-worldSpaceNormal.y, 0), 2); + // AmbientLightColor += up + down; + + vec3 AmbientLightColor = vec3(0.1); + #endif + + #ifdef END_SHADER + float vortexBounds = clamp(vortexBoundRange - length(feetPlayerPos+cameraPosition), 0.0,1.0); + vec3 lightPos = LightSourcePosition(feetPlayerPos+cameraPosition, cameraPosition,vortexBounds); + + + float lightningflash = texelFetch2D(colortex4,ivec2(1,1),0).x/150.0; + vec3 lightColors = LightSourceColors(vortexBounds, lightningflash); + + float NdotL = clamp(dot(worldSpaceNormal, normalize(-lightPos))*0.5+0.5,0.0,1.0); + + NdotL *= NdotL; + + Direct_lighting = lightColors * endFogPhase(lightPos) * NdotL; + + vec3 AmbientLightColor = vec3(0.5,0.75,1.0) * 0.9 + 0.1; + AmbientLightColor *= clamp(1.5 + dot(worldSpaceNormal, normalize(feetPlayerPos))*0.5,0,2); + #endif + + #ifdef IS_LPV_ENABLED + vec3 normalOffset = 0.5*worldSpaceNormal; + + #if LPV_NORMAL_STRENGTH > 0 + if (any(greaterThan(abs(normal), vec3(1.0e-6)))) { + vec3 texNormalOffset = -normalOffset + viewToWorld(normal); + normalOffset = mix(normalOffset, texNormalOffset, (LPV_NORMAL_STRENGTH*0.01)); + } + #endif + + vec3 lpvPos = GetLpvPosition(feetPlayerPos) + normalOffset; + #else + const vec3 lpvPos = vec3(0.0); + #endif + + Indirect_lighting = DoAmbientLightColor(feetPlayerPos, lpvPos, AmbientLightColor, MinimumLightColor, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.xy, exposure); + + vec3 FinalColor = (Indirect_lighting + Direct_lighting) * Albedo; + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// SPECULAR LIGHTING ///////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + #ifdef DAMAGE_BLOCK_EFFECT + #undef WATER_REFLECTIONS + #endif + + #ifndef OVERWORLD_SHADER + #undef WATER_SUN_SPECULAR + #endif + + #ifdef WATER_REFLECTIONS + // vec2 SpecularTex = texture2D(specular, lmtexcoord.xy, Texture_MipMap_Bias).rg; + + // if nothing is chosen, no smoothness and no reflectance + vec2 specularValues = vec2(1.0, 0.0); + + // hardcode specular values for select blocks like glass, water, and slime + if(isReflective) specularValues = vec2(1.0, 0.02); + + // detect if the specular texture is used, if it is, overwrite hardcoded values + if(SpecularTex.r > 0.0 && SpecularTex.g <= 1.0) specularValues = SpecularTex.rg; + + float roughness = pow(1.0-specularValues.r,2.0); + float f0 = isReflective ? max(specularValues.g, 0.02) : specularValues.g; + + // f0 = SpecularTex.g; + // roughness = pow(1.0-specularValues.r,2.0); + // f0 = 0.9; + // roughness = 0.0; + + vec3 Metals = f0 > 229.5/255.0 ? normalize(Albedo+1e-7) * (dot(Albedo,vec3(0.21, 0.72, 0.07)) * 0.7 + 0.3) : vec3(1.0); + + // make sure zero alpha is not forced to be full alpha by fresnel on items with funny normal padding + if(UnchangedAlpha <= 0.0 && !isReflective) f0 = 0.0; + + if (f0 > 0.0){ + + if(isReflective) f0 = max(f0, 0.02); + + vec3 Reflections_Final = vec3(0.0); + vec4 Reflections = vec4(0.0); + vec3 BackgroundReflection = FinalColor; + vec3 SunReflection = vec3(0.0); + float indoors = pow(1.0-pow(1.0-min(max(lightmap.y-0.6,0.0)*3.0,1.0),0.5),2.0); + + vec3 reflectedVector = reflect(normalize(viewPos), normal); + float normalDotEye = dot(normal, normalize(viewPos)); + + float fresnel = pow(clamp(1.0 + normalDotEye, 0.0, 1.0),5.0); + + /* + int seed = (frameCounter%40000) + frameCounter*2; + float noise = fract(R2_samples(seed).y + (1-blueNoise())); + mat3 Basis = CoordBase(viewToWorld(normal)); + vec3 ViewDir = -normalize(feetPlayerPos)*Basis; + vec3 SamplePoints = SampleVNDFGGX(ViewDir, vec2(roughness), noise); + vec3 Ln = reflect(-ViewDir, SamplePoints); + vec3 L = Basis * Ln; + fresnel = pow(clamp(1.0 + dot(-Ln, SamplePoints),0.0,1.0), 5.0); + */ + + #ifdef SNELLS_WINDOW + // snells window looking thing + if(isEyeInWater == 1) fresnel = pow(clamp(1.5 + normalDotEye,0.0,1.0), 25.0); + #endif + + fresnel = mix(f0, 1.0, fresnel); + + // Sun, Sky, and screen-space reflections + #ifdef OVERWORLD_SHADER + #ifdef WATER_SUN_SPECULAR + SunReflection = Direct_lighting * GGX(normal, -normalize(viewPos), WsunVec*mat3(gbufferModelViewInverse), max(roughness,0.035), f0) * Metals; + #endif + #ifdef WATER_BACKGROUND_SPECULAR + if(isEyeInWater == 0 && !isReflectiveEntity) BackgroundReflection = skyCloudsFromTex(mat3(gbufferModelViewInverse) * reflectedVector, colortex4).rgb / 30.0 * Metals; + #endif + + if(isEyeInWater == 1 && isWater) BackgroundReflection.rgb = exp(-8.0 * vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B)) * clamp(WsunVec.y*lightCol.a,0,1); + #else + #ifdef WATER_BACKGROUND_SPECULAR + if(isEyeInWater == 0) BackgroundReflection = skyCloudsFromTexLOD2(mat3(gbufferModelViewInverse) * reflectedVector, colortex4, 0).rgb / 30.0 * Metals; + #endif + #endif + + #ifdef SCREENSPACE_REFLECTIONS + float reflectLength = 0.0; + vec3 rtPos = rayTrace(reflectedVector, viewPos.xyz, interleaved_gradientNoise_temporal(), fresnel, isEyeInWater == 1,reflectLength); + if (rtPos.z < 1.0){ + vec3 previousPosition = mat3(gbufferModelViewInverse) * toScreenSpace(rtPos) + gbufferModelViewInverse[3].xyz + cameraPosition-previousCameraPosition; + previousPosition = mat3(gbufferPreviousModelView) * previousPosition + gbufferPreviousModelView[3].xyz; + previousPosition.xy = projMAD(gbufferPreviousProjection, previousPosition).xy / -previousPosition.z * 0.5 + 0.5; + if (previousPosition.x > 0.0 && previousPosition.y > 0.0 && previousPosition.x < 1.0 && previousPosition.x < 1.0) { + Reflections.a = 1.0; + Reflections.rgb = texture2D(colortex5, previousPosition.xy).rgb * Metals; + } + } + #endif + + float visibilityFactor = clamp(exp2((pow(roughness,3.0) / f0) * -4),0,1); + + Reflections_Final = mix(mix(FinalColor, BackgroundReflection, indoors), Reflections.rgb, Reflections.a) * fresnel * visibilityFactor; + Reflections_Final += SunReflection; + + //correct alpha channel with fresnel + float alpha0 = gl_FragData[0].a; + + gl_FragData[0].a = -gl_FragData[0].a * fresnel + gl_FragData[0].a + fresnel; + + // prevent reflections from being darkened by buffer blending + gl_FragData[0].rgb = clamp(FinalColor / gl_FragData[0].a*alpha0*(1.0-fresnel) * 0.1 + Reflections_Final / gl_FragData[0].a * 0.1,0.0,65100.0); + + if (gl_FragData[0].r > 65000.) gl_FragData[0].rgba = vec4(0.0); + + } else { + gl_FragData[0].rgb = FinalColor*0.1; + } + + #else + gl_FragData[0].rgb = FinalColor*0.1; + #endif + + // #if EMISSIVE_TYPE == 2 || EMISSIVE_TYPE == 3 + // Emission(gl_FragData[0].rgb, Albedo, SpecularTex.b, exposure); + // #endif + + #if defined DISTANT_HORIZONS && defined DH_OVERDRAW_PREVENTION && !defined HAND + bool WATER = texture2D(colortex7, gl_FragCoord.xy*texelSize).a > 0.0 && length(feetPlayerPos) > far-16*4 && texture2D(depthtex1, gl_FragCoord.xy*texelSize).x >= 1.0; + + if(WATER) gl_FragData[0].a = 0.0; + #endif + + gl_FragData[1] = vec4(Albedo, MATERIALS); + + #if DEBUG_VIEW == debug_DH_WATER_BLENDING + if(gl_FragCoord.x*texelSize.x < 0.47) gl_FragData[0] = vec4(0.0); + #endif + #if DEBUG_VIEW == debug_NORMALS + gl_FragData[0].rgb = normalize(normal.xyz) * 0.1; + #endif + #if DEBUG_VIEW == debug_INDIRECT + gl_FragData[0].rgb = Indirect_lighting* 0.1; + #endif + #if DEBUG_VIEW == debug_DIRECT + gl_FragData[0].rgb = Direct_lighting * 0.1; + #endif + + gl_FragData[3].a = clamp(lightmap.y,0.0,1.0); +} +} \ No newline at end of file diff --git a/shaders/dimensions/physics_ocean.vsh b/shaders/dimensions/physics_ocean.vsh new file mode 100644 index 00000000..d606987a --- /dev/null +++ b/shaders/dimensions/physics_ocean.vsh @@ -0,0 +1,232 @@ +#include "/lib/settings.glsl" +#include "/lib/res_params.glsl" +#include "/lib/bokeh.glsl" +#include "/lib/items.glsl" +#include "/lib/physics_ocean.glsl" + +uniform float frameTimeCounter; +#include "/lib/Shadow_Params.glsl" + +/* +!! DO NOT REMOVE !! +This code is from Chocapic13' shaders +Read the terms of modification and sharing before changing something below please ! +!! DO NOT REMOVE !! +*/ + +varying vec3 physics_localPosition; +varying float physics_localWaviness; + +varying vec4 lmtexcoord; +varying vec4 color; + +uniform sampler2D colortex4; +uniform sampler2D noisetex; +flat varying float exposure; + +#ifdef OVERWORLD_SHADER + flat varying vec3 averageSkyCol_Clouds; + flat varying vec4 lightCol; + flat varying vec3 WsunVec; + + #if defined Daily_Weather + flat varying vec4 dailyWeatherParams0; + flat varying vec4 dailyWeatherParams1; + #endif +#endif + +varying vec4 normalMat; +varying vec3 binormal; +varying vec4 tangent; +varying vec3 flatnormal; + +varying vec3 shitnormal; + +uniform mat4 gbufferModelViewInverse; +uniform mat4 gbufferModelView; +varying vec3 viewVector; + +flat varying int glass; + +attribute vec4 at_tangent; +attribute vec4 mc_Entity; + + +uniform vec3 sunPosition; +uniform vec3 cameraPosition; +uniform float sunElevation; + +varying vec4 tangent_other; + +uniform int frameCounter; +// uniform float far; +uniform float aspectRatio; +uniform float viewHeight; +uniform float viewWidth; +uniform int hideGUI; +uniform float screenBrightness; + +uniform int heldItemId; +uniform int heldItemId2; +flat varying float HELD_ITEM_BRIGHTNESS; + +uniform vec2 texelSize; +uniform int framemod8; + +const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.), + vec2(-1.,3.)/8., + vec2(5.0,1.)/8., + vec2(-3,-5.)/8., + vec2(-5.,5.)/8., + vec2(-7.,-1.)/8., + vec2(3,7.)/8., + vec2(7.,-7.)/8.); + +#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z) +#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz) + +vec4 toClipSpace3(vec3 viewSpacePosition) { + return vec4(projMAD(gl_ProjectionMatrix, viewSpacePosition),-viewSpacePosition.z); +} + + +// float getWave (vec3 pos, float range){ +// return pow(1.0-texture2D(noisetex, (pos.xz + frameTimeCounter * WATER_WAVE_SPEED)/150.0).b,2) * WATER_WAVE_STRENGTH / range; +// } +// vec3 getWaveNormal(vec3 posxz, float range){ + +// float deltaPos = 0.5; + +// vec3 coord = posxz; + +// float h0 = getWave(coord,range); +// float h1 = getWave(coord - vec3(deltaPos,0.0,0.0),range); +// float h3 = getWave(coord - vec3(0.0,0.0,deltaPos),range); + + +// float xDelta = (h1-h0)/deltaPos*1.5; +// float yDelta = (h3-h0)/deltaPos*1.5; + +// vec3 wave = normalize(vec3(xDelta, yDelta, 1.0-pow(abs(xDelta+yDelta),2.0))); + +// return wave; +// } +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// +//////////////////////////////VOID MAIN////////////////////////////// + +void main() { + + // lmtexcoord.xy = (gl_MultiTexCoord0).xy; + lmtexcoord.xy = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy; + vec2 lmcoord = gl_MultiTexCoord1.xy / 240.0; + lmtexcoord.zw = lmcoord; + + vec3 position = mat3(gl_ModelViewMatrix) * vec3(gl_Vertex) + gl_ModelViewMatrix[3].xyz; + + physics_localWaviness = texelFetch(physics_waviness, ivec2(gl_Vertex.xz) - physics_textureOffset, 0).r; + float waveOffsetY = physics_waveHeight(gl_Vertex.xz, PHYSICS_ITERATIONS_OFFSET, physics_localWaviness, physics_gameTime); + physics_localPosition = gl_Vertex.xyz;// + vec3(0.0, waveOffsetY, 0.0); + + vec3 displacedPos = mat3(gbufferModelViewInverse) * position + gbufferModelViewInverse[3].xyz; + + #ifdef DISTANT_HORIZONS + float range = min(1.0 + pow(length(displacedPos) / min(far,256.0),2.0), 256.0); + #else + float range = min(1.0 + pow(length(displacedPos) / 256,2.0), 256.0); + #endif + + + displacedPos.y += smoothstep(256.0, 200.0, range) * waveOffsetY; + //shitnormal = getWaveNormal(displacedPos, range); + shitnormal = vec3(0.0, 0.0, 1.0); + + position = mat3(gbufferModelView) * displacedPos + gbufferModelView[3].xyz; + + gl_Position = toClipSpace3(position); + + HELD_ITEM_BRIGHTNESS = 0.0; + + #ifdef Hand_Held_lights + if(heldItemId > 999 || heldItemId2 > 999) HELD_ITEM_BRIGHTNESS = 0.9; + #endif + + // 1.0 = water mask + float mat = 1.0; + + gl_Position.z -= 1e-4; + + // translucent entities + // #if defined ENTITIES || defined BLOCKENTITIES + // mat = 0.9; + // if (entityId == 1803) mat = 0.8; + // #endif + + // translucent blocks + // if (mc_Entity.x >= 301 && mc_Entity.x <= 321) mat = 0.7; + + tangent = vec4(normalize(gl_NormalMatrix *at_tangent.rgb),at_tangent.w); + + normalMat = vec4(normalize(gl_NormalMatrix * gl_Normal), 1.0); + normalMat.a = mat; + + vec3 tangent2 = normalize( gl_NormalMatrix *at_tangent.rgb); + binormal = normalize(cross(tangent2.rgb,normalMat.xyz)*at_tangent.w); + + mat3 tbnMatrix = mat3(tangent2.x, binormal.x, normalMat.x, + tangent2.y, binormal.y, normalMat.y, + tangent2.z, binormal.z, normalMat.z); + + flatnormal = normalMat.xyz; + + viewVector = position.xyz; + // viewVector = (gl_ModelViewMatrix * gl_Vertex).xyz; + viewVector = normalize(tbnMatrix * viewVector); + + + color = vec4(gl_Color.rgb, 1.0); + exposure = texelFetch2D(colortex4,ivec2(10,37),0).r; + + #ifdef OVERWORLD_SHADER + lightCol.rgb = texelFetch2D(colortex4,ivec2(6,37),0).rgb; + lightCol.a = float(sunElevation > 1e-5)*2.0 - 1.0; + + averageSkyCol_Clouds = texelFetch2D(colortex4,ivec2(0,37),0).rgb; + + WsunVec = lightCol.a * normalize(mat3(gbufferModelViewInverse) * sunPosition); + // WsunVec = normalize(LightDir); + + #if defined Daily_Weather + dailyWeatherParams0 = vec4((texelFetch2D(colortex4,ivec2(1,1),0).rgb/150.0)/2.0, 0.0); + dailyWeatherParams1 = vec4((texelFetch2D(colortex4,ivec2(2,1),0).rgb/150.0)/2.0, 0.0); + #endif + + #endif + + #ifdef TAA_UPSCALING + gl_Position.xy = gl_Position.xy * RENDER_SCALE + RENDER_SCALE * gl_Position.w - gl_Position.w; + #endif + #ifdef TAA + gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize; + #endif + + #if DOF_QUALITY == 5 + vec2 jitter = clamp(jitter_offsets[frameCounter % 64], -1.0, 1.0); + jitter = rotate(radians(float(frameCounter))) * jitter; + jitter.y *= aspectRatio; + jitter.x *= DOF_ANAMORPHIC_RATIO; + + #if MANUAL_FOCUS == -2 + float focusMul = 0; + #elif MANUAL_FOCUS == -1 + float focusMul = gl_Position.z - mix(pow(512.0, screenBrightness), 512.0 * screenBrightness, 0.25); + #else + float focusMul = gl_Position.z - MANUAL_FOCUS; + #endif + + vec2 totalOffset = (jitter * JITTER_STRENGTH) * focusMul * 1e-2; + gl_Position.xy += hideGUI >= 1 ? totalOffset : vec2(0); + #endif +} diff --git a/shaders/lib/physics_ocean.glsl b/shaders/lib/physics_ocean.glsl new file mode 100644 index 00000000..df5f76ae --- /dev/null +++ b/shaders/lib/physics_ocean.glsl @@ -0,0 +1,163 @@ +const int PHYSICS_ITERATIONS_OFFSET = 13; +const float PHYSICS_DRAG_MULT = 0.048; +const float PHYSICS_XZ_SCALE = 0.035; +const float PHYSICS_TIME_MULTIPLICATOR = 0.45; +const float PHYSICS_W_DETAIL = 0.75; +const float PHYSICS_FREQUENCY = 6.0; +const float PHYSICS_SPEED = 2.0; +const float PHYSICS_WEIGHT = 0.8; +const float PHYSICS_FREQUENCY_MULT = 1.18; +const float PHYSICS_SPEED_MULT = 1.07; +const float PHYSICS_ITER_INC = 12.0; +const float PHYSICS_NORMAL_STRENGTH = 1.0; + +// this is the surface detail from the physics options, ranges from 13 to 48 (yeah I know weird) +uniform int physics_iterationsNormal; +// used to offset the 0 point of wave meshes to keep the wave function consistent even +// though the mesh totally changes +uniform vec2 physics_waveOffset; +// used for offsetting the local position to fetch the right pixel of the waviness texture +uniform ivec2 physics_textureOffset; +// time in seconds that can go faster dependent on weather conditions (affected by weather strength +// multiplier in ocean settings +uniform float physics_gameTime; +// base value is 13 and gets multiplied by wave height in ocean settings +uniform float physics_oceanHeight; +// basic texture to determine how shallow/far away from the shore the water is +uniform sampler2D physics_waviness; +// basic scale for the horizontal size of the waves +uniform float physics_oceanWaveHorizontalScale; +// used to offset the model to know the ripple position +uniform vec3 physics_modelOffset; +// used for offsetting the ripple texture +uniform float physics_rippleRange; +// controlling how much foam generates on the ocean +uniform float physics_foamAmount; +// controlling the opacity of the foam +uniform float physics_foamOpacity; +// texture containing the ripples (basic bump map) +uniform sampler2D physics_ripples; +// foam noise +uniform sampler3D physics_foam; + +// ERROR: MISSING! +const float physics_globalTime = 0.0; + + +float physics_waveHeight(vec2 position, int iterations, float factor, float time) { + position = (position - physics_waveOffset) * PHYSICS_XZ_SCALE * physics_oceanWaveHorizontalScale; + float iter = 0.0; + float frequency = PHYSICS_FREQUENCY; + float speed = PHYSICS_SPEED; + float weight = 1.0; + float height = 0.0; + float waveSum = 0.0; + float modifiedTime = time * PHYSICS_TIME_MULTIPLICATOR; + + for (int i = 0; i < iterations; i++) { + vec2 direction = vec2(sin(iter), cos(iter)); + float x = dot(direction, position) * frequency + modifiedTime * speed; + float wave = exp(sin(x) - 1.0); + float result = wave * cos(x); + vec2 force = result * weight * direction; + + position -= force * PHYSICS_DRAG_MULT; + height += wave * weight; + iter += PHYSICS_ITER_INC; + waveSum += weight; + weight *= PHYSICS_WEIGHT; + frequency *= PHYSICS_FREQUENCY_MULT; + speed *= PHYSICS_SPEED_MULT; + } + + return height / waveSum * physics_oceanHeight * factor - physics_oceanHeight * factor * 0.5; +} + +vec3 physics_waveNormal(const in vec2 position, const in vec2 direction, const in float factor, const in float time) { + float oceanHeightFactor = physics_oceanHeight / 13.0; + float totalFactor = oceanHeightFactor * factor; + vec3 waveNormal = normalize(vec3(direction * totalFactor, PHYSICS_NORMAL_STRENGTH)); + + vec2 eyePosition = position + physics_modelOffset.xz; + vec2 rippleFetch = (eyePosition + vec2(physics_rippleRange)) / (physics_rippleRange * 2.0); + vec2 rippleTexelSize = vec2(2.0 / textureSize(physics_ripples, 0).x, 0.0); + float left = texture(physics_ripples, rippleFetch - rippleTexelSize.xy).r; + float right = texture(physics_ripples, rippleFetch + rippleTexelSize.xy).r; + float top = texture(physics_ripples, rippleFetch - rippleTexelSize.yx).r; + float bottom = texture(physics_ripples, rippleFetch + rippleTexelSize.yx).r; + float totalEffect = left + right + top + bottom; + + vec3 rippleNormal = normalize(vec3(left - right, top - bottom, 1.0)); + return normalize(mix(waveNormal, rippleNormal, sqrt(totalEffect))); +} + +#ifdef RENDER_FRAGMENT + struct WavePixelData { + vec2 direction; + vec2 worldPos; + vec3 normal; + float foam; + float height; + }; + + WavePixelData physics_wavePixel(vec2 position, const in float factor, const in float iterations, const in float time) { + #if WATER_SURFACE_PIXEL_RES > 0 + position = floor(position * WATER_SURFACE_PIXEL_RES) / WATER_SURFACE_PIXEL_RES; + #endif + + vec2 wavePos = (position.xy - physics_waveOffset) * PHYSICS_XZ_SCALE * physics_oceanWaveHorizontalScale; + float iter = 0.0; + float frequency = PHYSICS_FREQUENCY; + float speed = PHYSICS_SPEED; + float weight = 1.0; + float height = 0.0; + float waveSum = 0.0; + float modifiedTime = time * PHYSICS_TIME_MULTIPLICATOR; + vec2 dx = vec2(0.0); + + for (int i = 0; i < iterations; i++) { + vec2 direction = vec2(sin(iter), cos(iter)); + float x = dot(direction, wavePos) * frequency + modifiedTime * speed; + float wave = exp(sin(x) - 1.0); + float result = wave * cos(x); + vec2 force = result * weight * direction; + + dx += force / pow(weight, PHYSICS_W_DETAIL); + wavePos -= force * PHYSICS_DRAG_MULT; + height += wave * weight; + iter += PHYSICS_ITER_INC; + waveSum += weight; + weight *= PHYSICS_WEIGHT; + frequency *= PHYSICS_FREQUENCY_MULT; + speed *= PHYSICS_SPEED_MULT; + } + + WavePixelData data; + data.direction = -vec2(dx / pow(waveSum, 1.0 - PHYSICS_W_DETAIL)); + data.worldPos = wavePos / physics_oceanWaveHorizontalScale / PHYSICS_XZ_SCALE; + data.height = height / waveSum * physics_oceanHeight * factor - physics_oceanHeight * factor * 0.5; + + data.normal = physics_waveNormal(position, data.direction, factor, time); + + float waveAmplitude = max(data.normal.z, 0.0); + waveAmplitude = data.height * pow(waveAmplitude, 4); + vec2 waterUV = mix(position - physics_waveOffset, data.worldPos, clamp(factor * 2.0, 0.2, 1.0)); + + vec2 s1 = textureLod(physics_foam, vec3(waterUV * 0.26, physics_globalTime / 360.0), 0).rg; + vec2 s2 = textureLod(physics_foam, vec3(waterUV * 0.02, physics_globalTime / 360.0 + 0.5), 0).rg; + vec2 s3 = textureLod(physics_foam, vec3(waterUV * 0.1, physics_globalTime / 360.0 + 1.0), 0).rg; + + float waterSurfaceNoise = s1.r * s2.r * s3.r * 2.8 * physics_foamAmount; + waveAmplitude = saturate(waveAmplitude * 1.2); + waterSurfaceNoise = (1.0 - waveAmplitude) * waterSurfaceNoise + waveAmplitude * physics_foamAmount; + + float worleyNoise = 0.2 + 0.8 * s1.g * (1.0 - s2.g); + float waterFoamMinSmooth = 0.45; + float waterFoamMaxSmooth = 2.0; + waterSurfaceNoise = smoothstep(waterFoamMinSmooth, 1.0, waterSurfaceNoise) * worleyNoise; + + data.foam = saturate(waterFoamMaxSmooth * waterSurfaceNoise * physics_foamOpacity); + + return data; + } +#endif diff --git a/shaders/world0/physics_ocean.fsh b/shaders/world0/physics_ocean.fsh new file mode 100644 index 00000000..78dcfa20 --- /dev/null +++ b/shaders/world0/physics_ocean.fsh @@ -0,0 +1,5 @@ +#version 120 + +#define OVERWORLD_SHADER + +#include "/dimensions/physics_ocean.fsh" \ No newline at end of file diff --git a/shaders/world0/physics_ocean.vsh b/shaders/world0/physics_ocean.vsh new file mode 100644 index 00000000..c00aebbb --- /dev/null +++ b/shaders/world0/physics_ocean.vsh @@ -0,0 +1,5 @@ +#version 120 + +#define OVERWORLD_SHADER + +#include "/dimensions/physics_ocean.vsh" \ No newline at end of file