Backups/Bliss-Shader
1
0
Fork 0
mirror of https://github.com/X0nk/Bliss-Shader.git synced 2024-12-23 01:59:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix Emissives in end/nether. fix tiny labSSS curve issue

Browse Source
This commit is contained in:
Xonk 2023-07-01 15:53:13 -04:00
parent 825819c0cb
commit 08ff5ab8bb
12 changed files with 602 additions and 374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
shaders/gbuffers_all_solid.fsh
View File

@ -552,11 +552,10 @@ void main() {
#ifdef WORLD #ifdef WORLD
gl_FragData[5].x = 0;
#ifdef ENTITIES // #ifdef ENTITIES
gl_FragData[5].xyz = velocity *0.5+0.5; // gl_FragData[5].xyz = velocity *0.5+0.5;
#endif // #endif
gl_FragData[3] = vec4(FlatNormals * 0.5 + 0.5,VanillaAO); gl_FragData[3] = vec4(FlatNormals * 0.5 + 0.5,VanillaAO);
#endif #endif

4
shaders/lib/settings.glsl
View File

@ -148,10 +148,10 @@
// #define LabPBR_Emissives // #define LabPBR_Emissives
#define EMISSIVE_TYPE 2 // [0 1 2 3] #define EMISSIVE_TYPE 2 // [0 1 2 3]
#define Emissive_Brightness 10.0 // [1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 15.0 20.0 25.0 30.0 35.0 40.0 45.0 50.0 100.] #define Emissive_Brightness 10.0 // [1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 15.0 20.0 25.0 30.0 35.0 40.0 45.0 50.0 100.]
#define Emissive_Curve 2.0 // yes i blatantly copied kappa here. [1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0 ] #define Emissive_Curve 2.0 // yes i blatantly copied kappa here. [0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0 ]
#define LabPBR_subsurface_scattering #define LabPBR_subsurface_scattering
#define LabSSS_Curve 1.0 // i just really like how it looks at 2.0, so i made it an option. [0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0 ] #define LabSSS_Curve 1.0 // i just really like how it looks at 2.0, so i made it an option. [0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0 ]
//#define POM //#define POM
#define Adaptive_Step_length // make only used parts of the POM depth get samples, to increase overall quality. DOWNSIDE: at sheer angles, it looks kinda buggy. #define Adaptive_Step_length // make only used parts of the POM depth get samples, to increase overall quality. DOWNSIDE: at sheer angles, it looks kinda buggy.

400
shaders/programs/all_solid.fsh
View File

@ -4,7 +4,6 @@
#include "/lib/settings.glsl" #include "/lib/settings.glsl"
flat varying int NameTags; flat varying int NameTags;
#ifndef USE_LUMINANCE_AS_HEIGHTMAP #ifndef USE_LUMINANCE_AS_HEIGHTMAP
@ -30,31 +29,30 @@ const int MAX_OCCLUSION_POINTS = MAX_ITERATIONS;
uniform vec2 texelSize; uniform vec2 texelSize;
uniform int framemod8; uniform int framemod8;
#ifdef POM // #ifdef POM
varying vec4 vtexcoordam; // .st for add, .pq for mul varying vec4 vtexcoordam; // .st for add, .pq for mul
varying vec4 vtexcoord; varying vec4 vtexcoord;
#endif vec2 dcdx = dFdx(vtexcoord.st*vtexcoordam.pq)*exp2(Texture_MipMap_Bias);
vec2 dcdy = dFdy(vtexcoord.st*vtexcoordam.pq)*exp2(Texture_MipMap_Bias);
// #endif
#include "/lib/res_params.glsl" #include "/lib/res_params.glsl"
varying vec4 lmtexcoord; varying vec4 lmtexcoord;
varying vec4 color; varying vec4 color;
varying vec4 NoSeasonCol; varying vec4 NoSeasonCol;
varying vec4 seasonColor; varying vec4 seasonColor;
uniform float far; uniform float far;
varying vec4 normalMat; varying vec4 normalMat;
#ifdef MC_NORMAL_MAP #ifdef MC_NORMAL_MAP
varying vec4 tangent; varying vec4 tangent;
uniform float wetness; uniform sampler2D normals;
uniform sampler2D normals; varying vec3 FlatNormals;
uniform sampler2D specular;
varying vec3 FlatNormals;
#endif #endif
#ifdef POM uniform sampler2D specular;
vec2 dcdx = dFdx(vtexcoord.st*vtexcoordam.pq)*exp2(Texture_MipMap_Bias);
vec2 dcdy = dFdy(vtexcoord.st*vtexcoordam.pq)*exp2(Texture_MipMap_Bias);
#endif
flat varying int lightningBolt; flat varying int lightningBolt;
uniform sampler2D texture; uniform sampler2D texture;
@ -69,37 +67,19 @@ uniform vec3 cameraPosition;
uniform float rainStrength; uniform float rainStrength;
uniform sampler2D noisetex;//depth uniform sampler2D noisetex;//depth
uniform sampler2D depthtex0; uniform sampler2D depthtex0;
in vec3 test_motionVectors;
flat varying float blockID; flat varying float blockID;
flat varying float SSSAMOUNT;
flat varying float EMISSIVE;
flat varying int LIGHTNING;
flat varying int SIGN;
// float interleaved_gradientNoise(){
// return fract(52.9829189*fract(0.06711056*gl_FragCoord.x + 0.00583715*gl_FragCoord.y)+frameTimeCounter*51.9521);
// }
// float interleaved_gradientNoise(){
// vec2 alpha = vec2(0.75487765, 0.56984026);
// vec2 coord = vec2(alpha.x * gl_FragCoord.x,alpha.y * gl_FragCoord.y)+ 1.0/1.6180339887 * frameCounter;
// float noise = fract(52.9829189*fract(0.06711056*coord.x + 0.00583715*coord.y));
// return noise;
// }
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 blueNoise(){ float blueNoise(){
return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter); return fract(texelFetch2D(noisetex, ivec2(gl_FragCoord.xy)%512, 0).a + 1.0/1.6180339887 * frameCounter);
} }
float R2_dither(){
vec2 alpha = vec2(0.75487765, 0.56984026);
return fract(alpha.x * gl_FragCoord.x + alpha.y * gl_FragCoord.y + 1.0/1.6180339887 * frameCounter) ;
}
vec2 decodeVec2(float a){
const vec2 constant1 = 65535. / vec2( 256., 65536.);
const float constant2 = 256. / 255.;
return fract( a * constant1 ) * constant2 ;
}
mat3 inverse(mat3 m) { mat3 inverse(mat3 m) {
float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2]; float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];
float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2]; float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];
@ -116,26 +96,6 @@ mat3 inverse(mat3 m) {
b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det; b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;
} }
vec3 viewToWorld(vec3 viewPosition) {
vec4 pos;
pos.xyz = viewPosition;
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));
}
#ifdef MC_NORMAL_MAP #ifdef MC_NORMAL_MAP
vec3 applyBump(mat3 tbnMatrix, vec3 bump, float puddle_values){ vec3 applyBump(mat3 tbnMatrix, vec3 bump, float puddle_values){
@ -145,6 +105,28 @@ vec4 encode (vec3 n, vec2 lightmaps){
} }
#endif #endif
vec3 viewToWorld(vec3 viewPosition) {
vec4 pos;
pos.xyz = viewPosition;
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 //encoding by jodie
float encodeVec2(vec2 a){ float encodeVec2(vec2 a){
const vec2 constant1 = vec2( 1., 256.) / 65535.; const vec2 constant1 = vec2( 1., 256.) / 65535.;
@ -167,26 +149,22 @@ vec3 toScreenSpace(vec3 p) {
vec3 toClipSpace3(vec3 viewSpacePosition) { vec3 toClipSpace3(vec3 viewSpacePosition) {
return projMAD(gbufferProjection, viewSpacePosition) / -viewSpacePosition.z * 0.5 + 0.5; return projMAD(gbufferProjection, viewSpacePosition) / -viewSpacePosition.z * 0.5 + 0.5;
} }
#ifdef POM #ifdef POM
vec4 readNormal(in vec2 coord) vec4 readNormal(in vec2 coord)
{ {
return texture2DGradARB(normals,fract(coord)*vtexcoordam.pq+vtexcoordam.st,dcdx,dcdy); return texture2DGradARB(normals,fract(coord)*vtexcoordam.pq+vtexcoordam.st,dcdx,dcdy);
} }
vec4 readTexture(in vec2 coord) vec4 readTexture(in vec2 coord)
{ {
return texture2DGradARB(texture,fract(coord)*vtexcoordam.pq+vtexcoordam.st,dcdx,dcdy); return texture2DGradARB(texture,fract(coord)*vtexcoordam.pq+vtexcoordam.st,dcdx,dcdy);
} }
#endif #endif
float luma(vec3 color) { float luma(vec3 color) {
return dot(color,vec3(0.21, 0.72, 0.07)); return dot(color,vec3(0.21, 0.72, 0.07));
} }
vec3 toLinear(vec3 sRGB){
return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878);
}
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.), const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
vec2(-1.,3.)/8., vec2(-1.,3.)/8.,
vec2(5.0,1.)/8., vec2(5.0,1.)/8.,
@ -195,55 +173,42 @@ const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
vec2(-7.,-1.)/8., vec2(-7.,-1.)/8.,
vec2(3,7.)/8., vec2(3,7.)/8.,
vec2(7.,-7.)/8.); vec2(7.,-7.)/8.);
vec3 srgbToLinear2(vec3 srgb){
return mix(
srgb / 12.92,
pow(.947867 * srgb + .0521327, vec3(2.4) ),
step( .04045, srgb )
);
}
vec3 blackbody2(float Temp)
{
float t = pow(Temp, -1.5);
float lt = log(Temp);
vec3 col = vec3(0.0); float bias(){
col.x = 220000.0 * t + 0.58039215686; return Texture_MipMap_Bias + (blueNoise()-0.5)*0.5;
col.y = 0.39231372549 * lt - 2.44549019608;
col.y = Temp > 6500. ? 138039.215686 * t + 0.72156862745 : col.y;
col.z = 0.76078431372 * lt - 5.68078431373;
col = clamp(col,0.0,1.0);
col = Temp < 1000. ? col * Temp * 0.001 : col;
return srgbToLinear2(col);
}
float densityAtPosSNOW(in vec3 pos){
pos /= 18.;
pos.xz *= 0.5;
vec3 p = floor(pos);
vec3 f = fract(pos);
f = (f*f) * (3.-2.*f);
vec2 uv = p.xz + f.xz + p.y * vec2(0.0,193.0);
vec2 coord = uv / 512.0;
vec2 xy = texture2D(noisetex, coord).yx;
return mix(xy.r,xy.g, f.y);
} }
vec4 texture2D_POMSwitch(
sampler2D sampler,
vec2 lightmapCoord,
vec4 dcdxdcdy,
bool ifPOM
){
if(ifPOM){
return texture2DGradARB(sampler, lightmapCoord, dcdxdcdy.xy, dcdxdcdy.zw);
}else{
return texture2D(sampler, lightmapCoord, bias());
}
}
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
/* RENDERTARGETS: 1,7,8,15,10 */ /* RENDERTARGETS: 1,7,8,15 */
void main() { void main() {
float phi = 2 * 3.14159265359; bool ifPOM = false;
float noise = fract(fract(frameCounter * (1.0 / phi)) + interleaved_gradientNoise() ) ;
#ifdef POM
ifPOM = true;
#endif
if(SIGN > 0) ifPOM = false;
vec3 normal = normalMat.xyz; vec3 normal = normalMat.xyz;
vec3 normal2 = normalMat.xyz;
#ifdef MC_NORMAL_MAP #ifdef MC_NORMAL_MAP
vec3 tangent2 = normalize(cross(tangent.rgb,normal)*tangent.w); vec3 tangent2 = normalize(cross(tangent.rgb,normal)*tangent.w);
@ -258,31 +223,39 @@ void main() {
vec3 worldpos = mat3(gbufferModelViewInverse) * fragpos + gbufferModelViewInverse[3].xyz + cameraPosition; vec3 worldpos = mat3(gbufferModelViewInverse) * fragpos + gbufferModelViewInverse[3].xyz + cameraPosition;
float torchlightmap = lmtexcoord.z;
// #ifdef Hand_Held_lights
// if(HELD_ITEM_BRIGHTNESS > 0.0) torchlightmap = max(torchlightmap, HELD_ITEM_BRIGHTNESS * clamp( pow(max(1.0-length(fragpos)/10,0.0),1.5),0.0,1.0));
// #endif
float lightmap = clamp( (lmtexcoord.w-0.8) * 10.0,0.,1.); float lightmap = clamp( (lmtexcoord.w-0.8) * 10.0,0.,1.);
vec2 adjustedTexCoord = lmtexcoord.xy;
#ifdef POM #ifdef POM
// vec2 tempOffset=offsets[framemod8];
vec2 adjustedTexCoord = fract(vtexcoord.st)*vtexcoordam.pq+vtexcoordam.st; adjustedTexCoord = fract(vtexcoord.st)*vtexcoordam.pq+vtexcoordam.st;
// vec3 fragpos = toScreenSpace(gl_FragCoord.xyz*vec3(texelSize/RENDER_SCALE,1.0)-vec3(vec2(tempOffset)*texelSize*0.5,0.0));
vec3 viewVector = normalize(tbnMatrix*fragpos); vec3 viewVector = normalize(tbnMatrix*fragpos);
float dist = length(fragpos); float dist = length(fragpos);
gl_FragDepth = gl_FragCoord.z; gl_FragDepth = gl_FragCoord.z;
#ifdef WORLD #ifdef WORLD
if (dist < MAX_OCCLUSION_DISTANCE) { if (dist < MAX_OCCLUSION_DISTANCE) {
float depthmap = readNormal(vtexcoord.st).a; float depthmap = readNormal(vtexcoord.st).a;
float used_POM_DEPTH = 1.0; float used_POM_DEPTH = 1.0;
if ( viewVector.z < 0.0 && depthmap < 0.9999 && depthmap > 0.00001) { if ( viewVector.z < 0.0 && depthmap < 0.9999 && depthmap > 0.00001) {
#ifdef Adaptive_Step_length #ifdef Adaptive_Step_length
vec3 interval = (viewVector.xyz /-viewVector.z/MAX_OCCLUSION_POINTS * POM_DEPTH) * clamp(1.0-pow(depthmap,2),0.1,1.0) ; vec3 interval = (viewVector.xyz /-viewVector.z/MAX_OCCLUSION_POINTS * POM_DEPTH) * clamp(1.0-pow(depthmap,2),0.1,1.0) ;
used_POM_DEPTH = 1.0; used_POM_DEPTH = 1.0;
#else #else
vec3 interval = viewVector.xyz /-viewVector.z/MAX_OCCLUSION_POINTS*POM_DEPTH; vec3 interval = viewVector.xyz /-viewVector.z/MAX_OCCLUSION_POINTS*POM_DEPTH;
#endif #endif
vec3 coord = vec3(vtexcoord.st, 1.0); vec3 coord = vec3(vtexcoord.st, 1.0);
@ -293,134 +266,121 @@ void main() {
coord = coord+interval * used_POM_DEPTH; coord = coord+interval * used_POM_DEPTH;
sumVec += 1.0 * used_POM_DEPTH; sumVec += 1.0 * used_POM_DEPTH;
} }
if (coord.t < mincoord) { if (coord.t < mincoord) {
if (readTexture(vec2(coord.s,mincoord)).a == 0.0) { if (readTexture(vec2(coord.s,mincoord)).a == 0.0) {
coord.t = mincoord; coord.t = mincoord;
discard; discard;
} }
} }
adjustedTexCoord = mix(fract(coord.st)*vtexcoordam.pq+vtexcoordam.st, adjustedTexCoord, max(dist-MIX_OCCLUSION_DISTANCE,0.0)/(MAX_OCCLUSION_DISTANCE-MIX_OCCLUSION_DISTANCE)); adjustedTexCoord = mix(fract(coord.st)*vtexcoordam.pq+vtexcoordam.st, adjustedTexCoord, max(dist-MIX_OCCLUSION_DISTANCE,0.0)/(MAX_OCCLUSION_DISTANCE-MIX_OCCLUSION_DISTANCE));
vec3 truePos = fragpos + sumVec*inverse(tbnMatrix)*interval; vec3 truePos = fragpos + sumVec*inverse(tbnMatrix)*interval;
// #ifdef Depth_Write_POM
gl_FragDepth = toClipSpace3(truePos).z; gl_FragDepth = toClipSpace3(truePos).z;
// #endif
} }
} }
#endif #endif
#endif
//////////////////////////////// if(!ifPOM) adjustedTexCoord = lmtexcoord.xy;
//////////////////////////////// ALBEDO
////////////////////////////////
vec4 Albedo = texture2DGradARB(texture, adjustedTexCoord.xy,dcdx,dcdy) * color; ////////////////////////////////
//////////////////////////////// ALBEDO
#ifdef ENTITIES ////////////////////////////////
if(NameTags == 1) Albedo = texture2D(texture, lmtexcoord.xy, Texture_MipMap_Bias) * color;
#endif
#ifdef WORLD vec4 Albedo = texture2D_POMSwitch(texture, adjustedTexCoord.xy, vec4(dcdx,dcdy), ifPOM) * color;
if (Albedo.a > 0.1) Albedo.a = normalMat.a; if(LIGHTNING > 0) Albedo = vec4(1);
else Albedo.a = 0.0;
#endif
#ifdef HAND #ifdef WORLD
if (Albedo.a > 0.1) Albedo.a = 0.75; if (Albedo.a > 0.1) Albedo.a = normalMat.a;
else Albedo.a = 0.0; else Albedo.a = 0.0;
#endif #endif
//////////////////////////////// #ifdef HAND
//////////////////////////////// NORMAL if (Albedo.a > 0.1) Albedo.a = 0.75;
//////////////////////////////// else Albedo.a = 0.0;
#endif
////////////////////////////////
//////////////////////////////// NORMAL
////////////////////////////////
#ifdef WORLD
#ifdef MC_NORMAL_MAP #ifdef MC_NORMAL_MAP
vec3 NormalTex = texture2DGradARB(normals, adjustedTexCoord.xy, dcdx,dcdy).rgb;
NormalTex.xy = NormalTex.xy*2.0-1.0;
NormalTex.z = clamp(sqrt(1.0 - dot(NormalTex.xy, NormalTex.xy)),0.0,1.0);
normal = applyBump(tbnMatrix,NormalTex, 1.0);
#endif
////////////////////////////////
//////////////////////////////// SPECULAR
////////////////////////////////
gl_FragData[2] = texture2DGradARB(specular, adjustedTexCoord.xy,dcdx,dcdy);
////////////////////////////////
//////////////////////////////// FINALIZE
////////////////////////////////
vec4 data1 = clamp(encode(viewToWorld(normal), lmtexcoord.zw),0.,1.0);
gl_FragData[0] = vec4(encodeVec2(Albedo.x,data1.x),encodeVec2(Albedo.y,data1.y),encodeVec2(Albedo.z,data1.z),encodeVec2(data1.w,Albedo.w));
gl_FragData[1].a = 0.0; vec4 NormalTex = texture2D_POMSwitch(normals, adjustedTexCoord.xy, vec4(dcdx,dcdy), ifPOM);
#else
////////////////////////////////
//////////////////////////////// NORMAL
////////////////////////////////
#ifdef MC_NORMAL_MAP
vec4 NormalTex = texture2D(normals, lmtexcoord.xy, Texture_MipMap_Bias).rgba;
NormalTex.xy = NormalTex.xy*2.0-1.0; NormalTex.xy = NormalTex.xy*2.0-1.0;
NormalTex.z = clamp(sqrt(1.0 - dot(NormalTex.xy, NormalTex.xy)),0.0,1.0) ; NormalTex.z = clamp(sqrt(1.0 - dot(NormalTex.xy, NormalTex.xy)),0.0,1.0) ;
normal = applyBump(tbnMatrix, NormalTex.xyz, 1.0); normal = applyBump(tbnMatrix, NormalTex.xyz, 1.0);
#endif #endif
////////////////////////////////
//////////////////////////////// SPECULAR
////////////////////////////////
vec4 SpecularTex = texture2D(specular, lmtexcoord.xy, Texture_MipMap_Bias);
gl_FragData[2] = SpecularTex;
////////////////////////////////
//////////////////////////////// ALBEDO
////////////////////////////////
vec4 Albedo = texture2D(texture, lmtexcoord.xy, Texture_MipMap_Bias) * color;
#ifdef WhiteWorld
Albedo.rgb = vec3(1.0);
#endif
#ifdef WORLD
if (Albedo.a > 0.1) Albedo.a = normalMat.a;
else Albedo.a = 0.0;
#endif
#ifdef HAND
if (Albedo.a > 0.1) Albedo.a = 0.75;
else Albedo.a = 0.0;
#endif
////////////////////////////////
//////////////////////////////// FINALIZE
////////////////////////////////
vec4 data1 = clamp( encode(viewToWorld(normal), blueNoise()*lmtexcoord.zw/50.0+lmtexcoord.zw ),0.0,1.0);
gl_FragData[0] = vec4(encodeVec2(Albedo.x,data1.x), encodeVec2(Albedo.y,data1.y), encodeVec2(Albedo.z,data1.z), encodeVec2(data1.w,Albedo.w));
#ifdef WORLD
gl_FragData[1].a = 0.0;
#endif
#endif #endif
gl_FragData[3] = vec4(FlatNormals* 0.5 + 0.5,VanillaAO); ////////////////////////////////
//////////////////////////////// SPECULAR
////////////////////////////////
#ifdef WORLD
vec4 SpecularTex = texture2D_POMSwitch(specular, adjustedTexCoord.xy, vec4(dcdx,dcdy), ifPOM);
gl_FragData[4].x = 0; gl_FragData[2].rg = SpecularTex.rg;
#ifdef ENTITIES #if EMISSIVE_TYPE == 0
gl_FragData[4].x = 1; gl_FragData[2].a = 0.0;
#endif
#if EMISSIVE_TYPE == 1
gl_FragData[2].a = EMISSIVE;
#endif
#if EMISSIVE_TYPE == 2
gl_FragData[2].a = SpecularTex.a;
if(SpecularTex.a <= 0.0) gl_FragData[2].a = EMISSIVE;
#endif
#if EMISSIVE_TYPE == 3
gl_FragData[2].a = SpecularTex.a;
#endif
#if SSS_TYPE == 0
gl_FragData[2].b = 0.0;
#endif
#if SSS_TYPE == 1
gl_FragData[2].b = SSSAMOUNT;
#endif
#if SSS_TYPE == 2
gl_FragData[2].b = SpecularTex.b;
if(SpecularTex.b < 65.0/255.0) gl_FragData[2].b = SSSAMOUNT;
#endif
#if SSS_TYPE == 3
gl_FragData[2].b = SpecularTex.b;
#endif
#endif #endif
////////////////////////////////
//////////////////////////////// FINALIZE
////////////////////////////////
vec4 data1 = clamp( encode(viewToWorld(normal), (blueNoise()*vec2(torchlightmap,lmtexcoord.w) / (30.0 * (1+ (1-RENDER_SCALE.x))) ) + vec2(torchlightmap,lmtexcoord.w)), 0.0, 1.0);
gl_FragData[0] = vec4(encodeVec2(Albedo.x,data1.x), encodeVec2(Albedo.y,data1.y), encodeVec2(Albedo.z,data1.z), encodeVec2(data1.w,Albedo.w));
gl_FragData[1].a = 0.0;
////////////////////////////////
//////////////////////////////// OTHER STUFF
////////////////////////////////
#ifdef WORLD
gl_FragData[3] = vec4(FlatNormals * 0.5 + 0.5,VanillaAO);
#endif
// gl_FragData[4].x = 0;
// #ifdef ENTITIES
// gl_FragData[4].x = 1;
// #endif
} }

252
shaders/programs/all_solid.vsh
View File

@ -1,5 +1,6 @@
#extension GL_EXT_gpu_shader4 : enable #extension GL_EXT_gpu_shader4 : enable
#include "/lib/settings.glsl" #include "/lib/settings.glsl"
#include "/lib/res_params.glsl" #include "/lib/res_params.glsl"
/* /*
@ -10,14 +11,18 @@ Read the terms of modification and sharing before changing something below pleas
*/ */
#ifdef HAND
#undef POM
#endif
#ifndef USE_LUMINANCE_AS_HEIGHTMAP #ifndef USE_LUMINANCE_AS_HEIGHTMAP
#ifndef MC_NORMAL_MAP #ifndef MC_NORMAL_MAP
#undef POM #undef POM
#endif #endif
#endif #endif
#ifdef POM #ifdef POM
#define MC_NORMAL_MAP #define MC_NORMAL_MAP
#endif #endif
@ -27,10 +32,10 @@ varying float VanillaAO;
varying vec4 lmtexcoord; varying vec4 lmtexcoord;
varying vec4 normalMat; varying vec4 normalMat;
#ifdef POM // #ifdef POM
varying vec4 vtexcoordam; // .st for add, .pq for mul varying vec4 vtexcoordam; // .st for add, .pq for mul
varying vec4 vtexcoord; varying vec4 vtexcoord;
#endif // #endif
#ifdef MC_NORMAL_MAP #ifdef MC_NORMAL_MAP
varying vec4 tangent; varying vec4 tangent;
@ -38,17 +43,35 @@ varying vec4 normalMat;
varying vec3 FlatNormals; varying vec3 FlatNormals;
#endif #endif
uniform float frameTimeCounter;
const float PI48 = 150.796447372*WAVY_SPEED;
float pi2wt = PI48*frameTimeCounter;
attribute vec4 mc_Entity; attribute vec4 mc_Entity;
uniform int blockEntityId; uniform int blockEntityId;
uniform int entityId; uniform int entityId;
flat varying float blockID; flat varying float blockID;
uniform int heldItemId;
uniform int heldItemId2;
flat varying float HELD_ITEM_BRIGHTNESS;
flat varying int PHYSICSMOD_SNOW;
flat varying int NameTags; flat varying int NameTags;
attribute vec4 mc_midTexCoord; flat varying float SSSAMOUNT;
flat varying float EMISSIVE;
flat varying int LIGHTNING;
flat varying int PORTAL;
flat varying int SIGN;
uniform mat4 gbufferModelView;
uniform mat4 gbufferModelViewInverse;
attribute vec4 mc_midTexCoord;
uniform vec3 cameraPosition;
uniform vec2 texelSize; uniform vec2 texelSize;
uniform int framemod8; uniform int framemod8;
@ -60,80 +83,233 @@ const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
vec2(-7.,-1.)/8., vec2(-7.,-1.)/8.,
vec2(3,7.)/8., vec2(3,7.)/8.,
vec2(7.,-7.)/8.); vec2(7.,-7.)/8.);
#define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z) #define diagonal3(m) vec3((m)[0].x, (m)[1].y, m[2].z)
#define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz) #define projMAD(m, v) (diagonal3(m) * (v) + (m)[3].xyz)
vec4 toClipSpace3(vec3 viewSpacePosition) { vec4 toClipSpace3(vec3 viewSpacePosition) {
return vec4(projMAD(gl_ProjectionMatrix, viewSpacePosition),-viewSpacePosition.z); return vec4(projMAD(gl_ProjectionMatrix, viewSpacePosition),-viewSpacePosition.z);
} }
vec2 calcWave(in vec3 pos) {
float magnitude = abs(sin(dot(vec4(frameTimeCounter, pos),vec4(1.0,0.005,0.005,0.005)))*0.5+0.72)*0.013;
vec2 ret = (sin(pi2wt*vec2(0.0063,0.0015)*4. - pos.xz + pos.y*0.05)+0.1)*magnitude;
return ret;
}
vec3 calcMovePlants(in vec3 pos) {
vec2 move1 = calcWave(pos );
float move1y = -length(move1);
return vec3(move1.x,move1y,move1.y)*5.*WAVY_STRENGTH;
}
vec3 calcWaveLeaves(in vec3 pos, in float fm, in float mm, in float ma, in float f0, in float f1, in float f2, in float f3, in float f4, in float f5) {
float magnitude = abs(sin(dot(vec4(frameTimeCounter, pos),vec4(1.0,0.005,0.005,0.005)))*0.5+0.72)*0.013;
vec3 ret = (sin(pi2wt*vec3(0.0063,0.0224,0.0015)*1.5 - pos))*magnitude;
return ret;
}
vec3 calcMoveLeaves(in vec3 pos, in float f0, in float f1, in float f2, in float f3, in float f4, in float f5, in vec3 amp1, in vec3 amp2) {
vec3 move1 = calcWaveLeaves(pos , 0.0054, 0.0400, 0.0400, 0.0127, 0.0089, 0.0114, 0.0063, 0.0224, 0.0015) * amp1;
return move1*5.*WAVY_STRENGTH;
}
vec3 srgbToLinear2(vec3 srgb){
return mix(
srgb / 12.92,
pow(.947867 * srgb + .0521327, vec3(2.4) ),
step( .04045, srgb )
);
}
vec3 blackbody2(float Temp)
{
float t = pow(Temp, -1.5);
float lt = log(Temp);
vec3 col = vec3(0.0);
col.x = 220000.0 * t + 0.58039215686;
col.y = 0.39231372549 * lt - 2.44549019608;
col.y = Temp > 6500. ? 138039.215686 * t + 0.72156862745 : col.y;
col.z = 0.76078431372 * lt - 5.68078431373;
col = clamp(col,0.0,1.0);
col = Temp < 1000. ? col * Temp * 0.001 : col;
return srgbToLinear2(col);
}
// float luma(vec3 color) {
// return dot(color,vec3(0.21, 0.72, 0.07));
// }
#define SEASONS_VSH
#include "/lib/climate_settings.glsl"
uniform sampler2D noisetex;//depth
float densityAtPos(in vec3 pos){
pos /= 18.;
pos.xz *= 0.5;
vec3 p = floor(pos);
vec3 f = fract(pos);
vec2 uv = p.xz + f.xz + p.y * vec2(0.0,193.0);
vec2 coord = uv / 512.0;
//The y channel has an offset to avoid using two textures fetches
vec2 xy = texture2D(noisetex, coord).yx;
return mix(xy.r,xy.g, f.y);
}
float luma(vec3 color) {
return dot(color,vec3(0.21, 0.72, 0.07));
}
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
void main() { void main() {
gl_Position = ftransform(); gl_Position = ftransform();
lmtexcoord.xy = (gl_MultiTexCoord0).xy;
FlatNormals = normalize(gl_NormalMatrix * gl_Normal);
NameTags = 0;
blockID = mc_Entity.x;
#ifdef POM
vec2 midcoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
vec2 texcoordminusmid = lmtexcoord.xy-midcoord;
vtexcoordam.pq = abs(texcoordminusmid)*2;
vtexcoordam.st = min(lmtexcoord.xy,midcoord-texcoordminusmid);
vtexcoord.xy = sign(texcoordminusmid)*0.5+0.5;
#endif
vec2 lmcoord = gl_MultiTexCoord1.xy/255.;
lmtexcoord.zw = lmcoord;
vec3 position = mat3(gl_ModelViewMatrix) * vec3(gl_Vertex) + gl_ModelViewMatrix[3].xyz; vec3 position = mat3(gl_ModelViewMatrix) * vec3(gl_Vertex) + gl_ModelViewMatrix[3].xyz;
color = gl_Color;
/////// ----- COLOR STUFF ----- ///////
color = gl_Color;
VanillaAO = 1.0 - clamp(color.a,0,1); VanillaAO = 1.0 - clamp(color.a,0,1);
if (color.a < 0.3) color.a = 1.0; // fix vanilla ao on some custom block models. if (color.a < 0.3) color.a = 1.0; // fix vanilla ao on some custom block models.
/////// ----- RANDOM STUFF ----- ///////
lmtexcoord.xy = (gl_MultiTexCoord0).xy;
// #ifdef POM
vec2 midcoord = (gl_TextureMatrix[0] * mc_midTexCoord).st;
vec2 texcoordminusmid = lmtexcoord.xy-midcoord;
vtexcoordam.pq = abs(texcoordminusmid)*2;
vtexcoordam.st = min(lmtexcoord.xy,midcoord-texcoordminusmid);
vtexcoord.xy = sign(texcoordminusmid)*0.5+0.5;
// #endif
vec2 lmcoord = gl_MultiTexCoord1.xy / 255.0; // is this even correct? lol'
lmtexcoord.zw = lmcoord;
#ifdef MC_NORMAL_MAP #ifdef MC_NORMAL_MAP
tangent = vec4(normalize(gl_NormalMatrix *at_tangent.rgb),at_tangent.w); tangent = vec4(normalize(gl_NormalMatrix *at_tangent.rgb),at_tangent.w);
#endif #endif
normalMat = vec4(normalize(gl_NormalMatrix *gl_Normal), 1.0); normalMat = vec4(normalize(gl_NormalMatrix *gl_Normal), 1.0);
FlatNormals = normalMat.xyz;
blockID = mc_Entity.x;
SIGN = 0;
#ifdef WORLD
// disallow POM to work on signs.
if(blockEntityId == 2200) SIGN = 1;
#endif
NameTags = 0;
PHYSICSMOD_SNOW = 0;
#ifdef ENTITIES #ifdef ENTITIES
// try and single out nametag text and then discard nametag background // disallow POM to work on item frames.
if( dot(gl_Color.rgb, vec3(0.35)) < 1.0) NameTags = 1; if(entityId == 2300) SIGN = 1;
if(gl_Color.a >= 0.24 && gl_Color.a <= 0.25 ) gl_Position = vec4(10,10,10,1); #ifdef ENTITY_PHYSICSMOD_SNOW
if(entityId == 829925) PHYSICSMOD_SNOW = 1;
#endif
// try and single out nametag text and then discard nametag background
// if( dot(gl_Color.rgb, vec3(1.0/3.0)) < 1.0) NameTags = 1;
// if(gl_Color.a < 1.0) NameTags = 1;
// if(gl_Color.a >= 0.24 && gl_Color.a <= 0.25 ) gl_Position = vec4(10,10,10,1);
if(entityId == 1100 || entityId == 1200 || entityId == 2468) normalMat.a = 0.45;
#endif #endif
if(mc_Entity.x == 10003) normalMat.a = 0.55;
/////// ----- EMISSIVE STUFF ----- ///////
EMISSIVE = 0.0;
LIGHTNING = 0;
// if(NameTags > 0) EMISSIVE = 0.9;
// normal block lightsources
if(mc_Entity.x == 10005) EMISSIVE = 0.5;
// special cases light lightning and beacon beams...
#ifdef ENTITIES
if(entityId == 12345){
LIGHTNING = 1;
normalMat.a = 0.5;
}
#endif
/////// ----- SSS STUFF ----- ///////
SSSAMOUNT = 0.0;
HELD_ITEM_BRIGHTNESS = 0.0;
#ifdef Hand_Held_lights
if(heldItemId == 100 || heldItemId2 == 100) HELD_ITEM_BRIGHTNESS = 0.9;
#endif
#ifdef WORLD #ifdef WORLD
normalMat = vec4(normalize(gl_NormalMatrix *gl_Normal),mc_Entity.x == 10004 || mc_Entity.x == 10003 ? 0.5 : mc_Entity.x == 10001 ? 0.6 : 1.0); /////// ----- SSS ON BLOCKS ----- ///////
// strong
if(mc_Entity.x == 10001 || mc_Entity.x == 10003 || mc_Entity.x == 10004) SSSAMOUNT = 1.0;
// medium
if(mc_Entity.x == 10006 || mc_Entity.x == 200) SSSAMOUNT = 0.75;
// low
if(mc_Entity.x == 10007 || mc_Entity.x == 10008) SSSAMOUNT = 0.5;
#ifdef ENTITIES
/////// ----- SSS ON MOBS----- ///////
// strong
if(entityId == 1100) SSSAMOUNT = 0.75;
normalMat.a = mc_Entity.x == 10005 ? 0.8 : normalMat.a; // medium
if (mc_Entity.x == 100 ){ // low
color.rgb = normalize(color.rgb)*sqrt(3.0); if(entityId == 1200) SSSAMOUNT = 0.3;
normalMat.a = 0.9; #endif
}
#ifdef BLOCKENTITIES
/////// ----- SSS ON BLOCK ENTITIES----- ///////
// strong
// medium
if(blockEntityId == 10010) SSSAMOUNT = 0.4;
// low
#endif
gl_Position = toClipSpace3(position);
#endif #endif
gl_Position = toClipSpace3(position);
// #ifdef TAA_UPSCALING
// gl_Position.xy = gl_Position.xy * RENDER_SCALE + RENDER_SCALE * gl_Position.w - gl_Position.w;
// #endif
#ifdef TAA #ifdef TAA
gl_Position.xy += offsets[framemod8] * gl_Position.w * texelSize; gl_Position.xy += offsets[framemod8] * gl_Position.w * texelSize;

68
shaders/world-1/composite2.fsh
View File

@ -315,7 +315,6 @@ void LabEmission(
} }
vec3 SubsurfaceScattering_sky(vec3 albedo, float Scattering, float Density){ vec3 SubsurfaceScattering_sky(vec3 albedo, float Scattering, float Density){
vec3 absorbed = max(luma(albedo) - albedo,0.0); vec3 absorbed = max(luma(albedo) - albedo,0.0);
@ -382,13 +381,6 @@ void ScreenSpace_SSS(inout float sss, vec3 fragpos, vec2 noise, vec3 normal){
void main() { void main() {
float dirtAmount = Dirt_Amount; float dirtAmount = Dirt_Amount;
vec3 waterEpsilon = vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B); vec3 waterEpsilon = vec3(Water_Absorb_R, Water_Absorb_G, Water_Absorb_B);
@ -407,30 +399,45 @@ void main() {
vec3 np3 = normVec(p3); vec3 np3 = normVec(p3);
vec4 trpData = texture2D(colortex7,texcoord); ////// --------------- UNPACK OPAQUE GBUFFERS --------------- //////
bool iswater = trpData.a > 0.99;
vec4 data = texture2D(colortex1,texcoord);
vec4 dataUnpacked0 = vec4(decodeVec2(data.x),decodeVec2(data.y)); // albedo, masks
vec4 dataUnpacked1 = vec4(decodeVec2(data.z),decodeVec2(data.w)); // normals, lightmaps
// vec4 dataUnpacked2 = vec4(decodeVec2(data.z),decodeVec2(data.w));
vec3 albedo = toLinear(vec3(dataUnpacked0.xz,dataUnpacked1.x));
vec2 lightmap = dataUnpacked1.yz;
vec3 normal = decode(dataUnpacked0.yw);
////// --------------- UNPACK MISC --------------- //////
vec4 SpecularTex = texture2D(colortex8,texcoord); vec4 SpecularTex = texture2D(colortex8,texcoord);
float LabSSS = clamp((-65.0 + SpecularTex.z * 255.0) / 190.0 ,0.0,1.0); float LabSSS = clamp((-65.0 + SpecularTex.z * 255.0) / 190.0 ,0.0,1.0);
vec4 data = texture2D(colortex1,texcoord); // terraom
vec4 dataUnpacked0 = vec4(decodeVec2(data.x),decodeVec2(data.y));
vec4 dataUnpacked1 = vec4(decodeVec2(data.z),decodeVec2(data.w));
float Translucent_Programs = texture2D(colortex2,texcoord).a; // the shader for all translucent progams.
// Normal //
vec3 normal = decode(dataUnpacked0.yw) ;
vec4 normalAndAO = texture2D(colortex15,texcoord); vec4 normalAndAO = texture2D(colortex15,texcoord);
vec3 FlatNormals = normalAndAO.rgb * 2.0 - 1.0; vec3 FlatNormals = normalAndAO.rgb * 2.0 - 1.0;
float vanilla_AO = 1.0 - exp2(-5 * pow(1-normalAndAO.a,3)) ; vec3 slopednormal = normal;
#ifdef POM
#ifdef Horrible_slope_normals
vec3 ApproximatedFlatNormal = normalize(cross(dFdx(p3), dFdy(p3))); // it uses depth that has POM written to it.
slopednormal = normalize(clamp(normal, ApproximatedFlatNormal*2.0 - 1.0, ApproximatedFlatNormal*2.0 + 1.0) );
#endif
#endif
vec3 albedo = toLinear(vec3(dataUnpacked0.xz,dataUnpacked1.x)); float vanilla_AO = normalAndAO.a;
normalAndAO.a = clamp(pow(normalAndAO.a*5,4),0,1);
vec2 lightmap = dataUnpacked1.yz;
bool translucent = abs(dataUnpacked1.w-0.5) <0.01;
bool hand = abs(dataUnpacked1.w-0.75) <0.01; bool iswater = texture2D(colortex7,texcoord).a > 0.99;
float Indirect_SSS = 0.0; bool lightningBolt = abs(dataUnpacked1.w-0.5) <0.01;
bool isLeaf = abs(dataUnpacked1.w-0.55) <0.01;
bool entities = abs(dataUnpacked1.w-0.45) < 0.01;
bool hand = abs(dataUnpacked1.w-0.75) < 0.01;
// bool blocklights = abs(dataUnpacked1.w-0.8) <0.01;
if (z >=1.0) { if (z >=1.0) {
vec3 color = clamp(gl_Fog.color.rgb*pow(luma(gl_Fog.color.rgb),-0.75)*0.65,0.0,1.0)*0.02; vec3 color = clamp(gl_Fog.color.rgb*pow(luma(gl_Fog.color.rgb),-0.75)*0.65,0.0,1.0)*0.02;
@ -446,7 +453,9 @@ void main() {
// do all ambient lighting stuff // do all ambient lighting stuff
vec3 Indirect_lighting = DoAmbientLighting_Nether(FogColor, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, normal, np3, p3 ); vec3 Indirect_lighting = DoAmbientLighting_Nether(FogColor, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, normal, np3, p3 );
if(!hand) Indirect_lighting *= ssao(fragpos,noise,FlatNormals) * vanilla_AO; vec3 AO = vec3( exp( (vanilla_AO*vanilla_AO) * -5) ) ;
if(!hand) Indirect_lighting *= ssao(fragpos,noise,FlatNormals) * AO;
// ScreenSpace_SSS(Indirect_SSS, fragpos, vec2(R2_dither()), FlatNormals); // ScreenSpace_SSS(Indirect_SSS, fragpos, vec2(R2_dither()), FlatNormals);
@ -471,16 +480,17 @@ void main() {
// finalize // finalize
gl_FragData[0].rgb = (Indirect_lighting) * albedo; gl_FragData[0].rgb = Indirect_lighting * albedo;
// gl_FragData[0].rgb = LightSource * albedo; // gl_FragData[0].rgb = LightSource * albedo;
#ifdef Specular_Reflections #ifdef Specular_Reflections
MaterialReflections_N(gl_FragData[0].rgb, SpecularTex.r, SpecularTex.ggg, albedo, normal, np3, fragpos, vec3(blueNoise(gl_FragCoord.xy).rg,noise), hand); MaterialReflections_N(gl_FragData[0].rgb, SpecularTex.r, SpecularTex.ggg, albedo, normal, np3, fragpos, vec3(blueNoise(gl_FragCoord.xy).rg,noise), hand);
#endif #endif
#ifdef LabPBR_Emissives LabEmission(gl_FragData[0].rgb, albedo, SpecularTex.a);
LabEmission(gl_FragData[0].rgb, albedo, SpecularTex.a);
#endif if(lightningBolt) gl_FragData[0].rgb += vec3(Lightning_R,Lightning_G,Lightning_B) ;
} }
// ////// border Fog // ////// border Fog

1
shaders/world-1/gbuffers_hand.fsh
View File

@ -1,4 +1,5 @@
#version 120 #version 120
#define WORLD
#define HAND #define HAND
#include "/programs/all_solid.fsh" #include "/programs/all_solid.fsh"

49
shaders/world-1/gbuffers_spidereyes.fsh
View File

@ -1,32 +1,55 @@
#version 120 #version 120
/*
!! 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 vec4 color; varying vec4 color;
varying vec2 texcoord; varying vec2 texcoord;
uniform sampler2D texture; uniform sampler2D texture;
//faster and actually more precise than pow 2.2
vec3 toLinear(vec3 sRGB){ vec3 toLinear(vec3 sRGB){
return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878); return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878);
} }
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));
}
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
/* DRAWBUFFERS:28 */
void main() { void main() {
vec4 albedo = texture2D(texture, texcoord);
albedo *= color; vec4 Albedo = texture2D(texture, texcoord);
albedo.rgb = toLinear(albedo.rgb)*0.33;
/* DRAWBUFFERS:2 */
gl_FragData[0] = albedo;
} // if (Albedo.a > 0.1) Albedo.a = 1.0;
// else Albedo.a = 0.0;
// vec4 data1 = vec4(1);
// gl_FragData[0] = vec4(encodeVec2(Albedo.x,data1.x), encodeVec2(Albedo.y,data1.y), encodeVec2(Albedo.z,data1.z), encodeVec2(data1.w,Albedo.w));
Albedo *= color;
Albedo.rgb = toLinear(Albedo.rgb);
gl_FragData[0] = Albedo;
gl_FragData[1] = vec4(0.0,0.0,0.0,0.5);
}

35
shaders/world-1/gbuffers_spidereyes.vsh
View File

@ -1,5 +1,8 @@
#version 120 #version 120
#define TAA #extension GL_EXT_gpu_shader4 : enable
#include "/lib/settings.glsl"
#include "/lib/res_params.glsl"
/* /*
!! DO NOT REMOVE !! !! DO NOT REMOVE !!
@ -13,24 +16,28 @@ varying vec2 texcoord;
uniform vec2 texelSize; uniform vec2 texelSize;
uniform int framemod8; uniform int framemod8;
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.), const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
vec2(-1.,3.)/8., vec2(-1.,3.)/8.,
vec2(5.0,1.)/8., vec2(5.0,1.)/8.,
vec2(-3,-5.)/8., vec2(-3,-5.)/8.,
vec2(-5.,5.)/8., vec2(-5.,5.)/8.,
vec2(-7.,-1.)/8., vec2(-7.,-1.)/8.,
vec2(3,7.)/8., vec2(3,7.)/8.,
vec2(7.,-7.)/8.); vec2(7.,-7.)/8.);
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
void main() { void main() {
gl_Position = ftransform();
texcoord = (gl_MultiTexCoord0).xy; texcoord = (gl_MultiTexCoord0).xy;
color = gl_Color; color = gl_Color;
gl_Position = ftransform();
#ifdef TAA #ifdef TAA
gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize; gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize;
#endif #endif
}
}

74
shaders/world1/composite.fsh
View File

@ -353,33 +353,49 @@ void main() {
float noise = blueNoise(); float noise = blueNoise();
vec3 fragpos = toScreenSpace(vec3(texcoord-vec2(tempOffset)*texelSize*0.5,z)); vec3 fragpos = toScreenSpace(vec3(texcoord-vec2(tempOffset)*texelSize*0.5,z));
vec3 fragpos_RTSHADOW = toScreenSpace(vec3(texcoord,z));
vec3 p3 = mat3(gbufferModelViewInverse) * fragpos; vec3 p3 = mat3(gbufferModelViewInverse) * fragpos;
vec3 np3 = normVec(p3); vec3 np3 = normVec(p3);
vec4 trpData = texture2D(colortex7,texcoord); ////// --------------- UNPACK OPAQUE GBUFFERS --------------- //////
bool iswater = trpData.a > 0.99;
vec4 SpecularTex = texture2D(colortex8,texcoord);
bool isEntities = texture2D(colortex10,texcoord).x > 0.0;
vec4 data = texture2D(colortex1,texcoord); // terraom
vec4 dataUnpacked0 = vec4(decodeVec2(data.x),decodeVec2(data.y));
vec4 dataUnpacked1 = vec4(decodeVec2(data.z),decodeVec2(data.w));
float Translucent_Programs = texture2D(colortex2,texcoord).a; // the shader for all translucent progams. vec4 data = texture2D(colortex1,texcoord);
// Normal // vec4 dataUnpacked0 = vec4(decodeVec2(data.x),decodeVec2(data.y)); // albedo, masks
vec3 normal = decode(dataUnpacked0.yw) ; vec4 dataUnpacked1 = vec4(decodeVec2(data.z),decodeVec2(data.w)); // normals, lightmaps
// vec4 dataUnpacked2 = vec4(decodeVec2(data.z),decodeVec2(data.w));
vec3 albedo = toLinear(vec3(dataUnpacked0.xz,dataUnpacked1.x));
vec2 lightmap = dataUnpacked1.yz;
vec3 normal = decode(dataUnpacked0.yw);
////// --------------- UNPACK MISC --------------- //////
vec4 SpecularTex = texture2D(colortex8,texcoord);
float LabSSS = clamp((-65.0 + SpecularTex.z * 255.0) / 190.0 ,0.0,1.0);
vec4 normalAndAO = texture2D(colortex15,texcoord); vec4 normalAndAO = texture2D(colortex15,texcoord);
vec3 FlatNormals = normalAndAO.rgb * 2.0 - 1.0; vec3 FlatNormals = normalAndAO.rgb * 2.0 - 1.0;
float vanilla_AO = 1.0 - exp2(-5 * pow(1-normalAndAO.a,3)) ; vec3 slopednormal = normal;
#ifdef POM
#ifdef Horrible_slope_normals
vec3 ApproximatedFlatNormal = normalize(cross(dFdx(p3), dFdy(p3))); // it uses depth that has POM written to it.
slopednormal = normalize(clamp(normal, ApproximatedFlatNormal*2.0 - 1.0, ApproximatedFlatNormal*2.0 + 1.0) );
#endif
#endif
vec3 albedo = toLinear(vec3(dataUnpacked0.xz,dataUnpacked1.x)); float vanilla_AO = normalAndAO.a;
normalAndAO.a = clamp(pow(normalAndAO.a*5,4),0,1);
vec2 lightmap = dataUnpacked1.yz;
bool translucent = abs(dataUnpacked1.w-0.5) <0.01;
bool hand = abs(dataUnpacked1.w-0.75) <0.01; bool iswater = texture2D(colortex7,texcoord).a > 0.99;
bool lightningBolt = abs(dataUnpacked1.w-0.5) <0.01;
bool isLeaf = abs(dataUnpacked1.w-0.55) <0.01;
bool entities = abs(dataUnpacked1.w-0.45) < 0.01;
bool hand = abs(dataUnpacked1.w-0.75) < 0.01;
// bool blocklights = abs(dataUnpacked1.w-0.8) <0.01;
if (z >= 1.0) { if (z >= 1.0) {
@ -390,6 +406,8 @@ void main() {
p3 += gbufferModelViewInverse[3].xyz; p3 += gbufferModelViewInverse[3].xyz;
// do all ambient lighting stuff // do all ambient lighting stuff
vec3 AO = vec3( exp( (vanilla_AO*vanilla_AO) * -5) ) ;
vec3 Indirect_lighting = DoAmbientLighting_End(gl_Fog.color.rgb, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, normal, np3) ; vec3 Indirect_lighting = DoAmbientLighting_End(gl_Fog.color.rgb, vec3(TORCH_R,TORCH_G,TORCH_B), lightmap.x, normal, np3) ;
// Indirect_lighting = vec3(TORCH_R,TORCH_G,TORCH_B) * curveinvert(clamp(lightmap.x,0.0,1.0),2); // Indirect_lighting = vec3(TORCH_R,TORCH_G,TORCH_B) * curveinvert(clamp(lightmap.x,0.0,1.0),2);
@ -436,24 +454,26 @@ void main() {
gl_FragData[0].rgb = (Indirect_lighting + LightSource) * albedo; gl_FragData[0].rgb = (Indirect_lighting + LightSource) * albedo;
#ifdef Specular_Reflections #ifdef Specular_Reflections
MaterialReflections_E(gl_FragData[0].rgb, SpecularTex.r, SpecularTex.ggg, albedo, normal, np3, fragpos, vec3(blueNoise(gl_FragCoord.xy).rg,noise), hand, LightColor * LightFalloff, normalize(-LightPos), isEntities); MaterialReflections_E(gl_FragData[0].rgb, SpecularTex.r, SpecularTex.ggg, albedo, normal, np3, fragpos, vec3(blueNoise(gl_FragCoord.xy).rg,noise), hand, LightColor * LightFalloff, normalize(-LightPos), entities);
#endif #endif
if(!hand) gl_FragData[0].rgb *= ssao(fragpos,noise,FlatNormals) * vanilla_AO; if(!hand) gl_FragData[0].rgb *= ssao(fragpos,noise,FlatNormals) * AO;
// if(lightningBolt) albedo.rgb += vec3(Lightning_R,Lightning_G,Lightning_B) ;
LabEmission(gl_FragData[0].rgb, albedo, SpecularTex.a);
#ifdef LabPBR_Emissives
LabEmission(gl_FragData[0].rgb, albedo, SpecularTex.a);
#endif
} }
////// border Fog // ////// border Fog
if(Translucent_Programs > 0.0){ // if(Translucent_Programs > 0.0){
vec3 fragpos = toScreenSpace(vec3(texcoord-vec2(0.0)*texelSize*0.5,z)); // vec3 fragpos = toScreenSpace(vec3(texcoord-vec2(0.0)*texelSize*0.5,z));
float fogdistfade = 1.0 - clamp( exp(-pow(length(fragpos / far),2.)*5.0) ,0.0,1.0); // float fogdistfade = 1.0 - clamp( exp(-pow(length(fragpos / far),2.)*5.0) ,0.0,1.0);
gl_FragData[0].rgb = mix(gl_FragData[0].rgb, gl_Fog.color.rgb*0.5*NetherFog_brightness, fogdistfade) ; // gl_FragData[0].rgb = mix(gl_FragData[0].rgb, gl_Fog.color.rgb*0.5*NetherFog_brightness, fogdistfade) ;
} // }
////// Water Fog ////// Water Fog

2
shaders/world1/gbuffers_hand.fsh
View File

@ -1,4 +1,6 @@
#version 120 #version 120
#define WORLD
#define HAND #define HAND
#include "/programs/all_solid.fsh" #include "/programs/all_solid.fsh"

49
shaders/world1/gbuffers_spidereyes.fsh
View File

@ -1,32 +1,55 @@
#version 120 #version 120
/*
!! 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 vec4 color; varying vec4 color;
varying vec2 texcoord; varying vec2 texcoord;
uniform sampler2D texture; uniform sampler2D texture;
//faster and actually more precise than pow 2.2
vec3 toLinear(vec3 sRGB){ vec3 toLinear(vec3 sRGB){
return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878); return sRGB * (sRGB * (sRGB * 0.305306011 + 0.682171111) + 0.012522878);
} }
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));
}
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN////////////////////////////// //////////////////////////////VOID MAIN//////////////////////////////
/* DRAWBUFFERS:28 */
void main() { void main() {
vec4 albedo = texture2D(texture, texcoord);
albedo *= color; vec4 Albedo = texture2D(texture, texcoord);
albedo.rgb = toLinear(albedo.rgb)*0.33;
/* DRAWBUFFERS:2 */
gl_FragData[0] = albedo;
} // if (Albedo.a > 0.1) Albedo.a = 1.0;
// else Albedo.a = 0.0;
// vec4 data1 = vec4(1);
// gl_FragData[0] = vec4(encodeVec2(Albedo.x,data1.x), encodeVec2(Albedo.y,data1.y), encodeVec2(Albedo.z,data1.z), encodeVec2(data1.w,Albedo.w));
Albedo *= color;
Albedo.rgb = toLinear(Albedo.rgb);
gl_FragData[0] = Albedo;
gl_FragData[1] = vec4(0.0,0.0,0.0,0.5);
}

35
shaders/world1/gbuffers_spidereyes.vsh
View File

@ -1,5 +1,8 @@
#version 120 #version 120
#define TAA #extension GL_EXT_gpu_shader4 : enable
#include "/lib/settings.glsl"
#include "/lib/res_params.glsl"
/* /*
!! DO NOT REMOVE !! !! DO NOT REMOVE !!
@ -13,24 +16,28 @@ varying vec2 texcoord;
uniform vec2 texelSize; uniform vec2 texelSize;
uniform int framemod8; uniform int framemod8;
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.), const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
vec2(-1.,3.)/8., vec2(-1.,3.)/8.,
vec2(5.0,1.)/8., vec2(5.0,1.)/8.,
vec2(-3,-5.)/8., vec2(-3,-5.)/8.,
vec2(-5.,5.)/8., vec2(-5.,5.)/8.,
vec2(-7.,-1.)/8., vec2(-7.,-1.)/8.,
vec2(3,7.)/8., vec2(3,7.)/8.,
vec2(7.,-7.)/8.); vec2(7.,-7.)/8.);
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
//////////////////////////////VOID MAIN//////////////////////////////
void main() { void main() {
gl_Position = ftransform();
texcoord = (gl_MultiTexCoord0).xy; texcoord = (gl_MultiTexCoord0).xy;
color = gl_Color; color = gl_Color;
gl_Position = ftransform();
#ifdef TAA #ifdef TAA
gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize; gl_Position.xy += offsets[framemod8] * gl_Position.w*texelSize;
#endif #endif
}
}