pyrite-dev/assaultfish
13
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cascade shadows #1

Merged
nishi merged 3 commits from cascade-shadows into master 2026-02-03 10:11:35 +09:00
Conversation 0 Commits 3 Files changed 8 +188 -106
8 changed files with 188 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

15
client/main.c
View file

@ -39,6 +39,7 @@ static void tick(void){
} }
GSPhysicsObject obj[128]; GSPhysicsObject obj[128];
GSModel mdl;
static void render(GSEngine self){ static void render(GSEngine self){
GSGL gl = GSClientGetGL(GSEngineGetClient(self)); GSGL gl = GSClientGetGL(GSEngineGetClient(self));
@ -46,10 +47,10 @@ static void render(GSEngine self){
GSVector4 col1 = {1, 0, 0, 1}; GSVector4 col1 = {1, 0, 0, 1};
GSVector4 col2 = {1, 1, 1, 1}; GSVector4 col2 = {1, 1, 1, 1};
GSVector3 v[] = { GSVector3 v[] = {
{-20, 0, 20}, {-40, 0, 40},
{-20, 0, -20}, {-40, 0, -40},
{20, 0, -20}, {40, 0, -40},
{20, 0, 20} {40, 0, 40}
}; };
GSVector3 n = {0, 1, 0}; GSVector3 n = {0, 1, 0};
@ -63,7 +64,7 @@ static void render(GSEngine self){
GSGLPushMatrix(gl); GSGLPushMatrix(gl);
GSGLSetPosition(gl, rv); GSGLSetPosition(gl, rv);
GSGLSetRotation3x3(gl, rm); GSGLSetRotation3x3(gl, rm);
GSGLTetrakis(gl, 0.5, col1, col2); GSModelDraw(mdl);
GSGLPopMatrix(gl); GSGLPopMatrix(gl);
} }
@ -104,6 +105,9 @@ int main(int argc, char** argv){
int i; int i;
GSVector3 pos = {0, 1, 0}; GSVector3 pos = {0, 1, 0};
GSVector3 sz = {1, 1, 1}; GSVector3 sz = {1, 1, 1};
mdl = GSModelOpen(engine, "game:/mdl/fish.gsm");
for(i = 0; i < sizeof(obj) / sizeof(obj[0]); i++){ for(i = 0; i < sizeof(obj) / sizeof(obj[0]); i++){
obj[i] = GSPhysicsCreateSphere(GSServerGetPhysics(GSEngineGetServer(engine)), 1, 0.5); obj[i] = GSPhysicsCreateSphere(GSServerGetPhysics(GSEngineGetServer(engine)), 1, 0.5);
@ -116,6 +120,7 @@ int main(int argc, char** argv){
GSClientSetSkybox(GSEngineGetClient(engine), GSTrue); GSClientSetSkybox(GSEngineGetClient(engine), GSTrue);
GSEngineLoop(engine); GSEngineLoop(engine);
GSModelClose(mdl);
GSEngineDestroy(engine); GSEngineDestroy(engine);
} }
} }

35
engine/data/shader/shadow.fs
View file

@ -2,13 +2,18 @@
varying vec4 vPos; varying vec4 vPos;
varying vec3 vNrm; varying vec3 vNrm;
varying vec4 vShadowCoord; varying vec4 vShadowCoord0;
varying vec4 vShadowCoord1;
varying vec4 vShadowCoord2;
varying vec4 vColor; varying vec4 vColor;
uniform sampler2D depth_texture; uniform sampler2D shadow_map0;
uniform sampler2D shadow_map1;
uniform sampler2D shadow_map2;
uniform sampler2D current_texture; uniform sampler2D current_texture;
uniform float enable_lighting; uniform float enable_lighting;
uniform float enable_texture; uniform float enable_texture;
uniform vec3 camera;
vec4 PhongShading(void) vec4 PhongShading(void)
{ {
@ -36,14 +41,14 @@ vec4 PhongShading(void)
return ambient+diffuse+specular; return ambient+diffuse+specular;
} }
float ShadowCoef(void){ float SampleShadow(sampler2D shadowMap, vec4 shadowCoord) {
vec3 shadow_coord = vShadowCoord.xyz / vShadowCoord.w; vec3 shadow_c = shadowCoord.xyz / shadowCoord.w;
float view = shadow_coord.z; float view = shadow_c.z;
vec2 d[4];
float shadow_coef = 1.0; float shadow_coef = 1.0;
vec2 d[4];
int i; int i;
if(shadow_coord.z > 1.0) return 1.0; if(shadow_c.z > 1.0) return 1.0;
d[0] = vec2(-0.94201624, -0.39906216); d[0] = vec2(-0.94201624, -0.39906216);
d[1] = vec2(0.94558609, -0.76890725); d[1] = vec2(0.94558609, -0.76890725);
@ -51,11 +56,11 @@ float ShadowCoef(void){
d[3] = vec2(0.34495938, 0.29387760); d[3] = vec2(0.34495938, 0.29387760);
for(i = 0; i < 4; i++){ for(i = 0; i < 4; i++){
vec2 p = shadow_coord.xy + d[i] / 700.0; vec2 p = shadow_c.xy + d[i] / 700.0;
if(p.x < 0.0 || p.y < 0.0 || p.x > 1.0 || p.y > 1.0) shadow_coef += 1.0; if(p.x < 0.0 || p.y < 0.0 || p.x > 1.0 || p.y > 1.0) shadow_coef += 1.0;
if(texture2D(depth_texture, p).z < view){ if(texture2D(shadowMap, p).z < view){
shadow_coef -= 0.2; shadow_coef -= 0.2;
} }
} }
@ -63,6 +68,18 @@ float ShadowCoef(void){
return shadow_coef; return shadow_coef;
} }
float ShadowCoef(void){
float dist = length(normalize(camera + gl_LightSource[0].position.xyz) - vPos.xyz);
if(gl_LightSource[0].position.w > 0.5){
if(dist >= 10.0) return 1.0;
}
if(dist < 10.0) return SampleShadow(shadow_map0, vShadowCoord0);
if(dist < 40.0) return SampleShadow(shadow_map1, vShadowCoord1);
return SampleShadow(shadow_map2, vShadowCoord2);
}
void main(void){ void main(void){
vec4 c = PhongShading(); vec4 c = PhongShading();
vec4 ambient = gl_LightSource[0].ambient; vec4 ambient = gl_LightSource[0].ambient;

10
engine/data/shader/shadow.vs
View file

@ -2,17 +2,21 @@
varying vec4 vPos; varying vec4 vPos;
varying vec3 vNrm; varying vec3 vNrm;
varying vec4 vShadowCoord; varying vec4 vShadowCoord0;
varying vec4 vShadowCoord1;
varying vec4 vShadowCoord2;
varying vec4 vColor; varying vec4 vColor;
void main(void){ void main(void){
vPos = gl_ModelViewMatrix * gl_Vertex; vPos = gl_ModelViewMatrix * gl_Vertex;
vNrm = normalize(gl_NormalMatrix * gl_Normal); vNrm = normalize(gl_NormalMatrix * gl_Normal);
vShadowCoord = gl_TextureMatrix[7] * gl_ModelViewMatrix * gl_Vertex; vShadowCoord0 = gl_TextureMatrix[5] * gl_ModelViewMatrix * gl_Vertex;
vShadowCoord1 = gl_TextureMatrix[6] * gl_ModelViewMatrix * gl_Vertex;
vShadowCoord2 = gl_TextureMatrix[7] * gl_ModelViewMatrix * gl_Vertex;
vColor = gl_Color; vColor = gl_Color;
gl_Position = gl_ProjectionMatrix * vPos; gl_Position = gl_ProjectionMatrix * vPos;
gl_FrontColor = gl_Color; gl_FrontColor = gl_Color;
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0; gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
} }

7
engine/include/GearSrc/GL.h
View file

@ -37,12 +37,15 @@ GSDECL void GSGLTetrakis(GSGL gl, GSNumber scale, GSVector4 col1, GSVector4 co
/* gl_shadow.c */ /* gl_shadow.c */
GSDECL void GSGLShadowInit(GSGL gl); GSDECL void GSGLShadowInit(GSGL gl);
GSDECL GSBool GSGLShadowBeforeMapping(GSGL gl); GSDECL GSBool GSGLShadowBegin(GSGL gl);
GSDECL void GSGLShadowAfterMapping(GSGL gl); GSDECL void GSGLShadowCascade(GSGL gl, int cascade);
GSDECL void GSGLShadowCopy(GSGL gl, int cascade);
GSDECL void GSGLShadowApply(GSGL gl);
GSDECL void GSGLShadowEnd(GSGL gl); GSDECL void GSGLShadowEnd(GSGL gl);
GSDECL void GSGLShadowDeinit(GSGL gl); GSDECL void GSGLShadowDeinit(GSGL gl);
GSDECL void GSGLShadowDisable(GSGL gl); GSDECL void GSGLShadowDisable(GSGL gl);
GSDECL void GSGLShadowEnable(GSGL gl); GSDECL void GSGLShadowEnable(GSGL gl);
GSDECL int GSGLShadowCascadeSteps(GSGL gl);
/* gl.c */ /* gl.c */
GSDECL GSGL GSGLCreate(GSClient client); GSDECL GSGL GSGLCreate(GSClient client);

8
engine/include/GearSrc/TypeDefs.h
View file

@ -181,14 +181,16 @@ struct _GSNetKV {
#include <miniaudio.h> #include <miniaudio.h>
#include <ode/ode.h> #include <ode/ode.h>
#define GSGL_SHADOW_CASCADES 3
struct _GSGL { struct _GSGL {
GSEngine engine; GSEngine engine;
int shadow_use_shader; int shadow_use_shader;
GLuint shadow_texture; GLuint shadow_texture[GSGL_SHADOW_CASCADES];
GLuint shadow_shader; GLuint shadow_shader;
GLdouble shadow_modelview[16]; GLdouble shadow_modelview[GSGL_SHADOW_CASCADES][16];
GLdouble shadow_projection[16]; GLdouble shadow_projection[GSGL_SHADOW_CASCADES][16];
GLdouble shadow_old_projection[16]; GLdouble shadow_old_projection[16];
GLdouble shadow_old_modelview[16]; GLdouble shadow_old_modelview[16];

11
engine/src/client.c
View file

@ -132,9 +132,14 @@ void GSClientStep(GSClient client) {
GSGLTextBold(client->gl, 0); GSGLTextBold(client->gl, 0);
if(GSGLShadowBeforeMapping(client->gl)) { if(GSGLShadowBegin(client->gl)) {
scene(client); int c;
GSGLShadowAfterMapping(client->gl); for(c = 0; c < GSGLShadowCascadeSteps(client->gl); c++) {
GSGLShadowCascade(client->gl, c);
scene(client);
GSGLShadowCopy(client->gl, c);
}
GSGLShadowApply(client->gl);
} }
if(client->skybox_enabled) { if(client->skybox_enabled) {

6
engine/src/gl/gl_camera.c
View file

@ -63,6 +63,12 @@ void GSGLCameraLookAt(GSGL gl, GSVector3 camera, GSVector3 look_at) {
glMultMatrixd(matrix); glMultMatrixd(matrix);
glTranslated(-camera[0], -camera[1], camera[2]); glTranslated(-camera[0], -camera[1], camera[2]);
if(gl->shadow_use_shader){
glUseProgram(gl->shadow_shader);
glUniform3f(glGetUniformLocation(gl->shadow_shader, "camera"), camera[0], camera[1], camera[2]);
glUseProgram(0);
}
} }
void GSGLCameraSetup(GSGL gl) { void GSGLCameraSetup(GSGL gl) {

216
engine/src/gl/gl_shadow.c
View file

@ -6,30 +6,37 @@
void GSGLShadowInit(GSGL gl) { void GSGLShadowInit(GSGL gl) {
GLfloat color[] = {1, 1, 1, 1}; GLfloat color[] = {1, 1, 1, 1};
int i;
glGenTextures(1, &gl->shadow_texture); glGenTextures(GSGL_SHADOW_CASCADES, gl->shadow_texture);
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, GSGLMaxShadowDistance, GSGLMaxShadowDistance, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); for(i = 0; i < GSGL_SHADOW_CASCADES; i++) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glBindTexture(GL_TEXTURE_2D, gl->shadow_texture[i]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, GSGLMaxShadowDistance, GSGLMaxShadowDistance, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, color); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE); glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, color);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
}
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
if(GSGLShaderPrepare(gl, &gl->shadow_shader, "base:/shader/shadow.vs", "base:/shader/shadow.fs")) { if(GSGLShaderPrepare(gl, &gl->shadow_shader, "base:/shader/shadow.vs", "base:/shader/shadow.fs")) {
glUseProgram(gl->shadow_shader); glUseProgram(gl->shadow_shader);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "depth_texture"), 7); glUniform1i(glGetUniformLocation(gl->shadow_shader, "shadow_map0"), 5);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "shadow_map1"), 6);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "shadow_map2"), 7);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "current_texture"), 0); glUniform1i(glGetUniformLocation(gl->shadow_shader, "current_texture"), 0);
glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_lighting"), 1); glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_lighting"), 1);
glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_texture"), 0); glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_texture"), 0);
@ -37,57 +44,22 @@ void GSGLShadowInit(GSGL gl) {
gl->shadow_use_shader = 1; gl->shadow_use_shader = 1;
} else { } else {
glDeleteTextures(1, &gl->shadow_texture); glDeleteTextures(GSGL_SHADOW_CASCADES, gl->shadow_texture);
gl->shadow_use_shader = 0; gl->shadow_use_shader = 0;
} }
} }
GSBool GSGLShadowBeforeMapping(GSGL gl) { GSBool GSGLShadowBegin(GSGL gl) {
GSVector3 zero = {0, 0, 0};
if(!gl->shadow_use_shader) return GSFalse; if(!gl->shadow_use_shader) return GSFalse;
GSGLClear(gl);
glViewport(0, 0, GSGLMaxShadowDistance, GSGLMaxShadowDistance);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_old_projection); glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_old_projection);
glLoadIdentity();
if(gl->engine->client->light0[3]) {
GSGLCameraPerspective(gl, GSGLMaxShadowDistance, GSGLMaxShadowDistance);
} else {
glOrtho(-5, 5, -5, 5, -5, 10);
}
glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_projection);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_old_modelview); glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_old_modelview);
glLoadIdentity();
if(gl->engine->client->light0[3]){
GSGLCameraLookAt(gl, gl->engine->client->light0, zero);
}else{
GSVector3 n;
int i;
for(i = 0; i < 3; i++) n[i] = gl->engine->client->light0[i];
GSMathNormalize3(n);
for(i = 0; i < 3; i++){
n[i] *= 5;
n[i] += gl->engine->client->position[i];
}
GSGLCameraLookAt(gl, n, gl->engine->client->position);
}
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_modelview);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
#ifdef SHADOW_CULL #ifdef SHADOW_CULL
@ -102,22 +74,84 @@ GSBool GSGLShadowBeforeMapping(GSGL gl) {
return GSTrue; return GSTrue;
} }
void GSGLShadowAfterMapping(GSGL gl) { int GSGLShadowCascadeSteps(GSGL gl){
GSMatrix4x4 in, in2, out, out2; if(gl->engine->client->light0[3]) return 1;
GLdouble mat[16];
int i;
glDisable(GL_POLYGON_OFFSET_FILL); return GSGL_SHADOW_CASCADES;
}
glActiveTexture(GL_TEXTURE7); void GSGLShadowCascade(GSGL gl, int cascade) {
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture); GSVector3 zero = {0, 0, 0};
GSNumber size;
GSGLClear(gl);
glViewport(0, 0, GSGLMaxShadowDistance, GSGLMaxShadowDistance);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Simple cascade sizing
if(cascade == 0) size = 10;
else if(cascade == 1) size = 40;
else size = 100; // Covers max distance roughly
// If light is directional (light0[3] == 0)
// Current existing code logic:
if(gl->engine->client->light0[3]) {
// Point/Spot light - no cascade support implies here?
// Fallback to perspective for all cascades?
// Or just use the original logic.
GSGLCameraPerspective(gl, GSGLMaxShadowDistance, GSGLMaxShadowDistance);
} else {
// Directional
glOrtho(-size, size, -size, size, -size * 2, size * 2);
}
glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_projection[cascade]);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(gl->engine->client->light0[3]) {
GSGLCameraLookAt(gl, gl->engine->client->light0, zero);
} else {
GSVector3 n;
int i;
for(i = 0; i < 3; i++) n[i] = gl->engine->client->light0[i];
GSMathNormalize3(n);
for(i = 0; i < 3; i++) {
n[i] *= size; // Move light pos away based on size to ensure coverage
n[i] += gl->engine->client->position[i];
}
GSGLCameraLookAt(gl, n, gl->engine->client->position);
}
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_modelview[cascade]);
}
void GSGLShadowCopy(GSGL gl, int cascade) {
if(cascade < 0 || cascade >= GSGL_SHADOW_CASCADES) return;
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture[cascade]);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GSGLMaxShadowDistance, GSGLMaxShadowDistance); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, GSGLMaxShadowDistance, GSGLMaxShadowDistance);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0); }
void GSGLShadowApply(GSGL gl) {
GSMatrix4x4 in, in2, out, out2;
GLdouble mat[16];
int i, c;
glDisable(GL_POLYGON_OFFSET_FILL);
glViewport(0, 0, gl->engine->width, gl->engine->height); glViewport(0, 0, gl->engine->width, gl->engine->height);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);
#ifdef SHADOW_CULL #ifdef SHADOW_CULL
glCullFace(GL_BACK); glCullFace(GL_BACK);
#else #else
@ -132,75 +166,81 @@ void GSGLShadowAfterMapping(GSGL gl) {
glLoadIdentity(); glLoadIdentity();
glMultMatrixd(gl->shadow_old_modelview); glMultMatrixd(gl->shadow_old_modelview);
glActiveTexture(GL_TEXTURE7); // Calculate texture matrices for each cascade
glMatrixMode(GL_TEXTURE); for(c = 0; c < GSGL_SHADOW_CASCADES; c++) {
glLoadIdentity(); glActiveTexture(GL_TEXTURE5 + c);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
for(i = 0; i < 16; i++) in[i] = gl->shadow_old_modelview[i]; for(i = 0; i < 16; i++) in[i] = gl->shadow_old_modelview[i];
GSMathColumnToRow4x4(in2, in); GSMathColumnToRow4x4(in2, in);
GSMathInvert4x4(out, in2); GSMathInvert4x4(out, in2);
GSMathRowToColumn4x4(out2, out); GSMathRowToColumn4x4(out2, out);
for(i = 0; i < 16; i++) mat[i] = out2[i]; for(i = 0; i < 16; i++) mat[i] = out2[i];
glTranslated(0.5, 0.5, 0.5); glTranslated(0.5, 0.5, 0.5);
glScaled(0.5, 0.5, 0.5); glScaled(0.5, 0.5, 0.5);
glMultMatrixd(gl->shadow_projection); glMultMatrixd(gl->shadow_projection[c]);
glMultMatrixd(gl->shadow_modelview); glMultMatrixd(gl->shadow_modelview[c]);
glMultMatrixd(mat); glMultMatrixd(mat);
}
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
GSGLClear(gl); GSGLClear(gl); // Clear for main render
GSGLShadowEnable(gl); GSGLShadowEnable(gl);
} }
void GSGLShadowDisable(GSGL gl) { void GSGLShadowDisable(GSGL gl) {
int i;
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
if(gl->shadow_use_shader) { if(gl->shadow_use_shader) {
glUseProgram(0); glUseProgram(0);
glActiveTexture(GL_TEXTURE7); for(i = 0; i < GSGL_SHADOW_CASCADES; i++) {
glDisable(GL_TEXTURE_2D); glActiveTexture(GL_TEXTURE5 + i);
glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
}
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
} }
} }
void GSGLShadowEnable(GSGL gl) { void GSGLShadowEnable(GSGL gl) {
int i;
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);
if(gl->shadow_use_shader) { if(gl->shadow_use_shader) {
glUseProgram(gl->shadow_shader); glUseProgram(gl->shadow_shader);
glActiveTexture(GL_TEXTURE7); for(i = 0; i < GSGL_SHADOW_CASCADES; i++) {
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture); glActiveTexture(GL_TEXTURE5 + i);
glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, gl->shadow_texture[i]);
glEnable(GL_TEXTURE_2D);
}
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
} }
} }
void GSGLShadowEnd(GSGL gl) { void GSGLShadowEnd(GSGL gl) {
int i;
if(!gl->shadow_use_shader) return; if(!gl->shadow_use_shader) return;
GSGLShadowDisable(gl); GSGLShadowDisable(gl);
glActiveTexture(GL_TEXTURE7); // Reset texture matrices
glDisable(GL_TEXTURE_2D); for(i = 0; i < GSGL_SHADOW_CASCADES; i++) {
glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE5 + i);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
}
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE7);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glActiveTexture(GL_TEXTURE0);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
} }
void GSGLShadowDeinit(GSGL gl) { void GSGLShadowDeinit(GSGL gl) {
if(gl->shadow_use_shader) { if(gl->shadow_use_shader) {
glDeleteTextures(1, &gl->shadow_texture); glDeleteTextures(GSGL_SHADOW_CASCADES, gl->shadow_texture);
glDeleteProgram(gl->shadow_shader); glDeleteProgram(gl->shadow_shader);
} }
} }