316 lines
13 KiB
GLSL
316 lines
13 KiB
GLSL
#version 450 core
|
|
#extension GL_ARB_separate_shader_objects : enable
|
|
|
|
layout (constant_id = 0) const bool FOG = true;
|
|
layout (constant_id = 1) const bool PBR = true;
|
|
layout (constant_id = 2) const bool BIPLANAR = false;
|
|
layout (constant_id = 3) const bool TRIPLANAR = false;
|
|
layout (constant_id = 4) const bool STOCHASTIC = false;
|
|
layout (constant_id = 5) const bool BLEND = true;
|
|
// ...
|
|
layout (constant_id = 16) const int UNIT_SIZE = 8;
|
|
|
|
layout (binding = 0) uniform UniformBufferObject {
|
|
mat4 view;
|
|
mat4 proj;
|
|
|
|
vec3 lightInvDirection_worldspace;
|
|
|
|
vec4 fog; //color.rgb depth.a
|
|
} UBO;
|
|
layout (binding = 1) uniform sampler2DArray TextureAtlas;
|
|
layout (binding = 2) uniform sampler2DArray NormalAtlas;
|
|
layout (binding = 3) uniform sampler2DArray HOSAtlas;
|
|
|
|
#ifdef GEOMETRY
|
|
layout (location = 0) in GeometryData
|
|
#else
|
|
layout (location = 0) in VertexData
|
|
#endif
|
|
{
|
|
vec3 Position_modelspace;
|
|
#ifdef GEOMETRY
|
|
flat uint Textures[3];
|
|
vec3 TextureRatio;
|
|
#else
|
|
flat uint Texture;
|
|
#endif
|
|
|
|
vec3 FaceNormal_modelspace;
|
|
vec3 FaceNormal_worldspace;
|
|
vec3 EyeDirection_cameraspace;
|
|
vec3 LightDirection_cameraspace;
|
|
|
|
float Depth;
|
|
} vs;
|
|
|
|
layout(location = 0) out vec4 color;
|
|
|
|
vec3 expand(vec3 v) {
|
|
return (v - 0.5) * 2;
|
|
}
|
|
|
|
vec2 hash2D(vec2 s) {
|
|
// magic numbers
|
|
return fract(sin(mod(vec2(dot(s, vec2(127.1, 311.7)), dot(s, vec2(269.5, 183.3))), 3.14159)) * 43758.5453);
|
|
}
|
|
|
|
vec4 textureStochasticGrad(sampler2DArray smpl, vec3 UV, vec2 dx, vec2 dy) {
|
|
if(STOCHASTIC) {
|
|
// triangular by approx 2*sqrt(3)
|
|
vec2 skewUV = mat2(1.0, 0.0, -0.57735027, 1.15470054) * (UV.xy * 3.46400);
|
|
|
|
// vertex id and barrycentric coords
|
|
vec2 vxID = vec2(floor(skewUV));
|
|
vec3 barry = vec3(fract(skewUV), 0);
|
|
barry.z = 1.0 - barry.x - barry.y;
|
|
|
|
vec3 BW_vx0;
|
|
vec3 BW_vx1;
|
|
vec3 BW_vx2;
|
|
vec3 BW_vx3;
|
|
|
|
if(barry.z > 0) {
|
|
BW_vx0 = vec3(vxID, 0);
|
|
BW_vx1 = vec3(vxID + vec2(0, 1), 0);
|
|
BW_vx2 = vec3(vxID + vec2(1, 0), 0);
|
|
BW_vx3 = barry.zyx;
|
|
} else {
|
|
BW_vx0 = vec3(vxID + vec2(1, 1), 0);
|
|
BW_vx1 = vec3(vxID + vec2(1, 0), 0);
|
|
BW_vx2 = vec3(vxID + vec2(0, 1), 0);
|
|
BW_vx3 = vec3(-barry.z, 1.0 - barry.y, 1.0 - barry.x);
|
|
}
|
|
|
|
return textureGrad(smpl, vec3(UV.xy + hash2D(BW_vx0.xy), UV.z), dx, dy) * BW_vx3.x +
|
|
textureGrad(smpl, vec3(UV.xy + hash2D(BW_vx1.xy), UV.z), dx, dy) * BW_vx3.y +
|
|
textureGrad(smpl, vec3(UV.xy + hash2D(BW_vx2.xy), UV.z), dx, dy) * BW_vx3.z;
|
|
} else {
|
|
return textureGrad(smpl, UV, dx, dy);
|
|
}
|
|
}
|
|
vec4 textureStochastic(sampler2DArray smpl, vec3 UV) {
|
|
if(STOCHASTIC) {
|
|
return textureStochasticGrad(smpl, UV, dFdx(UV.xy), dFdy(UV.xy));
|
|
} else {
|
|
return texture(smpl, UV);
|
|
}
|
|
}
|
|
|
|
vec4 getTexture(sampler2DArray smpl, vec2 UV) {
|
|
#ifdef GEOMETRY
|
|
if(BLEND) {
|
|
vec4 colx = textureStochastic(smpl, vec3(UV, vs.Textures[0]));
|
|
if(vs.Textures[1] == vs.Textures[0]) {
|
|
return vs.Textures[2] == vs.Textures[0] ? colx :
|
|
mix(colx, textureStochastic(smpl, vec3(UV, vs.Textures[2])), vs.TextureRatio.z);
|
|
} else {
|
|
vec4 coly = textureStochastic(smpl, vec3(UV, vs.Textures[1]));
|
|
return vs.Textures[2] == vs.Textures[0] ? mix(colx, coly, vs.TextureRatio.y) : (
|
|
vs.Textures[2] == vs.Textures[1] ? mix(coly, colx, vs.TextureRatio.x) :
|
|
colx * vs.TextureRatio.x + coly * vs.TextureRatio.y + textureStochastic(smpl, vec3(UV, vs.Textures[2])) * vs.TextureRatio.z);
|
|
}
|
|
} else {
|
|
int mainTexture = vs.TextureRatio.x >= vs.TextureRatio.y ?
|
|
(vs.TextureRatio.x >= vs.TextureRatio.z ? 0 : 2) :
|
|
(vs.TextureRatio.y >= vs.TextureRatio.z ? 1 : 2);
|
|
return textureStochastic(smpl, vec3(UV, vs.Textures[mainTexture]));
|
|
}
|
|
#else
|
|
return textureStochastic(smpl, vec3(UV, vs.Texture));
|
|
#endif
|
|
}
|
|
vec4 getTextureGrad(sampler2DArray smpl, vec2 UV, vec2 dx, vec2 dy) {
|
|
#ifdef GEOMETRY
|
|
if(BLEND) {
|
|
vec4 colx = textureStochasticGrad(smpl, vec3(UV, vs.Textures[0]), dx, dy);
|
|
if(vs.Textures[1] == vs.Textures[0]) {
|
|
return vs.Textures[2] == vs.Textures[0] ? colx :
|
|
mix(colx, textureStochasticGrad(smpl, vec3(UV, vs.Textures[2]), dx, dy), vs.TextureRatio.z);
|
|
} else {
|
|
vec4 coly = textureStochasticGrad(smpl, vec3(UV, vs.Textures[1]), dx, dy);
|
|
return vs.Textures[2] == vs.Textures[0] ? mix(colx, coly, vs.TextureRatio.y) : (
|
|
vs.Textures[2] == vs.Textures[1] ? mix(coly, colx, vs.TextureRatio.x) :
|
|
colx * vs.TextureRatio.x + coly * vs.TextureRatio.y + textureStochasticGrad(smpl, vec3(UV, vs.Textures[2]), dx, dy) * vs.TextureRatio.z);
|
|
}
|
|
} else {
|
|
int mainTexture = vs.TextureRatio.x >= vs.TextureRatio.y ?
|
|
(vs.TextureRatio.x >= vs.TextureRatio.z ? 0 : 2) :
|
|
(vs.TextureRatio.y >= vs.TextureRatio.z ? 1 : 2);
|
|
return textureStochasticGrad(smpl, vec3(UV, vs.Textures[mainTexture]), dx, dy);
|
|
}
|
|
#else
|
|
return textureStochasticGrad(smpl, vec3(UV, vs.Texture), dx, dy);
|
|
#endif
|
|
}
|
|
|
|
vec4 getTriTexture(sampler2DArray smpl, vec2 UVx, vec2 UVy, vec2 UVz, vec3 w) {
|
|
vec4 x = getTexture(smpl, UVx);
|
|
vec4 y = getTexture(smpl, UVy);
|
|
vec4 z = getTexture(smpl, UVz);
|
|
return x*w.x + y*w.y + z*w.z;
|
|
}
|
|
|
|
vec4 getBiTexture(sampler2DArray smpl, vec2 UVa, vec2 UVb, vec2 dxa, vec2 dxb, vec2 dya, vec2 dyb, vec2 w) {
|
|
vec4 x = getTextureGrad(smpl, UVa, dxa, dya);
|
|
vec4 y = getTextureGrad(smpl, UVb, dxb, dyb);
|
|
return x*w.x + y*w.y;
|
|
}
|
|
|
|
void main() {
|
|
float texScale = 1. / UNIT_SIZE;
|
|
float transitionSpeed = 2;
|
|
vec4 tex;
|
|
vec3 worldNormal, texHOS;
|
|
|
|
if(TRIPLANAR) {
|
|
// Triplanar
|
|
float plateauSize = 0.001;
|
|
|
|
vec3 blendWeights = abs(vs.FaceNormal_modelspace);
|
|
blendWeights = blendWeights - plateauSize;
|
|
blendWeights = pow(max(blendWeights, 0), vec3(transitionSpeed));
|
|
blendWeights = blendWeights / (blendWeights.x + blendWeights.y + blendWeights.z);
|
|
vec2 UVx = vs.Position_modelspace.yz * texScale;
|
|
vec2 UVy = vs.Position_modelspace.zx * texScale;
|
|
vec2 UVz = vs.Position_modelspace.xy * texScale;
|
|
|
|
tex = getTriTexture(TextureAtlas, UVx, UVy, UVz, normalize(blendWeights));
|
|
|
|
if(PBR) {
|
|
// Whiteout normal blend
|
|
vec3 texNx = expand(getTexture(NormalAtlas, UVx).rgb);
|
|
vec3 texNy = expand(getTexture(NormalAtlas, UVy).rgb);
|
|
vec3 texNz = expand(getTexture(NormalAtlas, UVz).rgb);
|
|
// Swizzle world normals into tangent space and apply Whiteout blend
|
|
texNx = vec3(texNx.xy + vs.FaceNormal_worldspace.zy, abs(texNx.z) * vs.FaceNormal_worldspace.x);
|
|
texNy = vec3(texNy.xy + vs.FaceNormal_worldspace.xz, abs(texNy.z) * vs.FaceNormal_worldspace.y);
|
|
texNz = vec3(texNz.xy + vs.FaceNormal_worldspace.xy, abs(texNz.z) * vs.FaceNormal_worldspace.z);
|
|
// Swizzle tangent normals to match world orientation and triblend
|
|
worldNormal = normalize(texNx.zyx * blendWeights.x + texNy.xzy * blendWeights.y +texNz.xyz * blendWeights.z);
|
|
|
|
texHOS = getTriTexture(HOSAtlas, UVx, UVy, UVz, blendWeights).rgb;
|
|
}
|
|
} else if(BIPLANAR) {
|
|
// Biplanar
|
|
vec3 pos = vs.Position_modelspace * texScale;
|
|
vec3 dpdx = dFdx(pos);
|
|
vec3 dpdy = dFdy(pos);
|
|
vec3 blendWeights = abs(normalize(vs.FaceNormal_modelspace));
|
|
|
|
// determine major axis (in x; yz are following axis)
|
|
ivec3 ma = (blendWeights.x>blendWeights.y && blendWeights.x>blendWeights.z) ? ivec3(0,1,2) :
|
|
(blendWeights.y>blendWeights.z) ? ivec3(1,2,0) : ivec3(2,0,1);
|
|
// determine minor axis (in x; yz are following axis)
|
|
ivec3 mi = (blendWeights.x<blendWeights.y && blendWeights.x<blendWeights.z) ? ivec3(0,1,2) :
|
|
(blendWeights.y<blendWeights.z) ? ivec3(1,2,0) : ivec3(2,0,1);
|
|
// determine median axis (in x; yz are following axis)
|
|
ivec3 me = ivec3(3) - mi - ma;
|
|
vec2 UVa = vec2(pos[ma.y], pos[ma.z]);
|
|
vec2 UVb = vec2(pos[me.y], pos[me.z]);
|
|
vec2 dxa = vec2(dpdx[ma.y], dpdx[ma.z]);
|
|
vec2 dxb = vec2(dpdx[me.y], dpdx[me.z]);
|
|
vec2 dya = vec2(dpdy[ma.y], dpdy[ma.z]);
|
|
vec2 dyb = vec2(dpdy[me.y], dpdy[me.z]);
|
|
|
|
// blend factors
|
|
vec2 w = vec2(blendWeights[ma.x],blendWeights[me.x]);
|
|
w = clamp((w-0.5773)/(1.0-0.5773), 0.0, 1.0);
|
|
w = pow(w, vec2(transitionSpeed/8.0));
|
|
w = w / (w.x + w.y);
|
|
|
|
tex = getBiTexture(TextureAtlas, UVa, UVb, dxa, dxb, dya, dyb, w);
|
|
|
|
if(PBR) {
|
|
// Whiteout normal blend
|
|
vec3 texNa = expand(getTextureGrad(NormalAtlas, UVa, dxa, dya).rgb);
|
|
vec3 texNb = expand(getTextureGrad(NormalAtlas, UVb, dxb, dyb).rgb);
|
|
|
|
// Swizzle world normals into tangent space and apply Whiteout blend
|
|
texNa = normalize(vec3(texNa.xy + vs.FaceNormal_worldspace.zy, abs(texNa.z) * vs.FaceNormal_worldspace.x).zyx * blendWeights.x +
|
|
vec3(texNa.xy + vs.FaceNormal_worldspace.xz, abs(texNa.z) * vs.FaceNormal_worldspace.y).xzy * blendWeights.y +
|
|
vec3(texNa.xy + vs.FaceNormal_worldspace.xy, abs(texNa.z) * vs.FaceNormal_worldspace.z).xyz * blendWeights.z);
|
|
texNb = normalize(vec3(texNb.xy + vs.FaceNormal_worldspace.zy, abs(texNb.z) * vs.FaceNormal_worldspace.x).zyx * blendWeights.x +
|
|
vec3(texNb.xy + vs.FaceNormal_worldspace.xz, abs(texNb.z) * vs.FaceNormal_worldspace.y).xzy * blendWeights.y +
|
|
vec3(texNb.xy + vs.FaceNormal_worldspace.xy, abs(texNb.z) * vs.FaceNormal_worldspace.z).xyz * blendWeights.z);
|
|
// Swizzle tangent normals to match world orientation and biblend
|
|
worldNormal = normalize((texNa * w.x + texNb * w.y) / (w.x + w.y));
|
|
|
|
texHOS = getBiTexture(HOSAtlas, UVa, UVb, dxa, dxb, dya, dyb, w).rgb;
|
|
}
|
|
} else {
|
|
// Cheap planar
|
|
vec3 blendWeights = abs(vs.FaceNormal_modelspace);
|
|
vec3 nrm = normalize(pow(blendWeights, vec3(80 / sqrt(UNIT_SIZE))));
|
|
vec2 UV = (vec2(vs.Position_modelspace.xy * nrm.z) + vec2(vs.Position_modelspace.yz * nrm.x) + vec2(vs.Position_modelspace.zx * nrm.y)) * texScale;
|
|
|
|
tex = getTexture(TextureAtlas, UV);
|
|
if(PBR) {
|
|
vec3 texN = expand(getTexture(NormalAtlas, UV).rgb);
|
|
// Swizzle world normals into tangent space and apply Whiteout blend
|
|
// Swizzle tangent normals to match world orientation and triblend
|
|
worldNormal = normalize(vec3(texN.xy + vs.FaceNormal_worldspace.zy, abs(texN.z) * vs.FaceNormal_worldspace.x).zyx * blendWeights.x +
|
|
vec3(texN.xy + vs.FaceNormal_worldspace.xz, abs(texN.z) * vs.FaceNormal_worldspace.y).xzy * blendWeights.y +
|
|
vec3(texN.xy + vs.FaceNormal_worldspace.xy, abs(texN.z) * vs.FaceNormal_worldspace.z).xyz * blendWeights.z);
|
|
|
|
texHOS = getTexture(HOSAtlas, UV).rgb;
|
|
}
|
|
}
|
|
|
|
// Colors
|
|
if(PBR) {
|
|
// Texture properties
|
|
vec3 TextureDiffuseColor = tex.rgb;
|
|
vec3 TextureAmbientColor = vec3(.1) * TextureDiffuseColor * texHOS.y;
|
|
vec3 TextureSpecularColor = vec3(.8) * texHOS.z;
|
|
|
|
vec3 Normal_cameraspace = normalize((UBO.view * vec4(worldNormal,0)).xyz);
|
|
|
|
// Light emission properties
|
|
// You probably want to put them as uniforms
|
|
vec3 LightColor = vec3(1, 0.9, 0.9);
|
|
float LightPower = 1.2f;
|
|
|
|
// Distance to the light
|
|
float distance = 1.0f;//length( LightPosition_worldspace - Position_worldspace );
|
|
|
|
// Direction of the light (from the fragment to the light)
|
|
vec3 l = normalize(vs.LightDirection_cameraspace);
|
|
// Cosine of the angle between the normal and the light direction,
|
|
// clamped above 0
|
|
// - light is at the vertical of the triangle -> 1
|
|
// - light is perpendiular to the triangle -> 0
|
|
// - light is behind the triangle -> 0
|
|
float cosTheta = clamp(dot(Normal_cameraspace,l), 0,1 );
|
|
|
|
// Eye vector (towards the camera)
|
|
vec3 E = normalize(vs.EyeDirection_cameraspace);
|
|
// Direction in which the triangle reflects the light
|
|
vec3 R = reflect(-l,Normal_cameraspace);
|
|
// Cosine of the angle between the Eye vector and the Reflect vector,
|
|
// clamped to 0
|
|
// - Looking into the reflection -> 1
|
|
// - Looking elsewhere -> < 1
|
|
float cosAlpha = clamp( dot( E,R ), 0,1 );
|
|
|
|
float visibility=1.0;
|
|
|
|
// MAYBE: shadow
|
|
|
|
color = vec4(
|
|
// Ambient : simulates indirect lighting
|
|
TextureAmbientColor +
|
|
// Diffuse : "color" of the object
|
|
visibility * TextureDiffuseColor * LightColor * LightPower * cosTheta / (distance * distance) +
|
|
// Specular : reflective highlight, like a mirror
|
|
visibility * TextureSpecularColor * LightColor * LightPower * pow(cosAlpha,5) / (distance * distance),
|
|
// Restore alpha
|
|
tex.a);
|
|
} else {
|
|
color = tex;
|
|
}
|
|
if(FOG) {
|
|
float ratio = exp(vs.Depth * 0.69)-1;
|
|
color = mix(color, vec4(UBO.fog.rgb, 1), clamp(ratio, 0, 1));
|
|
}
|
|
} |