mirror/openlara
1
0
Fork 0
mirror of https://github.com/XProger/OpenLara.git synced 2025-08-17 02:24:07 +02:00
Code Issues Releases Wiki Activity

split GLSL uber-shader by passes

Browse Source
This commit is contained in:
XProger
2019-02-16 03:59:52 +03:00
parent 62fbbd60d7
commit 0ad35ea26d
9 changed files with 385 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/cache.h
View File

@@ -75,12 +75,9 @@ struct ShaderCache {
} }
void prepareAmbient(int fx) { void prepareAmbient(int fx) {
compile(Core::passAmbient, Shader::ROOM, fx, rsFull); compile(Core::passAmbient, Shader::ROOM, fx, rsFull);
compile(Core::passAmbient, Shader::ROOM, fx, rsFull | RS_DISCARD); compile(Core::passAmbient, Shader::ROOM, fx, rsFull | RS_DISCARD);
compile(Core::passAmbient, Shader::ROOM, fx | FX_UNDERWATER, rsFull); compile(Core::passAmbient, Shader::SPRITE, fx, rsFull | RS_DISCARD);
compile(Core::passAmbient, Shader::ROOM, fx | FX_UNDERWATER, rsFull | RS_DISCARD);
compile(Core::passAmbient, Shader::SPRITE, fx, rsFull | RS_DISCARD);
compile(Core::passAmbient, Shader::SPRITE, fx | FX_UNDERWATER, rsFull | RS_DISCARD);
} }
void prepareShadows(int fx) { void prepareShadows(int fx) {

2
src/core.h
View File

@@ -520,8 +520,6 @@ namespace Core {
enum Pass { passCompose, passShadow, passAmbient, passSky, passWater, passFilter, passGUI, passMAX } pass; enum Pass { passCompose, passShadow, passAmbient, passSky, passWater, passFilter, passGUI, passMAX } pass;
const char *passNames[Core::passMAX] = { "COMPOSE", "SHADOW", "AMBIENT", "SKY", "WATER", "FILTER", "GUI" };
GAPI::Texture *defaultTarget; GAPI::Texture *defaultTarget;
int32 renderState; int32 renderState;

41
src/gapi_gl.h
View File

@@ -334,8 +334,16 @@ namespace GAPI {
// Shader // Shader
#ifndef FFP #ifndef FFP
const char SHADER_BASE[] = const char SHADER_COMPOSE[] =
#include "shaders/shader.glsl" #include "shaders/compose.glsl"
;
const char SHADER_SHADOW[] =
#include "shaders/shadow.glsl"
;
const char SHADER_AMBIENT[] =
#include "shaders/ambient.glsl"
; ;
const char SHADER_SKY[] = const char SHADER_SKY[] =
@@ -398,26 +406,26 @@ namespace GAPI {
void init(Pass pass, int type, int *def, int defCount) { void init(Pass pass, int type, int *def, int defCount) {
const char *source; const char *source;
switch (pass) { switch (pass) {
case Core::passCompose : case Core::passCompose : source = SHADER_COMPOSE; break;
case Core::passShadow : case Core::passShadow : source = SHADER_SHADOW; break;
case Core::passAmbient : source = SHADER_BASE; break; case Core::passAmbient : source = SHADER_AMBIENT; break;
case Core::passSky : source = SHADER_SKY; break; case Core::passSky : source = SHADER_SKY; break;
case Core::passWater : source = SHADER_WATER; break; case Core::passWater : source = SHADER_WATER; break;
case Core::passFilter : source = SHADER_FILTER; break; case Core::passFilter : source = SHADER_FILTER; break;
case Core::passGUI : source = SHADER_GUI; break; case Core::passGUI : source = SHADER_GUI; break;
default : ASSERT(false); LOG("! wrong pass id\n"); return; default : ASSERT(false); LOG("! wrong pass id\n"); return;
} }
#ifdef _DEBUG_SHADERS #ifdef _DEBUG_SHADERS
Stream *stream = NULL; Stream *stream = NULL;
switch (pass) { switch (pass) {
case Core::passCompose : case Core::passCompose : stream = new Stream("../../src/shaders/compose.glsl"); break;
case Core::passShadow : case Core::passShadow : stream = new Stream("../../src/shaders/shadow.glsl"); break;
case Core::passAmbient : stream = new Stream("../../src/shaders/shader.glsl"); break; case Core::passAmbient : stream = new Stream("../../src/shaders/ambient.glsl"); break;
case Core::passSky : stream = new Stream("../../src/shaders/sky.glsl"); break; case Core::passSky : stream = new Stream("../../src/shaders/sky.glsl"); break;
case Core::passWater : stream = new Stream("../../src/shaders/water.glsl"); break; case Core::passWater : stream = new Stream("../../src/shaders/water.glsl"); break;
case Core::passFilter : stream = new Stream("../../src/shaders/filter.glsl"); break; case Core::passFilter : stream = new Stream("../../src/shaders/filter.glsl"); break;
case Core::passGUI : stream = new Stream("../../src/shaders/gui.glsl"); break; case Core::passGUI : stream = new Stream("../../src/shaders/gui.glsl"); break;
default : ASSERT(false); return; default : ASSERT(false); return;
} }
@@ -448,7 +456,6 @@ namespace GAPI {
for (int i = 0; i < defCount; i++) { for (int i = 0; i < defCount; i++) {
sprintf(defines + strlen(defines), "#define %s\n", DefineName[def[i]]); sprintf(defines + strlen(defines), "#define %s\n", DefineName[def[i]]);
} }
sprintf(defines + strlen(defines), "#define PASS_%s\n", passNames[pass]);
#if defined(_OS_RPI) || defined(_OS_CLOVER) #if defined(_OS_RPI) || defined(_OS_CLOVER)
strcat(defines, "#define OPT_VLIGHTPROJ\n"); strcat(defines, "#define OPT_VLIGHTPROJ\n");

50
src/level.h
View File

@@ -71,6 +71,10 @@ struct Level : IGame {
float animTexTimer; float animTexTimer;
float statsTimeDelta; float statsTimeDelta;
vec3 underwaterColor;
vec4 underwaterFogParams;
vec4 levelFogParams;
// IGame implementation ======== // IGame implementation ========
virtual void loadLevel(TR::LevelID id) { virtual void loadLevel(TR::LevelID id) {
sndWater = sndTrack = NULL; sndWater = sndTrack = NULL;
@@ -519,17 +523,6 @@ struct Level : IGame {
alphaTest = true; alphaTest = true;
} }
setShader(Core::pass, type, room.flags.water, alphaTest);
if (room.flags.water) {
if (waterCache)
waterCache->bindCaustics(roomIndex);
setWaterParams(float(room.waterLevel[level.state.flags.flipped]));
} else
setWaterParams(NO_CLIP_PLANE);
Core::active.shader->setParam(uParam, Core::params);
#ifdef FFP #ifdef FFP
switch (type) { switch (type) {
case Shader::SPRITE : case Shader::SPRITE :
@@ -549,7 +542,36 @@ struct Level : IGame {
} }
#endif #endif
Core::setMaterial(diffuse, ambient, specular, alpha); vec4 material;
if (Core::pass == Core::passAmbient) {
if (room.flags.water) {
Core::fogParams = underwaterFogParams;
material = vec4(underwaterColor, 1.0f);
} else {
Core::fogParams = levelFogParams;
material = vec4(1.0f);
}
} else {
Core::fogParams = levelFogParams;
material = vec4(diffuse, ambient, specular, alpha);
}
setShader(Core::pass, type, (Core::pass == Core::passAmbient) ? false : room.flags.water, alphaTest);
Core::setMaterial(material.x, material.y, material.z, material.w);
if (room.flags.water) {
if (waterCache) {
waterCache->bindCaustics(roomIndex);
}
setWaterParams(float(room.waterLevel[level.state.flags.flipped]));
} else {
setWaterParams(NO_CLIP_PLANE);
}
Core::active.shader->setParam(uParam, Core::params);
Core::updateLights(); Core::updateLights();
if (Core::settings.detail.shadows > Core::Settings::MEDIUM) if (Core::settings.detail.shadows > Core::Settings::MEDIUM)
@@ -835,7 +857,9 @@ struct Level : IGame {
memset(players, 0, sizeof(players)); memset(players, 0, sizeof(players));
player = NULL; player = NULL;
Core::fogParams = TR::getFogParams(level.id); underwaterColor = vec3(0.6f, 0.9f, 0.9f);
underwaterFogParams = vec4(underwaterColor * 0.2f, 1.0f / (6 * 1024));
levelFogParams = TR::getFogParams(level.id);
inventory->game = this; inventory->game = this;

4
src/platform/win/OpenLara.vcxproj
View File

@@ -233,9 +233,11 @@
<ClInclude Include="..\..\video.h" /> <ClInclude Include="..\..\video.h" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="..\..\shaders\ambient.glsl" />
<None Include="..\..\shaders\compose.glsl" />
<None Include="..\..\shaders\filter.glsl" /> <None Include="..\..\shaders\filter.glsl" />
<None Include="..\..\shaders\gui.glsl" /> <None Include="..\..\shaders\gui.glsl" />
<None Include="..\..\shaders\shader.glsl" /> <None Include="..\..\shaders\shadow.glsl" />
<None Include="..\..\shaders\sky.glsl" /> <None Include="..\..\shaders\sky.glsl" />
<None Include="..\..\shaders\water.glsl" /> <None Include="..\..\shaders\water.glsl" />
</ItemGroup> </ItemGroup>

10
src/platform/win/OpenLara.vcxproj.filters
View File

@@ -69,10 +69,16 @@
<None Include="..\..\shaders\water.glsl"> <None Include="..\..\shaders\water.glsl">
<Filter>shaders</Filter> <Filter>shaders</Filter>
</None> </None>
<None Include="..\..\shaders\shader.glsl"> <None Include="..\..\shaders\sky.glsl">
<Filter>shaders</Filter> <Filter>shaders</Filter>
</None> </None>
<None Include="..\..\shaders\sky.glsl"> <None Include="..\..\shaders\shadow.glsl">
<Filter>shaders</Filter>
</None>
<None Include="..\..\shaders\ambient.glsl">
<Filter>shaders</Filter>
</None>
<None Include="..\..\shaders\compose.glsl">
<Filter>shaders</Filter> <Filter>shaders</Filter>
</None> </None>
</ItemGroup> </ItemGroup>

69
src/shaders/ambient.glsl Normal file
View File

@@ -0,0 +1,69 @@
R"====(
uniform mat4 uViewProj;
uniform vec4 uViewPos;
uniform vec4 uFogParams;
varying vec2 vTexCoord;
varying vec4 vDiffuse;
#ifdef VERTEX
uniform vec4 uBasis[2];
uniform vec4 uMaterial;
attribute vec4 aCoord;
attribute vec4 aTexCoord;
attribute vec3 aColor;
attribute vec3 aLight;
vec3 mulQuat(vec4 q, vec3 v) {
return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + v * q.w);
}
vec3 mulBasis(vec4 rot, vec3 pos, vec3 v) {
return mulQuat(rot, v) + pos;
}
void main() {
vTexCoord = aTexCoord.xy;
vec4 rBasisRot = uBasis[0];
vec4 rBasisPos = uBasis[1];
vec3 coord =
#ifdef TYPE_SPRITE
mulBasis(rBasisRot, rBasisPos.xyz + aCoord.xyz, vec3(aTexCoord.z, aTexCoord.w, 0.0) * 32767.0);
#else
mulBasis(rBasisRot, rBasisPos.xyz, aCoord.xyz);
#endif
vDiffuse.xyz = aColor.xyz * aLight.xyz * uMaterial.xyz;
float fog = length(uViewPos.xyz - coord.xyz) * uFogParams.w;
vDiffuse.w = clamp(1.0 / exp(fog), 0.0, 1.0);
gl_Position = uViewProj * vec4(coord, 1.0);
}
#else
uniform sampler2D sDiffuse;
void main() {
vec4 color = texture2D(sDiffuse, vTexCoord);
#ifdef ALPHA_TEST
if (color.w <= 0.5)
discard;
#endif
color.xyz *= vDiffuse.xyz;
color.xyz = mix(uFogParams.xyz, color.xyz, vDiffuse.w);
color.xyz *= color.w;
fragColor = color;
}
#endif
)===="

412
src/shaders/shader.glsl → src/shaders/compose.glsl
View File

@@ -8,16 +8,6 @@ R"====(
#define SHADOW_NORMAL_BIAS 16.0 #define SHADOW_NORMAL_BIAS 16.0
#define SHADOW_CONST_BIAS 0.05 #define SHADOW_CONST_BIAS 0.05
#if (defined(PASS_AMBIENT) || defined(PASS_COMPOSE)) && !defined(TYPE_FLASH)
varying vec3 vCoord;
#endif
varying vec4 vTexCoord; // xy - atlas coords, zw - trapezoidal correction
#ifdef OPT_VLIGHTVEC
varying vec3 vLightVec;
#endif
#ifdef OPT_CAUSTICS #ifdef OPT_CAUSTICS
uniform vec4 uRoomSize; // xy - minXZ, zw - maxXZ uniform vec4 uRoomSize; // xy - minXZ, zw - maxXZ
#endif #endif
@@ -40,21 +30,25 @@ uniform vec4 uLightColor[MAX_LIGHTS]; // xyz - color, w - radius * intensity
uniform vec4 uMaterial; // x - diffuse, y - ambient, z - specular, w - alpha uniform vec4 uMaterial; // x - diffuse, y - ambient, z - specular, w - alpha
uniform vec4 uFogParams; uniform vec4 uFogParams;
#ifndef PASS_SHADOW varying vec4 vViewVec; // xyz - dir * dist, w - coord.y * clipPlaneSign
varying vec4 vViewVec; // xyz - dir * dist, w - coord.y * clipPlaneSign varying vec4 vDiffuse;
varying vec4 vDiffuse;
#ifndef TYPE_FLASH
varying vec3 vCoord;
varying vec4 vNormal; // xyz - normal dir, w - fog factor varying vec4 vNormal; // xyz - normal dir, w - fog factor
#ifndef TYPE_FLASH #ifdef OPT_SHADOW
#ifdef PASS_COMPOSE varying vec3 vAmbient;
#ifdef OPT_SHADOW varying vec3 vLightMap;
varying vec3 vAmbient;
varying vec3 vLightMap;
#endif
#endif
varying vec4 vLight; // lights intensity (MAX_LIGHTS == 4)
#endif #endif
varying vec4 vLight; // lights intensity (MAX_LIGHTS == 4)
#endif
varying vec4 vTexCoord; // xy - atlas coords, zw - trapezoidal correction
#ifdef OPT_VLIGHTVEC
varying vec3 vLightVec;
#endif #endif
#ifdef OPT_SHADOW #ifdef OPT_SHADOW
@@ -89,10 +83,8 @@ uniform vec4 uFogParams;
attribute vec4 aTexCoord; attribute vec4 aTexCoord;
attribute vec4 aNormal; attribute vec4 aNormal;
#ifndef PASS_SHADOW attribute vec4 aColor;
attribute vec4 aColor; attribute vec4 aLight;
attribute vec4 aLight;
#endif
vec3 mulQuat(vec4 q, vec3 v) { vec3 mulQuat(vec4 q, vec3 v) {
return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + v * q.w); return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + v * q.w);
@@ -112,23 +104,16 @@ uniform vec4 uFogParams;
vec4 rBasisPos = uBasis[1]; vec4 rBasisPos = uBasis[1];
#endif #endif
vec4 coord; vec3 coord =
coord.w = rBasisPos.w; // visible flag #ifdef TYPE_SPRITE
#if defined(TYPE_SPRITE) mulBasis(rBasisRot, rBasisPos.xyz + aCoord.xyz, vec3(aTexCoord.z, aTexCoord.w, 0.0) * 32767.0);
coord.xyz = mulBasis(rBasisRot, rBasisPos.xyz + aCoord.xyz, vec3(aTexCoord.z, aTexCoord.w, 0.0) * 32767.0);
#else #else
coord.xyz = mulBasis(rBasisRot, rBasisPos.xyz, aCoord.xyz); mulBasis(rBasisRot, rBasisPos.xyz, aCoord.xyz);
#endif #endif
#ifndef PASS_SHADOW vViewVec = vec4((uViewPos.xyz - coord) * uFogParams.w, coord.y * uParam.z);
vViewVec = vec4((uViewPos.xyz - coord.xyz) * uFogParams.w, coord.y * uParam.z);
#endif
#ifdef PASS_AMBIENT #ifndef TYPE_FLASH
vNormal = aNormal;
#endif
#if defined(PASS_COMPOSE) && !defined(TYPE_FLASH)
#ifdef TYPE_SPRITE #ifdef TYPE_SPRITE
vNormal.xyz = normalize(vViewVec.xyz); vNormal.xyz = normalize(vViewVec.xyz);
#else #else
@@ -136,125 +121,115 @@ uniform vec4 uFogParams;
#endif #endif
float fog; float fog;
#if defined(UNDERWATER) && defined(OPT_UNDERWATER_FOG) #if defined(UNDERWATER) && !defined(OPT_UNDERWATER_FOG)
float d; float d;
if (uViewPos.y < uParam.y) // TODO: fix for mediump if (uViewPos.y < uParam.y) // TODO: fix for mediump
d = abs((coord.y - uParam.y) / normalize(uViewPos.xyz - coord.xyz).y); d = abs((coord.y - uParam.y) / normalize(uViewPos.xyz - coord).y);
else else
d = length(uViewPos.xyz - coord.xyz); d = length(uViewPos.xyz - coord);
fog = d * WATER_FOG_DIST; fog = d * WATER_FOG_DIST;
fog *= step(uParam.y, coord.y); fog *= step(uParam.y, coord.y);
vNormal.w = fog; vNormal.w = clamp(1.0 / exp(fog), 0.0, 1.0);
#else #else
fog = length(vViewVec.xyz); fog = length(vViewVec.xyz);
vNormal.w = clamp(1.0 / exp(fog), 0.0, 1.0); vNormal.w = clamp(1.0 / exp(fog), 0.0, 1.0);
#endif #endif
vCoord = coord.xyz; vCoord = coord;
#endif #endif
return coord; return vec4(coord, rBasisPos.w);
} }
void _diffuse() { void _diffuse() {
#ifndef PASS_SHADOW vDiffuse = vec4(aColor.xyz * uMaterial.x, 1.0);
vDiffuse = vec4(aColor.xyz * uMaterial.x, 1.0); vDiffuse.xyz *= 2.0;
#ifdef PASS_COMPOSE
vDiffuse.xyz *= 2.0;
#endif
#ifdef TYPE_MIRROR #ifdef TYPE_MIRROR
vDiffuse.xyz = uMaterial.xyz; vDiffuse.xyz = uMaterial.xyz;
#endif #endif
#ifdef TYPE_FLASH #ifdef TYPE_FLASH
vDiffuse.xyz += uMaterial.w; vDiffuse.xyz += uMaterial.w;
#else #else
vDiffuse *= uMaterial.w; vDiffuse *= uMaterial.w;
#endif #endif
#ifdef TYPE_SPRITE #ifdef TYPE_SPRITE
vDiffuse *= aLight.w; vDiffuse *= aLight.w;
#endif
#endif #endif
} }
void _lighting(vec3 coord) { void _lighting(vec3 coord) {
#ifndef TYPE_FLASH #ifndef TYPE_FLASH
#ifdef PASS_COMPOSE vec3 lv0 = (uLightPos[0].xyz - coord) * uLightColor[0].w;
vec3 lv0 = (uLightPos[0].xyz - coord) * uLightColor[0].w; vec3 lv1 = (uLightPos[1].xyz - coord) * uLightColor[1].w;
vec3 lv1 = (uLightPos[1].xyz - coord) * uLightColor[1].w; vec3 lv2 = (uLightPos[2].xyz - coord) * uLightColor[2].w;
vec3 lv2 = (uLightPos[2].xyz - coord) * uLightColor[2].w; vec3 lv3 = (uLightPos[3].xyz - coord) * uLightColor[3].w;
vec3 lv3 = (uLightPos[3].xyz - coord) * uLightColor[3].w;
#ifdef OPT_VLIGHTVEC #ifdef OPT_VLIGHTVEC
vLightVec = lv0; vLightVec = lv0;
#endif #endif
vec4 lum, att; vec4 lum, att;
#ifdef TYPE_ENTITY #ifdef TYPE_ENTITY
lum.x = dot(vNormal.xyz, normalize(lv0)); lum.x = dot(vNormal.xyz, normalize(lv0));
att.x = dot(lv0, lv0); att.x = dot(lv0, lv0);
#else #else
lum.x = 1.0; lum.x = 1.0;
att.x = 0.0; att.x = 0.0;
#ifdef TYPE_SPRITE #ifdef TYPE_SPRITE
lum.x *= uMaterial.y; lum.x *= uMaterial.y;
#endif
#endif
lum.y = dot(vNormal.xyz, normalize(lv1)); att.y = dot(lv1, lv1);
lum.z = dot(vNormal.xyz, normalize(lv2)); att.z = dot(lv2, lv2);
lum.w = dot(vNormal.xyz, normalize(lv3)); att.w = dot(lv3, lv3);
vec4 light = max(vec4(0.0), lum) * max(vec4(0.0), vec4(1.0) - att);
#if (defined(TYPE_ENTITY) || defined(TYPE_ROOM)) && defined(UNDERWATER)
light.x *= 0.5 + abs(sin(dot(coord.xyz, vec3(1.0 / 1024.0)) + uParam.x)) * 0.75;
#endif
vec3 ambient;
#ifdef TYPE_ENTITY
#ifdef OPT_AMBIENT
ambient = calcAmbient(vNormal.xyz);
#else
ambient = vec3(uMaterial.y);
#endif
#else
ambient = min(uMaterial.yyy, aLight.xyz);
#endif
#ifdef OPT_SHADOW
vAmbient = ambient;
vLight = light;
vLightMap = aLight.xyz * light.x;
#ifdef OPT_VLIGHTPROJ
vLightProj = calcLightProj(coord, lv0, vNormal.xyz);
#endif
#else
vLight.xyz = uLightColor[1].xyz * light.y + uLightColor[2].xyz * light.z + uLightColor[3].xyz * light.w;
vLight.w = 0.0;
#ifdef TYPE_ENTITY
vLight.xyz += ambient + uLightColor[0].xyz * light.x;
#else
vLight.xyz += aLight.xyz * light.x;
#endif
#endif #endif
#endif #endif
#ifdef PASS_AMBIENT lum.y = dot(vNormal.xyz, normalize(lv1)); att.y = dot(lv1, lv1);
vLight = vec4(aLight.xyz, 1.0); lum.z = dot(vNormal.xyz, normalize(lv2)); att.z = dot(lv2, lv2);
lum.w = dot(vNormal.xyz, normalize(lv3)); att.w = dot(lv3, lv3);
vec4 light = max(vec4(0.0), lum) * max(vec4(0.0), vec4(1.0) - att);
#if (defined(TYPE_ENTITY) || defined(TYPE_ROOM)) && defined(UNDERWATER)
light.x *= 0.5 + abs(sin(dot(coord.xyz, vec3(1.0 / 1024.0)) + uParam.x)) * 0.75;
#endif
vec3 ambient;
#ifdef TYPE_ENTITY
#ifdef OPT_AMBIENT
ambient = calcAmbient(vNormal.xyz);
#else
ambient = vec3(uMaterial.y);
#endif
#else
ambient = min(uMaterial.yyy, aLight.xyz);
#endif
#ifdef OPT_SHADOW
vAmbient = ambient;
vLight = light;
vLightMap = aLight.xyz * light.x;
#ifdef OPT_VLIGHTPROJ
vLightProj = calcLightProj(coord, lv0, vNormal.xyz);
#endif
#else
vLight.xyz = uLightColor[1].xyz * light.y + uLightColor[2].xyz * light.z + uLightColor[3].xyz * light.w;
vLight.w = 0.0;
#ifdef TYPE_ENTITY
vLight.xyz += ambient + uLightColor[0].xyz * light.x;
#else
vLight.xyz += aLight.xyz * light.x;
#endif
#endif #endif
#endif #endif
} }
void _uv(vec3 coord) { void _uv(vec3 coord) {
vTexCoord = aTexCoord; vTexCoord = aTexCoord;
#if defined(PASS_COMPOSE) && !defined(TYPE_SPRITE) #ifndef TYPE_SPRITE
#ifdef OPT_TRAPEZOID #ifdef OPT_TRAPEZOID
vTexCoord.xy *= vTexCoord.zw; vTexCoord.xy *= vTexCoord.zw;
#endif #endif
@@ -264,27 +239,22 @@ uniform vec4 uFogParams;
void main() { void main() {
vec4 coord = _transform(); vec4 coord = _transform();
#ifndef PASS_SHADOW _diffuse();
_diffuse(); _lighting(coord.xyz);
_lighting(coord.xyz);
#endif
_uv(coord.xyz); _uv(coord.xyz);
gl_Position = uViewProj * coord; gl_Position = uViewProj * coord;
} }
#else #else
uniform sampler2D sDiffuse; uniform sampler2D sDiffuse;
#if defined(PASS_COMPOSE) && defined(TYPE_MIRROR) #ifdef TYPE_MIRROR
uniform samplerCube sEnvironment; uniform samplerCube sEnvironment;
#endif #endif
vec4 pack(float value) {
vec4 v = fract(value * vec4(1.0, 255.0, 65025.0, 16581375.0));
return v - v.yzww * vec4(1.0/255.0, 1.0/255.0, 1.0/255.0, 0.0);
}
float unpack(vec4 value) { float unpack(vec4 value) {
return dot(value, vec4(1.0, 1.0/255.0, 1.0/65025.0, 1.0/16581375.0)); return dot(value, vec4(1.0, 1.0/255.0, 1.0/65025.0, 1.0/16581375.0));
} }
@@ -392,14 +362,10 @@ uniform vec4 uFogParams;
vec2 uv = vTexCoord.xy; vec2 uv = vTexCoord.xy;
vec4 color; vec4 color;
#ifdef TYPE_MIRROR #ifdef TYPE_MIRROR
#ifdef PASS_COMPOSE vec3 rv = reflect(-normalize(vViewVec.xyz), normalize(vNormal.xyz));
vec3 rv = reflect(-normalize(vViewVec.xyz), normalize(vNormal.xyz)); color = textureCube(sEnvironment, normalize(rv));
color = textureCube(sEnvironment, normalize(rv));
#else
color = vec4(1.0);
#endif
#else #else
#if defined(PASS_COMPOSE) && !defined(TYPE_SPRITE) #ifndef TYPE_SPRITE
#ifdef OPT_TRAPEZOID #ifdef OPT_TRAPEZOID
uv /= vTexCoord.zw; uv /= vTexCoord.zw;
#endif #endif
@@ -413,107 +379,91 @@ uniform vec4 uFogParams;
discard; discard;
#endif #endif
#ifdef PASS_SHADOW color *= vDiffuse;
#if !defined(TYPE_FLASH) && !defined(TYPE_MIRROR)
#ifndef OPT_VLIGHTVEC
vec3 vLightVec = (uLightPos[0].xyz - vCoord) * uLightColor[0].w;
#endif
vec3 normal = normalize(vNormal.xyz);
#ifdef TYPE_ENTITY
float rSpecular = uMaterial.z;
#endif
#ifdef OPT_SHADOW
vec3 light = uLightColor[1].xyz * vLight.y + uLightColor[2].xyz * vLight.z + uLightColor[3].xyz * vLight.w;
#if defined(TYPE_ENTITY) || defined(TYPE_ROOM)
float rShadow = getShadow(vLightVec, normal);
#endif
#ifdef TYPE_ENTITY
rSpecular *= rShadow;
light += vAmbient + uLightColor[0].xyz * (vLight.x * rShadow);
#endif
#ifdef TYPE_ROOM
light += mix(vAmbient, vLightMap, rShadow);
#endif
#ifdef TYPE_SPRITE
light += vLightMap;
#endif
#ifdef SHADOW_COLOR
fragColor = pack(gl_FragCoord.z);
#else #else
fragColor = vec4(1.0); vec3 light = vLight.xyz;
#endif #endif
#else #ifdef UNDERWATER
color *= vDiffuse; float uwSign = 1.0;
#ifdef TYPE_ENTITY
#if !defined(TYPE_FLASH) && !defined(TYPE_MIRROR) uwSign = step(uParam.y, vCoord.y);
#ifdef PASS_AMBIENT
color.xyz *= vLight.xyz;
#endif #endif
#ifdef PASS_COMPOSE #ifdef OPT_CAUSTICS
light += calcCaustics(normal) * uwSign;
#ifndef OPT_VLIGHTVEC
vec3 vLightVec = (uLightPos[0].xyz - vCoord) * uLightColor[0].w;
#endif
vec3 normal = normalize(vNormal.xyz);
#ifdef TYPE_ENTITY
float rSpecular = uMaterial.z;
#endif
#ifdef OPT_SHADOW
vec3 light = uLightColor[1].xyz * vLight.y + uLightColor[2].xyz * vLight.z + uLightColor[3].xyz * vLight.w;
#if defined(TYPE_ENTITY) || defined(TYPE_ROOM)
float rShadow = getShadow(vLightVec, normal);
#endif
#ifdef TYPE_ENTITY
rSpecular *= rShadow;
light += vAmbient + uLightColor[0].xyz * (vLight.x * rShadow);
#endif
#ifdef TYPE_ROOM
light += mix(vAmbient, vLightMap, rShadow);
#endif
#ifdef TYPE_SPRITE
light += vLightMap;
#endif
#else
vec3 light = vLight.xyz;
#endif
#ifdef UNDERWATER
float uwSign = 1.0;
#ifdef TYPE_ENTITY
uwSign = step(uParam.y, vCoord.y);
#endif
#ifdef OPT_CAUSTICS
light += calcCaustics(normal) * uwSign;
#endif
#endif
#ifdef OPT_CONTACT
light *= getContactAO(vCoord, normal) * 0.5 + 0.5;
#endif
color.xyz *= light;
#if defined(TYPE_ENTITY) && defined(OPT_UNDERWATER_FOG)
float specular = calcSpecular(normal, vViewVec.xyz, vLightVec, uLightColor[0], rSpecular);
#ifdef UNDERWATER
specular *= (1.0 - uwSign);
#endif
color.xyz += specular;
#endif
#ifdef UNDERWATER
#ifdef OPT_UNDERWATER_FOG
float dist;
if (uViewPos.y < uParam.y)
dist = abs((vCoord.y - uParam.y) / normalize(uViewPos.xyz - vCoord.xyz).y);
else
dist = length(uViewPos.xyz - vCoord.xyz);
float fog = clamp(1.0 / exp(dist * WATER_FOG_DIST * uwSign), 0.0, 1.0);
dist += vCoord.y - uParam.y;
color.xyz *= mix(vec3(1.0), UNDERWATER_COLOR, clamp(dist * WATER_COLOR_DIST * uwSign, 0.0, 2.0));
color.xyz = mix(UNDERWATER_COLOR * 0.2, color.xyz, fog);
#else
color.xyz = mix(color.xyz, color.xyz * UNDERWATER_COLOR, uwSign);
color.xyz = mix(uFogParams.xyz, color.xyz, vNormal.w);
#endif
#else
color.xyz = mix(uFogParams.xyz, color.xyz, vNormal.w);
#endif
#endif #endif
#endif #endif
fragColor = color; #ifdef OPT_CONTACT
light *= getContactAO(vCoord, normal) * 0.5 + 0.5;
#endif
color.xyz *= light;
#if defined(TYPE_ENTITY) && defined(OPT_UNDERWATER_FOG)
float specular = calcSpecular(normal, vViewVec.xyz, vLightVec, uLightColor[0], rSpecular);
#ifdef UNDERWATER
specular *= (1.0 - uwSign);
#endif
color.xyz += specular;
#endif
#ifdef UNDERWATER
#ifdef OPT_UNDERWATER_FOG
float dist;
if (uViewPos.y < uParam.y)
dist = abs((vCoord.y - uParam.y) / normalize(uViewPos.xyz - vCoord.xyz).y);
else
dist = length(uViewPos.xyz - vCoord.xyz);
float fog = clamp(1.0 / exp(dist * WATER_FOG_DIST * uwSign), 0.0, 1.0);
dist += vCoord.y - uParam.y;
color.xyz *= mix(vec3(1.0), UNDERWATER_COLOR, clamp(dist * WATER_COLOR_DIST * uwSign, 0.0, 2.0));
color.xyz = mix(UNDERWATER_COLOR * 0.2, color.xyz, fog);
#else
color.xyz = mix(color.xyz, color.xyz * UNDERWATER_COLOR, uwSign);
color.xyz = mix(UNDERWATER_COLOR * 0.2, color.xyz, vNormal.w);
#endif
#else
color.xyz = mix(uFogParams.xyz, color.xyz, vNormal.w);
#endif
#endif #endif
fragColor = color;
} }
#endif #endif
)====" )===="

60
src/shaders/shadow.glsl Normal file
View File

@@ -0,0 +1,60 @@
R"====(
#ifdef ALPHA_TEST
varying vec2 vTexCoord;
#endif
#ifdef VERTEX
uniform mat4 uViewProj;
uniform vec4 uBasis[32 * 2];
attribute vec4 aCoord;
#ifdef ALPHA_TEST
attribute vec4 aTexCoord;
#endif
vec3 mulQuat(vec4 q, vec3 v) {
return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + v * q.w);
}
vec3 mulBasis(vec4 rot, vec3 pos, vec3 v) {
return mulQuat(rot, v) + pos;
}
void main() {
int index = int(aCoord.w * 2.0);
vec4 rBasisRot = uBasis[index];
vec4 rBasisPos = uBasis[index + 1];
#ifdef ALPHA_TEST
vTexCoord = aTexCoord.xy;
#endif
vec3 coord = mulBasis(rBasisRot, rBasisPos.xyz, aCoord.xyz);
gl_Position = uViewProj * vec4(coord, rBasisPos.w);
}
#else
#ifdef ALPHA_TEST
uniform sampler2D sDiffuse;
#endif
vec4 pack(float value) {
vec4 v = fract(value * vec4(1.0, 255.0, 65025.0, 16581375.0));
return v - v.yzww * vec4(1.0/255.0, 1.0/255.0, 1.0/255.0, 0.0);
}
void main() {
#ifdef ALPHA_TEST
if (texture2D(sDiffuse, vTexCoord).w <= 0.5)
discard;
#endif
#ifdef SHADOW_COLOR
fragColor = pack(gl_FragCoord.z);
#else
fragColor = vec4(1.0);
#endif
}
#endif
)===="