tr_shader.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code 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.

Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
#include "tr_local.h"

// tr_shader.c -- this file deals with the parsing and definition of shaders

static char *s_shaderText;

// the shader is parsed into these global variables, then copied into
// dynamically allocated memory if it is valid.
static  shaderStage_t   stages[MAX_SHADER_STAGES];      
static  shader_t        shader;
static  texModInfo_t    texMods[MAX_SHADER_STAGES][TR_MAX_TEXMODS];
static  qboolean        deferLoad;

#define FILE_HASH_SIZE      1024
static  shader_t*       hashTable[FILE_HASH_SIZE];

#define MAX_SHADERTEXT_HASH     2048
static char **shaderTextHashTable[MAX_SHADERTEXT_HASH];

/*
================
return a hash value for the filename
================
*/
static long generateHashValue( const char *fname, const int size ) {
    int     i;
    long    hash;
    char    letter;

    hash = 0;
    i = 0;
    while (fname[i] != '\0') {
        letter = tolower(fname[i]);
        if (letter =='.') break;                // don't include extension
        if (letter =='\\') letter = '/';        // damn path names
        if (letter == PATH_SEP) letter = '/';       // damn path names
        hash+=(long)(letter)*(i+119);
        i++;
    }
    hash = (hash ^ (hash >> 10) ^ (hash >> 20));
    hash &= (size-1);
    return hash;
}

void R_RemapShader(const char *shaderName, const char *newShaderName, const char *timeOffset) {
    char        strippedName[MAX_QPATH];
    int         hash;
    shader_t    *sh, *sh2;
    qhandle_t   h;

    sh = R_FindShaderByName( shaderName );
    if (sh == NULL || sh == tr.defaultShader) {
        h = RE_RegisterShaderLightMap(shaderName, 0);
        sh = R_GetShaderByHandle(h);
    }
    if (sh == NULL || sh == tr.defaultShader) {
        ri.Printf( PRINT_WARNING, "WARNING: R_RemapShader: shader %s not found\n", shaderName );
        return;
    }

    sh2 = R_FindShaderByName( newShaderName );
    if (sh2 == NULL || sh2 == tr.defaultShader) {
        h = RE_RegisterShaderLightMap(newShaderName, 0);
        sh2 = R_GetShaderByHandle(h);
    }

    if (sh2 == NULL || sh2 == tr.defaultShader) {
        ri.Printf( PRINT_WARNING, "WARNING: R_RemapShader: new shader %s not found\n", newShaderName );
        return;
    }

    // remap all the shaders with the given name
    // even tho they might have different lightmaps
    COM_StripExtension( shaderName, strippedName );
    hash = generateHashValue(strippedName, FILE_HASH_SIZE);
    for (sh = hashTable[hash]; sh; sh = sh->next) {
        if (Q_stricmp(sh->name, strippedName) == 0) {
            if (sh != sh2) {
                sh->remappedShader = sh2;
            } else {
                sh->remappedShader = NULL;
            }
        }
    }
    if (timeOffset) {
        sh2->timeOffset = atof(timeOffset);
    }
}

/*
===============
ParseVector
===============
*/
static qboolean ParseVector( char **text, int count, float *v ) {
    char    *token;
    int     i;

    // FIXME: spaces are currently required after parens, should change parseext...
    token = COM_ParseExt( text, qfalse );
    if ( strcmp( token, "(" ) ) {
        ri.Printf( PRINT_WARNING, "WARNING: missing parenthesis in shader '%s'\n", shader.name );
        return qfalse;
    }

    for ( i = 0 ; i < count ; i++ ) {
        token = COM_ParseExt( text, qfalse );
        if ( !token[0] ) {
            ri.Printf( PRINT_WARNING, "WARNING: missing vector element in shader '%s'\n", shader.name );
            return qfalse;
        }
        v[i] = atof( token );
    }

    token = COM_ParseExt( text, qfalse );
    if ( strcmp( token, ")" ) ) {
        ri.Printf( PRINT_WARNING, "WARNING: missing parenthesis in shader '%s'\n", shader.name );
        return qfalse;
    }

    return qtrue;
}


/*
===============
NameToAFunc
===============
*/
static unsigned NameToAFunc( const char *funcname )
{   
    if ( !Q_stricmp( funcname, "GT0" ) )
    {
        return GLS_ATEST_GT_0;
    }
    else if ( !Q_stricmp( funcname, "LT128" ) )
    {
        return GLS_ATEST_LT_80;
    }
    else if ( !Q_stricmp( funcname, "GE128" ) )
    {
        return GLS_ATEST_GE_80;
    }

    ri.Printf( PRINT_WARNING, "WARNING: invalid alphaFunc name '%s' in shader '%s'\n", funcname, shader.name );
    return 0;
}


/*
===============
NameToSrcBlendMode
===============
*/
static int NameToSrcBlendMode( const char *name )
{
    if ( !Q_stricmp( name, "GL_ONE" ) )
    {
        return GLS_SRCBLEND_ONE;
    }
    else if ( !Q_stricmp( name, "GL_ZERO" ) )
    {
        return GLS_SRCBLEND_ZERO;
    }
    else if ( !Q_stricmp( name, "GL_DST_COLOR" ) )
    {
        return GLS_SRCBLEND_DST_COLOR;
    }
    else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_COLOR" ) )
    {
        return GLS_SRCBLEND_ONE_MINUS_DST_COLOR;
    }
    else if ( !Q_stricmp( name, "GL_SRC_ALPHA" ) )
    {
        return GLS_SRCBLEND_SRC_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_ALPHA" ) )
    {
        return GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_DST_ALPHA" ) )
    {
        return GLS_SRCBLEND_DST_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_ALPHA" ) )
    {
        return GLS_SRCBLEND_ONE_MINUS_DST_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_SRC_ALPHA_SATURATE" ) )
    {
        return GLS_SRCBLEND_ALPHA_SATURATE;
    }

    ri.Printf( PRINT_WARNING, "WARNING: unknown blend mode '%s' in shader '%s', substituting GL_ONE\n", name, shader.name );
    return GLS_SRCBLEND_ONE;
}

/*
===============
NameToDstBlendMode
===============
*/
static int NameToDstBlendMode( const char *name )
{
    if ( !Q_stricmp( name, "GL_ONE" ) )
    {
        return GLS_DSTBLEND_ONE;
    }
    else if ( !Q_stricmp( name, "GL_ZERO" ) )
    {
        return GLS_DSTBLEND_ZERO;
    }
    else if ( !Q_stricmp( name, "GL_SRC_ALPHA" ) )
    {
        return GLS_DSTBLEND_SRC_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_ALPHA" ) )
    {
        return GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_DST_ALPHA" ) )
    {
        return GLS_DSTBLEND_DST_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_ALPHA" ) )
    {
        return GLS_DSTBLEND_ONE_MINUS_DST_ALPHA;
    }
    else if ( !Q_stricmp( name, "GL_SRC_COLOR" ) )
    {
        return GLS_DSTBLEND_SRC_COLOR;
    }
    else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_COLOR" ) )
    {
        return GLS_DSTBLEND_ONE_MINUS_SRC_COLOR;
    }

    ri.Printf( PRINT_WARNING, "WARNING: unknown blend mode '%s' in shader '%s', substituting GL_ONE\n", name, shader.name );
    return GLS_DSTBLEND_ONE;
}

/*
===============
NameToGenFunc
===============
*/
static genFunc_t NameToGenFunc( const char *funcname )
{
    if ( !Q_stricmp( funcname, "sin" ) )
    {
        return GF_SIN;
    }
    else if ( !Q_stricmp( funcname, "square" ) )
    {
        return GF_SQUARE;
    }
    else if ( !Q_stricmp( funcname, "triangle" ) )
    {
        return GF_TRIANGLE;
    }
    else if ( !Q_stricmp( funcname, "sawtooth" ) )
    {
        return GF_SAWTOOTH;
    }
    else if ( !Q_stricmp( funcname, "inversesawtooth" ) )
    {
        return GF_INVERSE_SAWTOOTH;
    }
    else if ( !Q_stricmp( funcname, "noise" ) )
    {
        return GF_NOISE;
    }

    ri.Printf( PRINT_WARNING, "WARNING: invalid genfunc name '%s' in shader '%s'\n", funcname, shader.name );
    return GF_SIN;
}


/*
===================
ParseWaveForm
===================
*/
static void ParseWaveForm( char **text, waveForm_t *wave )
{
    char *token;

    token = COM_ParseExt( text, qfalse );
    if ( token[0] == 0 )
    {
        ri.Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
        return;
    }
    wave->func = NameToGenFunc( token );

    // BASE, AMP, PHASE, FREQ
    token = COM_ParseExt( text, qfalse );
    if ( token[0] == 0 )
    {
        ri.Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
        return;
    }
    wave->base = atof( token );

    token = COM_ParseExt( text, qfalse );
    if ( token[0] == 0 )
    {
        ri.Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
        return;
    }
    wave->amplitude = atof( token );

    token = COM_ParseExt( text, qfalse );
    if ( token[0] == 0 )
    {
        ri.Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
        return;
    }
    wave->phase = atof( token );

    token = COM_ParseExt( text, qfalse );
    if ( token[0] == 0 )
    {
        ri.Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
        return;
    }
    wave->frequency = atof( token );
}


/*
===================
ParseTexMod
===================
*/
static void ParseTexMod( char *_text, shaderStage_t *stage )
{
    const char *token;
    char **text = &_text;
    texModInfo_t *tmi;

    if ( stage->bundle[0].numTexMods == TR_MAX_TEXMODS ) {
        ri.Error( ERR_DROP, "ERROR: too many tcMod stages in shader '%s'\n", shader.name );
        return;
    }

    tmi = &stage->bundle[0].texMods[stage->bundle[0].numTexMods];
    stage->bundle[0].numTexMods++;

    token = COM_ParseExt( text, qfalse );

    //
    // turb
    //
    if ( !Q_stricmp( token, "turb" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing tcMod turb parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.base = atof( token );
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.amplitude = atof( token );
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.phase = atof( token );
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.frequency = atof( token );

        tmi->type = TMOD_TURBULENT;
    }
    //
    // scale
    //
    else if ( !Q_stricmp( token, "scale" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing scale parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->scale[0] = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing scale parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->scale[1] = atof( token );
        tmi->type = TMOD_SCALE;
    }
    //
    // scroll
    //
    else if ( !Q_stricmp( token, "scroll" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing scale scroll parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->scroll[0] = atof( token );
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing scale scroll parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->scroll[1] = atof( token );
        tmi->type = TMOD_SCROLL;
    }
    //
    // stretch
    //
    else if ( !Q_stricmp( token, "stretch" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.func = NameToGenFunc( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.base = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.amplitude = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.phase = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->wave.frequency = atof( token );
        
        tmi->type = TMOD_STRETCH;
    }
    //
    // transform
    //
    else if ( !Q_stricmp( token, "transform" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->matrix[0][0] = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->matrix[0][1] = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->matrix[1][0] = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->matrix[1][1] = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->translate[0] = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->translate[1] = atof( token );

        tmi->type = TMOD_TRANSFORM;
    }
    //
    // rotate
    //
    else if ( !Q_stricmp( token, "rotate" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing tcMod rotate parms in shader '%s'\n", shader.name );
            return;
        }
        tmi->rotateSpeed = atof( token );
        tmi->type = TMOD_ROTATE;
    }
    //
    // entityTranslate
    //
    else if ( !Q_stricmp( token, "entityTranslate" ) )
    {
        tmi->type = TMOD_ENTITY_TRANSLATE;
    }
    else
    {
        ri.Printf( PRINT_WARNING, "WARNING: unknown tcMod '%s' in shader '%s'\n", token, shader.name );
    }
}


/*
===================
ParseStage
===================
*/
static qboolean ParseStage( shaderStage_t *stage, char **text )
{
    char *token;
    int depthMaskBits = GLS_DEPTHMASK_TRUE, blendSrcBits = 0, blendDstBits = 0, atestBits = 0, depthFuncBits = 0;
    qboolean depthMaskExplicit = qfalse;

    stage->active = qtrue;

    while ( 1 )
    {
        token = COM_ParseExt( text, qtrue );
        if ( !token[0] )
        {
            ri.Printf( PRINT_WARNING, "WARNING: no matching '}' found\n" );
            return qfalse;
        }

        if ( token[0] == '}' )
        {
            break;
        }
        //
        // map <name>
        //
        else if ( !Q_stricmp( token, "map" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( !token[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameter for 'map' keyword in shader '%s'\n", shader.name );
                return qfalse;
            }

            if ( !Q_stricmp( token, "$whiteimage" ) )
            {
                stage->bundle[0].image[0] = tr.whiteImage;
                continue;
            }
            else if ( !Q_stricmp( token, "$lightmap" ) )
            {
                stage->bundle[0].isLightmap = qtrue;
                if ( shader.lightmapIndex < 0 ) {
                    stage->bundle[0].image[0] = tr.whiteImage;
                } else {
                    stage->bundle[0].image[0] = tr.lightmaps[shader.lightmapIndex];
                }
                continue;
            }
            else
            {
                stage->bundle[0].image[0] = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, GL_REPEAT );
                if ( !stage->bundle[0].image[0] )
                {
                    ri.Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
                    return qfalse;
                }
            }
        }
        //
        // clampmap <name>
        //
        else if ( !Q_stricmp( token, "clampmap" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( !token[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameter for 'clampmap' keyword in shader '%s'\n", shader.name );
                return qfalse;
            }

            stage->bundle[0].image[0] = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, GL_CLAMP );
            if ( !stage->bundle[0].image[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
                return qfalse;
            }
        }
        //
        // animMap <frequency> <image1> .... <imageN>
        //
        else if ( !Q_stricmp( token, "animMap" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( !token[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameter for 'animMmap' keyword in shader '%s'\n", shader.name );
                return qfalse;
            }
            stage->bundle[0].imageAnimationSpeed = atof( token );

            // parse up to MAX_IMAGE_ANIMATIONS animations
            while ( 1 ) {
                int     num;

                token = COM_ParseExt( text, qfalse );
                if ( !token[0] ) {
                    break;
                }
                num = stage->bundle[0].numImageAnimations;
                if ( num < MAX_IMAGE_ANIMATIONS ) {
                    stage->bundle[0].image[num] = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, GL_REPEAT );
                    if ( !stage->bundle[0].image[num] )
                    {
                        ri.Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
                        return qfalse;
                    }
                    stage->bundle[0].numImageAnimations++;
                }
            }
        }
        else if ( !Q_stricmp( token, "videoMap" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( !token[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameter for 'videoMmap' keyword in shader '%s'\n", shader.name );
                return qfalse;
            }
            stage->bundle[0].videoMapHandle = ri.CIN_PlayCinematic( token, 0, 0, 256, 256, (CIN_loop | CIN_silent | CIN_shader));
            if (stage->bundle[0].videoMapHandle != -1) {
                stage->bundle[0].isVideoMap = qtrue;
                stage->bundle[0].image[0] = tr.scratchImage[stage->bundle[0].videoMapHandle];
            }
        }
        //
        // alphafunc <func>
        //
        else if ( !Q_stricmp( token, "alphaFunc" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( !token[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameter for 'alphaFunc' keyword in shader '%s'\n", shader.name );
                return qfalse;
            }

            atestBits = NameToAFunc( token );
        }
        //
        // depthFunc <func>
        //
        else if ( !Q_stricmp( token, "depthfunc" ) )
        {
            token = COM_ParseExt( text, qfalse );

            if ( !token[0] )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameter for 'depthfunc' keyword in shader '%s'\n", shader.name );
                return qfalse;
            }

            if ( !Q_stricmp( token, "lequal" ) )
            {
                depthFuncBits = 0;
            }
            else if ( !Q_stricmp( token, "equal" ) )
            {
                depthFuncBits = GLS_DEPTHFUNC_EQUAL;
            }
            else
            {
                ri.Printf( PRINT_WARNING, "WARNING: unknown depthfunc '%s' in shader '%s'\n", token, shader.name );
                continue;
            }
        }
        //
        // detail
        //
        else if ( !Q_stricmp( token, "detail" ) )
        {
            stage->isDetail = qtrue;
        }
        //
        // blendfunc <srcFactor> <dstFactor>
        // or blendfunc <add|filter|blend>
        //
        else if ( !Q_stricmp( token, "blendfunc" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( token[0] == 0 )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parm for blendFunc in shader '%s'\n", shader.name );
                continue;
            }
            // check for "simple" blends first
            if ( !Q_stricmp( token, "add" ) ) {
                blendSrcBits = GLS_SRCBLEND_ONE;
                blendDstBits = GLS_DSTBLEND_ONE;
            } else if ( !Q_stricmp( token, "filter" ) ) {
                blendSrcBits = GLS_SRCBLEND_DST_COLOR;
                blendDstBits = GLS_DSTBLEND_ZERO;
            } else if ( !Q_stricmp( token, "blend" ) ) {
                blendSrcBits = GLS_SRCBLEND_SRC_ALPHA;
                blendDstBits = GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
            } else {
                // complex double blends
                blendSrcBits = NameToSrcBlendMode( token );

                token = COM_ParseExt( text, qfalse );
                if ( token[0] == 0 )
                {
                    ri.Printf( PRINT_WARNING, "WARNING: missing parm for blendFunc in shader '%s'\n", shader.name );
                    continue;
                }
                blendDstBits = NameToDstBlendMode( token );
            }

            // clear depth mask for blended surfaces
            if ( !depthMaskExplicit )
            {
                depthMaskBits = 0;
            }
        }
        //
        // rgbGen
        //
        else if ( !Q_stricmp( token, "rgbGen" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( token[0] == 0 )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameters for rgbGen in shader '%s'\n", shader.name );
                continue;
            }

            if ( !Q_stricmp( token, "wave" ) )
            {
                ParseWaveForm( text, &stage->rgbWave );
                stage->rgbGen = CGEN_WAVEFORM;
            }
            else if ( !Q_stricmp( token, "const" ) )
            {
                vec3_t  color;

                ParseVector( text, 3, color );
                stage->constantColor[0] = 255 * color[0];
                stage->constantColor[1] = 255 * color[1];
                stage->constantColor[2] = 255 * color[2];

                stage->rgbGen = CGEN_CONST;
            }
            else if ( !Q_stricmp( token, "identity" ) )
            {
                stage->rgbGen = CGEN_IDENTITY;
            }
            else if ( !Q_stricmp( token, "identityLighting" ) )
            {
                stage->rgbGen = CGEN_IDENTITY_LIGHTING;
            }
            else if ( !Q_stricmp( token, "entity" ) )
            {
                stage->rgbGen = CGEN_ENTITY;
            }
            else if ( !Q_stricmp( token, "oneMinusEntity" ) )
            {
                stage->rgbGen = CGEN_ONE_MINUS_ENTITY;
            }
            else if ( !Q_stricmp( token, "vertex" ) )
            {
                stage->rgbGen = CGEN_VERTEX;
                if ( stage->alphaGen == 0 ) {
                    stage->alphaGen = AGEN_VERTEX;
                }
            }
            else if ( !Q_stricmp( token, "exactVertex" ) )
            {
                stage->rgbGen = CGEN_EXACT_VERTEX;
            }
            else if ( !Q_stricmp( token, "lightingDiffuse" ) )
            {
                stage->rgbGen = CGEN_LIGHTING_DIFFUSE;
            }
            else if ( !Q_stricmp( token, "oneMinusVertex" ) )
            {
                stage->rgbGen = CGEN_ONE_MINUS_VERTEX;
            }
            else
            {
                ri.Printf( PRINT_WARNING, "WARNING: unknown rgbGen parameter '%s' in shader '%s'\n", token, shader.name );
                continue;
            }
        }
        //
        // alphaGen 
        //
        else if ( !Q_stricmp( token, "alphaGen" ) )
        {
            token = COM_ParseExt( text, qfalse );
            if ( token[0] == 0 )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing parameters for alphaGen in shader '%s'\n", shader.name );
                continue;
            }

            if ( !Q_stricmp( token, "wave" ) )
            {
                ParseWaveForm( text, &stage->alphaWave );
                stage->alphaGen = AGEN_WAVEFORM;
            }
            else if ( !Q_stricmp( token, "const" ) )
            {
                token = COM_ParseExt( text, qfalse );
                stage->constantColor[3] = 255 * atof( token );
                stage->alphaGen = AGEN_CONST;
            }
            else if ( !Q_stricmp( token, "identity" ) )
            {
                stage->alphaGen = AGEN_IDENTITY;
            }
            else if ( !Q_stricmp( token, "entity" ) )
            {
                stage->alphaGen = AGEN_ENTITY;
            }
            else if ( !Q_stricmp( token, "oneMinusEntity" ) )
            {
                stage->alphaGen = AGEN_ONE_MINUS_ENTITY;
            }
            else if ( !Q_stricmp( token, "vertex" ) )
            {
                stage->alphaGen = AGEN_VERTEX;
            }
            else if ( !Q_stricmp( token, "lightingSpecular" ) )
            {
                stage->alphaGen = AGEN_LIGHTING_SPECULAR;
            }
            else if ( !Q_stricmp( token, "oneMinusVertex" ) )
            {
                stage->alphaGen = AGEN_ONE_MINUS_VERTEX;
            }
            else if ( !Q_stricmp( token, "portal" ) )
            {
                stage->alphaGen = AGEN_PORTAL;
                token = COM_ParseExt( text, qfalse );
                if ( token[0] == 0 )
                {
                    shader.portalRange = 256;
                    ri.Printf( PRINT_WARNING, "WARNING: missing range parameter for alphaGen portal in shader '%s', defaulting to 256\n", shader.name );
                }
                else
                {
                    shader.portalRange = atof( token );
                }
            }
            else
            {
                ri.Printf( PRINT_WARNING, "WARNING: unknown alphaGen parameter '%s' in shader '%s'\n", token, shader.name );
                continue;
            }
        }
        //
        // tcGen <function>
        //
        else if ( !Q_stricmp(token, "texgen") || !Q_stricmp( token, "tcGen" ) ) 
        {
            token = COM_ParseExt( text, qfalse );
            if ( token[0] == 0 )
            {
                ri.Printf( PRINT_WARNING, "WARNING: missing texgen parm in shader '%s'\n", shader.name );
                continue;
            }

            if ( !Q_stricmp( token, "environment" ) )
            {
                stage->bundle[0].tcGen = TCGEN_ENVIRONMENT_MAPPED;
            }
            else if ( !Q_stricmp( token, "lightmap" ) )
            {
                stage->bundle[0].tcGen = TCGEN_LIGHTMAP;
            }
            else if ( !Q_stricmp( token, "texture" ) || !Q_stricmp( token, "base" ) )
            {
                stage->bundle[0].tcGen = TCGEN_TEXTURE;
            }
            else if ( !Q_stricmp( token, "vector" ) )
            {
                ParseVector( text, 3, stage->bundle[0].tcGenVectors[0] );
                ParseVector( text, 3, stage->bundle[0].tcGenVectors[1] );

                stage->bundle[0].tcGen = TCGEN_VECTOR;
            }
            else 
            {
                ri.Printf( PRINT_WARNING, "WARNING: unknown texgen parm in shader '%s'\n", shader.name );
            }
        }
        //
        // tcMod <type> <...>
        //
        else if ( !Q_stricmp( token, "tcMod" ) )
        {
            char buffer[1024] = "";

            while ( 1 )
            {
                token = COM_ParseExt( text, qfalse );
                if ( token[0] == 0 )
                    break;
                strcat( buffer, token );
                strcat( buffer, " " );
            }

            ParseTexMod( buffer, stage );

            continue;
        }
        //
        // depthmask
        //
        else if ( !Q_stricmp( token, "depthwrite" ) )
        {
            depthMaskBits = GLS_DEPTHMASK_TRUE;
            depthMaskExplicit = qtrue;

            continue;
        }
        else
        {
            ri.Printf( PRINT_WARNING, "WARNING: unknown parameter '%s' in shader '%s'\n", token, shader.name );
            return qfalse;
        }
    }

    //
    // if cgen isn't explicitly specified, use either identity or identitylighting
    //
    if ( stage->rgbGen == CGEN_BAD ) {
        if ( blendSrcBits == 0 ||
            blendSrcBits == GLS_SRCBLEND_ONE || 
            blendSrcBits == GLS_SRCBLEND_SRC_ALPHA ) {
            stage->rgbGen = CGEN_IDENTITY_LIGHTING;
        } else {
            stage->rgbGen = CGEN_IDENTITY;
        }
    }


    //
    // implicitly assume that a GL_ONE GL_ZERO blend mask disables blending
    //
    if ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && 
         ( blendDstBits == GLS_DSTBLEND_ZERO ) )
    {
        blendDstBits = blendSrcBits = 0;
        depthMaskBits = GLS_DEPTHMASK_TRUE;
    }

    // decide which agens we can skip
    if ( stage->alphaGen == CGEN_IDENTITY ) {
        if ( stage->rgbGen == CGEN_IDENTITY
            || stage->rgbGen == CGEN_LIGHTING_DIFFUSE ) {
            stage->alphaGen = AGEN_SKIP;
        }
    }

    //
    // compute state bits
    //
    stage->stateBits = depthMaskBits | 
                       blendSrcBits | blendDstBits | 
                       atestBits | 
                       depthFuncBits;

    return qtrue;
}

/*
===============
ParseDeform

deformVertexes wave <spread> <waveform> <base> <amplitude> <phase> <frequency>
deformVertexes normal <frequency> <amplitude>
deformVertexes move <vector> <waveform> <base> <amplitude> <phase> <frequency>
deformVertexes bulge <bulgeWidth> <bulgeHeight> <bulgeSpeed>
deformVertexes projectionShadow
deformVertexes autoSprite
deformVertexes autoSprite2
deformVertexes text[0-7]
===============
*/
static void ParseDeform( char **text ) {
    char    *token;
    deformStage_t   *ds;

    token = COM_ParseExt( text, qfalse );
    if ( token[0] == 0 )
    {
        ri.Printf( PRINT_WARNING, "WARNING: missing deform parm in shader '%s'\n", shader.name );
        return;
    }

    if ( shader.numDeforms == MAX_SHADER_DEFORMS ) {
        ri.Printf( PRINT_WARNING, "WARNING: MAX_SHADER_DEFORMS in '%s'\n", shader.name );
        return;
    }

    ds = &shader.deforms[ shader.numDeforms ];
    shader.numDeforms++;

    if ( !Q_stricmp( token, "projectionShadow" ) ) {
        ds->deformation = DEFORM_PROJECTION_SHADOW;
        return;
    }

    if ( !Q_stricmp( token, "autosprite" ) ) {
        ds->deformation = DEFORM_AUTOSPRITE;
        return;
    }

    if ( !Q_stricmp( token, "autosprite2" ) ) {
        ds->deformation = DEFORM_AUTOSPRITE2;
        return;
    }

    if ( !Q_stricmpn( token, "text", 4 ) ) {
        int     n;
        
        n = token[4] - '0';
        if ( n < 0 || n > 7 ) {
            n = 0;
        }
        ds->deformation = DEFORM_TEXT0 + n;
        return;
    }

    if ( !Q_stricmp( token, "bulge" ) ) {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
            return;
        }
        ds->bulgeWidth = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
            return;
        }
        ds->bulgeHeight = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
            return;
        }
        ds->bulgeSpeed = atof( token );

        ds->deformation = DEFORM_BULGE;
        return;
    }

    if ( !Q_stricmp( token, "wave" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
            return;
        }

        if ( atof( token ) != 0 )
        {
            ds->deformationSpread = 1.0f / atof( token );
        }
        else
        {
            ds->deformationSpread = 100.0f;
            ri.Printf( PRINT_WARNING, "WARNING: illegal div value of 0 in deformVertexes command for shader '%s'\n", shader.name );
        }

        ParseWaveForm( text, &ds->deformationWave );
        ds->deformation = DEFORM_WAVE;
        return;
    }

    if ( !Q_stricmp( token, "normal" ) )
    {
        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
            return;
        }
        ds->deformationWave.amplitude = atof( token );

        token = COM_ParseExt( text, qfalse );
        if ( token[0] == 0 )
        {
            ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
            return;
        }
        ds->deformationWave.frequency = atof( token );

        ds->deformation = DEFORM_NORMALS;
        return;
    }

    if ( !Q_stricmp( token, "move" ) ) {
        int     i;

        for ( i = 0 ; i < 3 ; i++ ) {
            token = COM_ParseExt( text, qfalse );
            if ( token[0] == 0 ) {
                ri.Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
                return;
            }
            ds->