tenebrae/tenebrae2
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
tenebrae2/shaders.c
cholleme 74e411262d made argument const
2003-11-16 22:17:05 +00:00

782 lines
20 KiB
C
Raw Blame History

/*
Copyright (C) 2001-2002 Charles Hollemeersch
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
PENTA: the whole file is freakin penta...
"Shader" loading an management.
All .shader files are parsed on engine startup. We don't load textures for these of course,
textures are only loaded per level.
*/
#include "quakedef.h"
static shader_t *shaderList;
/*=====================================================
Generic shader routines
======================================================*/
void GL_ShaderLoadTextures(shader_t *shader);
static qboolean shader_haserrors;
static qboolean shaders_reloading = false;
void ShaderError(void) {
shader_haserrors = true;
if ( COM_CheckParm ("-forceshaders") || shaders_reloading )
return;
Con_NotifyBox("Shader error\nSee above for details\n");
}
/**
* Generates a clean stage before one is parsed over it
*/
void clearStage(stage_t *stage) {
memset(stage,0,sizeof(stage_t));
stage->texture[0] = NULL;
stage->alphatresh = 0;
stage->type = STAGE_SIMPLE;
stage->src_blend = -1;
stage->dst_blend = -1;
}
/**
* Generates a default shader from the given name.
*/
void initDefaultStage(char *texname, stage_t *stage, stagetype_t type) {
//memset(stage,0,sizeof(stage_t));
clearStage(stage);
stage->numtextures = 1;
stage->numtcmods = 0;
stage->type = type;
strncpy(stage->filename,texname,2*MAX_QPATH+1);
}
/**
* Generates a default shader from the given name.
*/
void initDefaultShader(char *name, shader_t *shader) {
char namebuff[256];
memset(shader,0,sizeof(shader));
strncpy(shader->name,name,sizeof(shader->name));
shader->flags = 0;
shader->numstages = 0;
shader->mipmap = true;
shader->cull = true;
sprintf(namebuff,"%s.tga",name);
initDefaultStage(namebuff, &shader->colorstages[0], STAGE_COLOR);
sprintf(namebuff,"%s_norm.tga|%s_gloss.tga",name,name);
initDefaultStage(namebuff, &shader->bumpstages[0], STAGE_BUMP);
initDefaultStage(namebuff, &shader->glossstages[0], STAGE_GRAYGLOSS);
shader->numbumpstages = 1;
shader->numglossstages = 1;
shader->numcolorstages = 1;
shader->flags |= (SURF_GLOSS | SURF_PPLIGHT | SURF_BUMP);
}
void initErrorShader(shader_t *shader) {
shader->numbumpstages = 0;
shader->numcolorstages = 0;
shader->numglossstages = 0;
shader->flags = 0;
shader->cull = true;
shader->mipmap = true;
shader->numstages = 1;
initDefaultStage("textures/system/shadererror.tga", &shader->stages[0], STAGE_SIMPLE);
}
/*
================
GL_ShaderForName
Load a shader, searches for the shader in the shader list
and returns a pointer to the shader
================
*/
shader_t *GL_ShaderForName(const char *name) {
shader_t *s;
s = shaderList;
//Con_Printf("ShaderForName %s\n",name);
while(s) {
if (!strcmp(name,s->name)) {
if (!s->texturesAreLoaded)
GL_ShaderLoadTextures(s);
s->texturesAreLoaded = true;
return s;
}
s = s->next;
}
//Shader not found: make a shader with the default filenames (_bump, _gloss, _normal)
s = malloc(sizeof(shader_t));
if (!s) {
Sys_Error("Malloc failed!");
}
//initDefaultShader(name,s);
strncpy(s->name, name, SHADER_MAX_NAME);
initErrorShader(s);
s->next = shaderList;
shaderList = s;
GL_ShaderLoadTextures(s);
s->texturesAreLoaded = true;
return s;
}
/*
================
StageLoadTextures
load all the textures for the given stage
================
*/
void StageLoadTextures(stage_t *stage, shader_t *shader) {
stage->numtextures = 1;
switch (stage->type) {
case STAGE_COLOR:
case STAGE_GLOSS:
stage->texture[0] = GL_CacheTexture(stage->filename, shader->mipmap, TEXTURE_RGB);
break;
case STAGE_SIMPLE:
if (stage->flags & STAGE_CUBEMAP)
stage->texture[0] = GL_CacheTexture(stage->filename, shader->mipmap, TEXTURE_CUBEMAP);
else
stage->texture[0] = GL_CacheTexture(stage->filename, shader->mipmap, TEXTURE_RGB);
break;
case STAGE_BUMP:
stage->texture[0] = GL_CacheTexture(stage->filename, shader->mipmap, TEXTURE_NORMAL);
break;
}
}
/*
================
GL_ShaderLoadTextures
load all the textures for the given shader
================
*/
void GL_ShaderLoadTextures(shader_t *shader) {
int i, j;
for (i=0; i<shader->numstages; i++) {
StageLoadTextures(&shader->stages[i],shader);
}
for (i=0; i<shader->numbumpstages; i++) {
StageLoadTextures(&shader->bumpstages[i],shader);
}
for (i=0; i<shader->numglossstages; i++) {
StageLoadTextures(&shader->glossstages[i],shader);
}
for (i=0; i<shader->numcolorstages; i++) {
StageLoadTextures(&shader->colorstages[i],shader);
}
for (i=0; i<shader->numglossstages; i++) {
if (shader->glossstages[i].type == STAGE_GRAYGLOSS) {
for (j=0; j< shader->glossstages[i].numtextures; j++)
shader->glossstages[i].texture[j] = shader->bumpstages[i].texture[j];
}
}
}
qboolean IsShaderBlended(shader_t *s) {
if (s->numstages)
return (s->stages[0].src_blend >= 0);
if (s->numcolorstages)
return (s->colorstages[0].src_blend >= 0);
return false;
}
/*=====================================================
Shader script parsing
======================================================*/
// parse some stuff but make sure you give some errors
#define GET_SAFE_TOKEN data = COM_Parse (data);\
if (!data) {\
Con_Printf ("LoadShader: EOF without closing brace");\
ShaderError();\
}\
if (com_token[0] == '}') {\
Sys_Error ("LoadShader: '}' not expected here");\
ShaderError();\
}
/**
* Parse a tcmod command out of the shader file
*/
char *ParceTcMod(char *data, stage_t *stage) {
GET_SAFE_TOKEN;
if (stage->numtcmods >= SHADER_MAX_TCMOD) {
Sys_Error("More than %i tcmods in stage\n",SHADER_MAX_TCMOD);
}
if (!strcmp(com_token, "rotate")) {
stage->tcmods[stage->numtcmods].type = TCMOD_ROTATE;
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[0] = atof(com_token);
} else if (!strcmp(com_token, "scroll")) {
stage->tcmods[stage->numtcmods].type = TCMOD_SCROLL;
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[0] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[1] = atof(com_token);
} else if (!strcmp(com_token, "scale")) {
stage->tcmods[stage->numtcmods].type = TCMOD_SCALE;
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[0] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[1] = atof(com_token);
} else if (!strcmp(com_token, "stretch")) {
stage->tcmods[stage->numtcmods].type = TCMOD_STRETCH;
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[0] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[1] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[2] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[3] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[4] = atof(com_token);
} else if (!strcmp(com_token, "turb")) {
//parse it and give a warning that it's not supported
stage->tcmods[stage->numtcmods].type = TCMOD_SCALE;
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[0] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[1] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[2] = atof(com_token);
GET_SAFE_TOKEN;
stage->tcmods[stage->numtcmods].params[3] = atoi(com_token);
Con_Printf("Warning: turb not supported by Tenebrae.\n");
} else {
Con_Printf("Sorry not supported yet ... maybe never\n");
}
stage->numtcmods++;
return data;
}
/**
* Parse a single shader stage out of the shader file
* returns the new position in the file
*/
char *ParseStage (char *data, shader_t *shader)
{
char command[MAX_QPATH];
char texture[MAX_QPATH*3+2], detail[MAX_QPATH];
stage_t stage;
qboolean isgraygloss, hascubetexture;
//Con_Printf("Parsing shader stage...\n");
clearStage(&stage);
isgraygloss = false;
hascubetexture = false;
// go through all the dictionary pairs
while (1)
{
data = COM_Parse (data);
//end of stage
if (com_token[0] == '}') {
//end of stage is parsed now set everything up correctly
strncpy(stage.filename,texture,MAX_QPATH*3+2);
stage.numtextures = 1;
if (stage.type == STAGE_GLOSS) {
//if it has a gray gloss map we change the bumpmaps filename so it loads the gray
//glossmap too, we won't bother with the glossmap in the graygloss shaders anymore
//as we just bind the bumpmap.
if (isgraygloss) {
stage_t *bumpstage;
//setup the filenames correctly
stage.type = STAGE_GRAYGLOSS;
if (shader->numbumpstages < 1) {
Con_Printf("Gray gloss defined before bumpmap\n");
ShaderError();
return NULL;
}
bumpstage = &shader->bumpstages[shader->numbumpstages-1];
sprintf(stage.filename,"%s|%s",bumpstage->filename,texture);
strcpy(bumpstage->filename, stage.filename);
}
shader->flags = shader->flags | SURF_GLOSS;
if (shader->numglossstages >= SHADER_MAX_BUMP_STAGES)
return NULL;
shader->glossstages[shader->numglossstages] = stage;
shader->numglossstages++;
} else if (stage.type == STAGE_COLOR) {
shader->flags = shader->flags | SURF_PPLIGHT;
if (shader->numcolorstages >= SHADER_MAX_BUMP_STAGES)
return NULL;
shader->colorstages[shader->numcolorstages] = stage;
shader->numcolorstages++;
} else if (stage.type == STAGE_BUMP) {
shader->flags = shader->flags | SURF_BUMP;
if (shader->numbumpstages >= SHADER_MAX_BUMP_STAGES)
return NULL;
shader->bumpstages[shader->numbumpstages] = stage;
shader->numbumpstages++;
} else { //Default stage
if (shader->numstages >= SHADER_MAX_STAGES)
return NULL;
if (hascubetexture)
stage.flags = stage.flags | STAGE_CUBEMAP;
shader->stages[shader->numstages] = stage;
shader->numstages++;
}
break;
}
//ugh nasty
if (!data) {
Con_Printf("ParseStage: EOF without '}'");
ShaderError();
return NULL;
}
//see what command it is
strncpy (command, com_token,sizeof(command));
if (!strcmp(command, "stage")) {
GET_SAFE_TOKEN;
if (!strcmp(com_token, "diffusemap")) {
stage.type = STAGE_COLOR;
} else if (!strcmp(com_token, "bumpmap")) {
stage.type = STAGE_BUMP;
} else if (!strcmp(com_token, "specularmap")) {
stage.type = STAGE_GLOSS;
} else {
Con_Printf("Unknown stage type %s\n",com_token);
ShaderError();
}
} else if (!strcmp(command, "map")) {
GET_SAFE_TOKEN;
if (!strcmp(com_token, "gray")) {
//If it has a gray modifier it means the glossmap has to be stored in the bumpmap alpha
GET_SAFE_TOKEN;
strncpy(texture,com_token, MAX_QPATH);
isgraygloss = true;
} else if (!strcmp(com_token, "add")) {
//It has an add modifier, add a bumpmap and a normalmap together
GET_SAFE_TOKEN;
strncpy(detail, com_token, MAX_QPATH);
GET_SAFE_TOKEN;
sprintf(texture, "%s+%s", detail, com_token);
} else if (!strcmp(com_token, "cube")) {
//It's a cube map
GET_SAFE_TOKEN;
strncpy(texture,com_token, MAX_QPATH);
hascubetexture = true;
} else
strncpy(texture,com_token,MAX_QPATH);
} else if (!strcmp(command, "tcMod")) {
data = ParceTcMod(data,&stage);
} else if (!strcmp(command, "blendfunc")) {
GET_SAFE_TOKEN;
stage.src_blend = SHADER_BlendModeForName(com_token);
if (stage.src_blend < 0) {
if (!strcmp(com_token,"blend")) {
stage.src_blend = GL_SRC_ALPHA;
stage.dst_blend = GL_ONE_MINUS_SRC_ALPHA;
} else if (!strcmp(com_token,"add")) {
stage.src_blend = GL_ONE;
stage.dst_blend = GL_ONE;
} else {
Con_Printf("Unknown blend func %s\n",com_token);
stage.src_blend = -1;
stage.dst_blend = -1;
}
} else {
GET_SAFE_TOKEN;
stage.dst_blend = SHADER_BlendModeForName(com_token);
if (stage.dst_blend < 0) {
Con_Printf("Unknown blend func %s\n",com_token);
ShaderError();
}
}
} else if (!strcmp(command, "alphafunc")) {
GET_SAFE_TOKEN;
if (!strcmp(com_token,"GE128")) {
stage.alphatresh = 128;
}
if ((stage.type == STAGE_BUMP) || (stage.type == STAGE_GLOSS)){
Con_Printf("Warning: Alphafunc with bump or normal stage type will be ignored.\n");
}
} else {
Con_Printf("Unknown statement %s\n",command);
ShaderError();
data = COM_SkipLine(data);
//return NULL; //stop parsing
}
}
return data;
}
/**
* Automatically generate a bump stage with the bumpmap keyword
*/
char *normalStage(char *data, shader_t *shader, char *name) {
stage_t *stage;
if (shader->numbumpstages >= SHADER_MAX_BUMP_STAGES)
return data;
stage = &shader->bumpstages[shader->numbumpstages];
shader->numbumpstages++;
clearStage(stage);
if (!strcmp(name,"add")) {
char buff[MAX_QPATH];
GET_SAFE_TOKEN;
strncpy(buff,com_token,MAX_QPATH);
GET_SAFE_TOKEN;
sprintf(stage->filename, "%s+%s", buff, com_token);
} else {
strncpy(stage->filename,name,MAX_QPATH);
}
stage->type = STAGE_BUMP;
shader->flags = shader->flags | SURF_BUMP;
return data;
}
/**
* Automatically generate a specular stage with the specularmap keyword
*/
void specularStage(shader_t *shader, char *name) {
stage_t *stage;
if (shader->numglossstages >= SHADER_MAX_BUMP_STAGES)
return;
stage = &shader->glossstages[shader->numglossstages];
shader->numglossstages++;
clearStage(stage);
stage->type = STAGE_GLOSS;
strncpy(stage->filename,name,MAX_QPATH);
shader->flags = shader->flags | SURF_GLOSS;
}
/**
* Automatically generate a specular stage with the normalspecular keyword
* This is a shader with a grayscale gloss map .
*/
void normalSpecularStage(shader_t *shader, char *name, char *name2) {
stage_t *stage, *stage2;
char buff[MAX_QPATH*2+1];
if (shader->numglossstages >= SHADER_MAX_BUMP_STAGES)
return;
if (shader->numbumpstages >= SHADER_MAX_BUMP_STAGES)
return;
stage = &shader->bumpstages[shader->numbumpstages];
shader->numbumpstages++;
clearStage(stage);
stage->type = STAGE_BUMP;
strncpy(stage->filename,name,MAX_QPATH);
shader->flags = shader->flags | SURF_BUMP;
stage2 = &shader->glossstages[shader->numglossstages];
shader->numglossstages++;
clearStage(stage2);
stage2->type = STAGE_GRAYGLOSS;
strncpy(stage2->filename,name2,MAX_QPATH);
shader->flags = shader->flags | SURF_GLOSS;
sprintf(buff,"%s|%s",stage->filename, stage2->filename);
strcpy(stage->filename, buff);
strcpy(stage2->filename, buff);
}
/**
* Automatically generate a bump stage with the colormap keyword
*/
void diffuseStage(shader_t *shader, char *name) {
stage_t *stage;
if (shader->numcolorstages >= SHADER_MAX_BUMP_STAGES)
return;
stage = &shader->colorstages[shader->numcolorstages];
shader->numcolorstages++;
clearStage(stage);
stage->type = STAGE_COLOR;
strncpy(stage->filename,name,MAX_QPATH);
shader->flags = shader->flags | SURF_PPLIGHT;
}
/**
* Parse a single shader out of the shader file
*/
char *ParseShader (char *data, shader_t *shader)
{
char command[256];
while (1)
{
data = COM_Parse (data);
//end of shader
if (com_token[0] == '}')
break;
//ugh nasty
if (!data) {
Con_Printf("ParseStage: EOF without '}'");
ShaderError();
return NULL;
}
//see what command it is
strncpy (command, com_token,sizeof(command));
if (command[0] == '{') {
data = ParseStage(data, shader);
} else if (!strcmp(command,"normalmap")) {
GET_SAFE_TOKEN;
data = normalStage(data, shader, com_token);
} else if (!strcmp(command,"diffusemap")) {
GET_SAFE_TOKEN;
diffuseStage(shader,com_token);
} else if (!strcmp(command,"specularmap")) {
GET_SAFE_TOKEN;
specularStage(shader,com_token);
} else if (!strcmp(command,"normalspecular")) {
GET_SAFE_TOKEN;
strcpy(command,com_token);
GET_SAFE_TOKEN;
normalSpecularStage(shader,command, com_token);
} else if (!strcmp(command,"surfaceparm")) {
GET_SAFE_TOKEN;
if (!strcmp(com_token, "nodraw")) {
shader->flags |= SURF_NODRAW;
}
} else if (!strcmp(command,"nomipmaps")) {
shader->mipmap = false;
} else if (!strcmp(command,"noshadow")) {
shader->flags |= SURF_NOSHADOW;
} else if (!strcmp(command,"cull")) {
GET_SAFE_TOKEN;
if (!strcmp(com_token,"disable")) {
shader->cull = false;
} else
shader->cull = true;
} else {
//ignore q3map and radiant commands
if (strncmp("qer_",com_token,4) && strncmp(com_token,"q3map_",5)) {
Con_Printf("Unknown statement %s\n",command);
ShaderError();
}
data = COM_SkipLine(data);
}
}
return data;
}
void LoadShadersFromString (char *data,const char *filename)
{
shader_t shader, *s;
// parse shaders
while (1)
{
data = COM_Parse (data);
if (!data)
break;
//No errors yet.
shader_haserrors = false;
//check if shader already exists
s = shaderList;
while(s) {
if (!strcmp(com_token,s->name)) {
if (!shaders_reloading) {
Con_Printf("Shader error:\nShader '%s' was defined a second time in '%s'\n",com_token, filename);
Con_Printf("This may cause texture errors\n");
ShaderError();
}
break;
}
s = s->next;
}
//If we are reloading make sure pointer says the same
if (!s) {
s = malloc(sizeof(shader_t));
if (!s) Sys_Error("Not enough mem");
memset(s,0,sizeof(shader_t));
s->next = shaderList;
shaderList = s;
strncpy(s->name,com_token,sizeof(s->name));
} else {
shader_t *oldNext = s->next;
qboolean t = s->texturesAreLoaded;
memset(s,0,sizeof(shader_t));
s->next = oldNext;
s->texturesAreLoaded = t;
strncpy(s->name,com_token,sizeof(s->name));
}
s->mipmap = true;
s->cull = true;
//parse it from the file
data = COM_Parse (data);
if (!data)
break;
if (com_token[0] != '{') {
Con_Printf("ED_LoadFromFile: found %s when expecting {",com_token);
ShaderError();
}
Con_DPrintf("Parsing %s...\n",s->name);
data = ParseShader (data, s);
if (shader_haserrors) {
initErrorShader(s);
}
}
}
void AddShaderFile(const char *filename) {
char *buffer = COM_LoadTempFile (filename);
Con_Printf("Parsing shaderscript: %s\n",filename);
if (!buffer) return;
LoadShadersFromString(buffer, filename);
}
/**
* This should be called once during engine startup.
*
*/
void R_InitShaders() {
//clear list
shaderList = NULL;
//load all scripts
Con_Printf("=================================\n");
Con_Printf("Shader_Init: Initializing shaders\n");
COM_FindAllExt("scripts","shader",AddShaderFile);
Con_Printf("=================================\n");
}
/**
* This should be called once during engine startup.
*
*/
void R_ReloadShaders_f( void ) {
shader_t *s = shaderList;
shaders_reloading = true;
scr_disabled_for_loading = true;
//load all scripts
Con_Printf("=================================\n");
Con_Printf("Reloading shaders\n");
COM_FindAllExt("scripts","shader",AddShaderFile);
//If the shader's textures were loaded previously reload them now as draw code relies on
//them being loded.
while (s) {
if (s->texturesAreLoaded) {
GL_ShaderLoadTextures(s);
}
s = s->next;
}
Con_Printf("=================================\n");
scr_disabled_for_loading = false;
shaders_reloading = false;
}
#if !defined(_WIN32) && !defined(SDL) && !defined(__glx__)
//warn non win32 devs they should free the memory...
#error Call this routine from vid shutdown!
#endif
void R_ShutdownShaders() {
shader_t *s;
while (shaderList) {
s = shaderList;
shaderList = shaderList->next;
free(s);
}
//free video textures and such
GL_ShutdownTextures();
}
Reference in a new issue View git blame Copy permalink