forked from Mirrors/openclonk
163 lines
5.0 KiB
GLSL
163 lines
5.0 KiB
GLSL
|
|
// Interpolated texture coordinates
|
|
in vec2 landscapeTexCoord;
|
|
#ifdef OC_DYNAMIC_LIGHT
|
|
in vec2 lightTexCoord;
|
|
#endif
|
|
|
|
// Input textures
|
|
uniform sampler2D landscapeTex[2];
|
|
uniform sampler2D scalerTex;
|
|
uniform sampler2DArray materialTex;
|
|
|
|
// Resolution of the landscape texture
|
|
uniform vec2 resolution;
|
|
|
|
// Center position
|
|
uniform vec2 center;
|
|
// Texture map
|
|
uniform sampler1D matMapTex;
|
|
uniform float materialDepth;
|
|
uniform vec2 materialSize;
|
|
|
|
// for SetMatAdjust
|
|
uniform vec4 clrMod;
|
|
|
|
out vec4 fragColor;
|
|
|
|
// Expected parameters for the scaler
|
|
const vec2 scalerStepX = vec2(1.0 / 8.0, 0.0);
|
|
const vec2 scalerStepY = vec2(0.0, 1.0 / 32.0);
|
|
const vec2 scalerOffset = scalerStepX / 3.0 + scalerStepY / 3.0;
|
|
const vec2 scalerPixel = vec2(scalerStepX.x, scalerStepY.y) / 3.0;
|
|
|
|
vec4 queryMatMap(int pix)
|
|
{
|
|
return texture(matMapTex, float(pix) / 2.0 / 256.0 + 0.5 / 2.0 / 256.0);
|
|
}
|
|
|
|
slice(init)
|
|
{
|
|
// How much % the normals from the normal map are added up to the
|
|
// landscape normal. The higher the strength, the more structure
|
|
// within the material is visible.
|
|
// 0.0 = just textures
|
|
// 1.0 = just material borders
|
|
const float normalMapStrengthMin = 0.4;
|
|
const float normalMapStrengthMax = 0.6;
|
|
|
|
// Depth assumed for landscape normals. This decides how deep the
|
|
// material "borders" appear to be. Lower means sharper normals
|
|
// means more of a 3D look.
|
|
float landscapeNormalDepth = 0.1;
|
|
}
|
|
|
|
slice(coordinate)
|
|
{
|
|
// full pixel steps in the landscape texture (depends on landscape resolution)
|
|
vec2 fullStep = vec2(1.0, 1.0) / resolution;
|
|
vec2 fullStepX = vec2(fullStep.x, 0.0);
|
|
vec2 fullStepY = vec2(0.0, fullStep.y);
|
|
|
|
vec2 texCoo = landscapeTexCoord;
|
|
|
|
// calculate pixel position in landscape, find center of current pixel
|
|
vec2 pixelCoo = texCoo * resolution;
|
|
vec2 centerCoo = (floor(pixelCoo) + vec2(0.5, 0.5)) / resolution;
|
|
|
|
// Texture coordinate for material
|
|
vec2 materialCoo = texCoo * resolution / materialSize;
|
|
}
|
|
|
|
slice(texture)
|
|
{
|
|
// our pixel color (without/with interpolation)
|
|
vec4 landscapePx = texture(landscapeTex[0], centerCoo);
|
|
vec4 realLandscapePx = texture(landscapeTex[0], texCoo);
|
|
|
|
// find scaler coordinate
|
|
vec2 scalerCoo = scalerOffset + mod(pixelCoo, vec2(1.0, 1.0)) * scalerPixel;
|
|
int iScaler = f2i(landscapePx.a), iRow = iScaler / 8;
|
|
scalerCoo.x += float(iScaler - iRow * 8) / 8.0;
|
|
scalerCoo.y += float(iScaler / 8) / 32.0;
|
|
|
|
// query scaler texture
|
|
vec4 scalerPx = texture(scalerTex, scalerCoo);
|
|
|
|
// Get "second" landscape pixel
|
|
vec2 centerCoo2 = centerCoo + fullStep * floor(vec2(-0.5, -0.5) +
|
|
scalerPx.gb * 255.0 / 64.0);
|
|
vec4 landscapePx2 = texture(landscapeTex[0], centerCoo2);
|
|
|
|
}
|
|
|
|
slice(texture+4)
|
|
{
|
|
#ifdef OC_DYNAMIC_LIGHT
|
|
vec2 lightCoord = lightTexCoord;
|
|
#endif
|
|
}
|
|
|
|
slice(material)
|
|
{
|
|
|
|
// Get material properties from material map
|
|
int matMapIx = f2i(landscapePx.r);
|
|
vec4 matMap = queryMatMap(2*matMapIx);
|
|
vec4 matMapX = queryMatMap(2*matMapIx+1);
|
|
float materialIx = int(matMap.a * (materialDepth - 1) + 0.5);
|
|
vec3 matEmit = matMap.rgb;
|
|
vec3 matSpot = matMapX.rgb * 255.9f / 16.0f;
|
|
float matAngle = matMapX.a;
|
|
|
|
// Query material texture pixels
|
|
vec4 materialPx = texture(materialTex, vec3(materialCoo, materialIx));
|
|
vec4 normalPx = texture(materialTex, vec3(materialCoo, materialIx+0.5 * materialDepth));
|
|
// Same for second pixel
|
|
int matMapIx2 = f2i(landscapePx2.r);
|
|
vec4 matMap2 = queryMatMap(2*matMapIx2);
|
|
vec4 matMapX2 = queryMatMap(2*matMapIx2+1);
|
|
float materialIx2 = int(matMap2.a * (materialDepth - 1) + 0.5);
|
|
vec3 matEmit2 = matMap2.rgb;
|
|
vec3 matSpot2 = matMapX2.rgb * 255.9f / 16.0f;
|
|
float matAngle2 = matMapX2.a;
|
|
|
|
// Query material texture pixels
|
|
vec4 materialPx2 = texture(materialTex, vec3(materialCoo, materialIx2));
|
|
vec4 normalPx2 = texture(materialTex, vec3(materialCoo, materialIx2+0.5 * materialDepth));
|
|
}
|
|
|
|
slice(normal)
|
|
{
|
|
// Normal calculation. At edges, take landscape normals
|
|
// more into account (#1418).
|
|
vec2 landscapeNormalPx = mix(realLandscapePx.yz, landscapePx.yz, scalerPx.a) - vec2(0.5, 0.5);
|
|
vec3 landscapeNormal = normalize(vec3(landscapeNormalPx, landscapeNormalDepth));
|
|
vec3 textureNormal = 2.0*(normalPx.xyz - vec3(0.5,0.5,0.5));
|
|
textureNormal.y *= -1.0;
|
|
float edgeFactor = 2.0 * length(landscapeNormalPx);
|
|
float edgeStrength = normalMapStrengthMin + (normalMapStrengthMax - normalMapStrengthMin) * edgeFactor;
|
|
vec3 normal = mix(textureNormal, landscapeNormal, edgeStrength);
|
|
|
|
vec2 landscapeNormalPx2 = landscapePx2.yz - vec2(0.5, 0.5);
|
|
vec3 landscapeNormal2 = normalize(vec3(landscapeNormalPx2, landscapeNormalDepth));
|
|
vec3 textureNormal2 = 2.0*(normalPx2.xyz - vec3(0.5,0.5,0.5));
|
|
textureNormal2.y *= -1.0;
|
|
float edgeFactor2 = 2.0 * length(landscapeNormalPx2);
|
|
float edgeStrength2 = normalMapStrengthMin + (normalMapStrengthMax - normalMapStrengthMin) * edgeFactor2;
|
|
vec3 normal2 = mix(textureNormal2, landscapeNormal2, edgeStrength2);
|
|
|
|
}
|
|
|
|
slice(color) {
|
|
fragColor = materialPx;
|
|
vec4 color2 = materialPx2;
|
|
}
|
|
|
|
slice(color+10) {
|
|
// Mix second color into main color according to scaler
|
|
fragColor = mix(color2, fragColor, scalerPx.r);
|
|
// Apply modulation
|
|
fragColor *= clrMod;
|
|
}
|