---

r_shader.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  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 The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:04 $
// By           :       $Author: kolrabi $
// $Id: r_shader.cpp,v 1.1.1.1 2002/12/07 19:02:04 kolrabi Exp $ 

/*

  $Log: r_shader.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:04  kolrabi
  initial release


*/

#include            <string>
 
#include            "omicron/internal.h" 
#include            "omicron/render.h" 
#include            "omicron/texture.h"
#include            "omicron/file.h" 
#include            "omicron/list.h"
// #include            "omicron/string.h"
 
static ushort      waveform_from_string 
( 
    const char        *t 
) 
{
    AssertReturnValue1(t, 0);

    if (!strcmpi(t, "sine")) 
        return WF_SINE; 
 
    if (!strcmpi(t, "rect")) 
        return WF_RECT; 
 
    if (!strcmpi(t, "sine2d")) 
        return WF_SINE2D; 
 
    if (!strcmpi(t, "rect2d")) 
        return WF_RECT2D; 

    if (!strcmpi(t, "none")) 
        return WF_NONE; 

    _log_printf(MSG_ERROR,  "ERROR: invalid token \"%s\"", t); 

    return WF_NONE; 
} 
 
static ushort     texfilter_from_string 
( 
    const char        *t 
) 
{ 
    if (!strcmpi(t, "linear")) 
        return TF_LINEAR; 
 
    if (!strcmpi(t, "nearest_mipmap_nearest")) 
        return TF_NEAREST_MIPMAP_NEAREST; 
 
    if (!strcmpi(t, "nearest_mipmap_linear")) 
        return TF_NEAREST_MIPMAP_LINEAR; 
 
    if (!strcmpi(t, "linear_mipmap_nearest")) 
        return TF_LINEAR_MIPMAP_NEAREST; 
 
    if (!strcmpi(t, "linear_mipmap_linear")) 
        return TF_LINEAR_MIPMAP_LINEAR; 
 
    return TF_NEAREST; 
} 
 
static ushort      texwrap_from_string 
( 
    const char        *t 
) 
{ 
    AssertReturnValue1(t, 0);

    if (!strcmpi(t, "clamp")) 
        return TW_CLAMP; 
 
    return TW_REPEAT; 
} 
 
static ushort     texbtype_from_string 
( 
    const char        *t 
) 
{ 
    AssertReturnValue1(t, 0);

    // opaque add blend modulate 
    if (!strcmpi(t, "add")) 
        return BT_ADD; 
    if (!strcmpi(t, "blend")) 
        return BT_BLEND; 
    if (!strcmpi(t, "modulate")) 
        return BT_MODULATE; 
    if (!strcmpi(t, "alphatest")) 
        return BT_ALPHATEST; 
    if (!strcmpi(t, "modulate2x")) 
        return BT_MODULATE2X; 
 
    return BT_OPAQUE; 
} 
 
/****************************************************************************
 * shader_initstage                                     init a shader stage *
 ****************************************************************************/
void            shader_initstage 
( 
    shader_t    *shad, 
    ushort      n 
) 
{ 
    AssertReturn1(shad);

    shad->passes[n].scalex          = 1; 
    shad->passes[n].scaley          = 1; 
    shad->passes[n].soffsetx        = 
    shad->passes[n].soffsety        =  
    shad->passes[n].offsetx         = 
    shad->passes[n].offsety         = 0; 
    shad->passes[n].magfilter       = TF_LINEAR_MIPMAP_LINEAR; 
    shad->passes[n].minfilter       = TF_LINEAR_MIPMAP_LINEAR; 
    shad->passes[n].texwrapu        =  
    shad->passes[n].texwrapv        = TW_REPEAT; 
 
    shad->passes[n].rotation        = 
    shad->passes[n].angle           =
    shad->passes[n].scrollx         = 
    shad->passes[n].scrolly         = 0.0f;
    shad->passes[n].shiny           = 0; 

    shad->passes[n].matrix          = false;
    shad->passes[n].fog             = true;
 
    shad->passes[n].colorwave.type  = 0; 
    shad->passes[n].colorwave.bias  = 1; 
 
    shad->passes[n].color1          = 
    shad->passes[n].color2          = COLOR_WHITE;

    shad->passes[n].color           = false;

    shad->passes[n].scalewavex.type  = 0; 
    shad->passes[n].scalewavex.bias  = 1; 
    shad->passes[n].scalewavey.type  = 0; 
    shad->passes[n].scalewavey.bias  = 1; 

    shad->passes[n].lightmap = 0;
    shad->passes[n].lighting = 0;
    shad->passes[n].blendtype    = BT_OPAQUE;
    shad->passes[n].twosided = 0;
    shad->passes[n].nodepth  = 0;
    shad->passes[n].ignorediffuse = false;
} 

/****************************************************************************
 * shader_get_waveform_frac                           get waveform fraction *
 ****************************************************************************/
float           shader_get_waveform_frac 
( 
    const shader_waveform_t  *wf
) 
{ 
    AssertReturnValue1(wf, 0);

    if (wf->type == WF_NONE) 
      return 0; 
 
    if (wf->freq == 0) 
      return wf->bias; 
 
    float invfreq = 1/wf->freq; 
    float t = gv.time + wf->phase; 
 
    switch(wf->type) 
    { 
        case WF_RECT: 
            if (fmod(t, invfreq) < invfreq/2) 
                return wf->bias-wf->amplitude; 
            else 
                return wf->bias+wf->amplitude; 
            
        case WF_SINE: 
            return (float)(wf->amplitude*sin(t*PI2*wf->freq)+wf->bias); 
 
/*        case WF_TRIANGLE:*/ 
/*        case WF_SAWTOOTH:*/ 
/*        case WF_INVSAWTOOTH:*/ 
    } 
 
    return 0; 
} 


/**************************************************************************** 
 * _r_simple_shader                                 creates a simple shader * 
 ****************************************************************************/ 
shader_t       *shader_create_simple 
( 
    ushort      blendtype, 
    sshort      texture 
) 
{ 
    shader_t *shad = new shader_t; 
 
    shader_init(shad, blendtype, texture); 
    gv.shaders->add_first(shad); 
 
    return shad; 
} 
 
 
/****************************************************************************
 * shader_init                                                init a shader *
 ****************************************************************************/
void            shader_init 
( 
    shader_t   *shad, 
    ushort      blendtype, 
    sshort      texture 
) 
{ 
    AssertReturn1(shad);

    memset(shad, 0, sizeof(shader_t)); 
    shad->passcount = 1; 
 
    shader_initstage(shad, 0); 
    shad->dynamic                   = 0;
    shad->passes[0].blendtype       = blendtype; 
    shad->passes[0].texture         = texture; 
    sprintf(shad->name, "unnamed");
} 
 
/****************************************************************************
 * shader_create                                       creates a new shader *
 ****************************************************************************/
shader_t       *shader_create 
( 
) 
{ 
    shader_t *shad = new shader_t; 
    gv.shaders->add_first(shad); 
    return shad; 
} 

/****************************************************************************
 * shader_find                                                find a shader * 
 ****************************************************************************/
shader_t       *shader_find
(
    const char      *name
)
{
    AssertReturnValue1(name, NULL);

    shader_t   *shad = (shader_t*)gv.shaders->get_first();

    while(shad)
    {
        if (!strcmpi(name, shad->name))
            return shad;

        shad = (shader_t*)gv.shaders->get_next();
    }

    return NULL;
}
 
 
/****************************************************************************
 * shader_load                                      load a shader from file *
 ****************************************************************************/
shader_t       *shader_load 
( 
    const char      *fname 
) 
{ 
    AssertReturnValue1(fname, NULL);

    shader_t    *shad = NULL; 
    file_t      *f; 
    std::string fname2;

    shad = shader_find(fname);

    if (shad)
        return shad;

    fname2 = fname;
    fname2 += ".shader";
 
    f = gv.fileman->load(fname2.c_str(), false); 
 
    if (!f) 
    {
        sshort t = gv.texman->load(fname);

        if (t != TEXTURE_NOTFOUND)
        {
            shad = shader_create_simple(BT_OPAQUE, t);
            sprintf(shad->name, "%s", fname);
        }
        else
        {
            shad = shader_find("noshader");
        }
        return shad;
    }
 
    ushort      currentpass         = 0; 
    char        tmp[256]            = ""; 
    ulong       linenum             = 0; 

    std::string      cmd                 = "";
    std::string      params              = "";
    std::string      line                = "";

    slong       comment             = 0;
 
    shad = shader_create(); 
 
    if (!shad)
    {
        gv.fileman->close(f);
        return NULL; 
    }
 
    sprintf(shad->name, "%s", fname);
    shad->passcount = 0; 
    shad->dynamic = 0;
 
    while(!gv.fileman->eof(f)) 
    { 
      int i;

        linenum++; 
        gv.fileman->gets(tmp, 256, f); 

        line = tmp;
        
        comment = line.find('#');
        if (comment != -1)
            line[comment] = 0;

        for (i=line.length(); i>=0; --i)
          if (strchr(" \n\r\t", line.at(i)))
            line.erase(i);
        // line.trim(" \n\r\t");

        if (!line.length()) 
            continue; 

        if (line.find_first_of(" \n\t")==line.length())
        {
            cmd     = line;
            params  = "";
        }
        else
        {
            slong p = line.find_first_of(" \n\t");
            cmd     = line.substr(0, p);
            params  = line.substr(p+1, line.length()-p-1);
        }

        // newstage 
        if (!cmd.compare("newpass")) 
        { 
            if (currentpass>=7) 
            { 
                _log_printf(MSG_ERROR,  "ERROR: while parsing shader \"%s\" line %u: " 
                                        "all passes already used. newstage invalid", 
                                        fname, linenum); 
                break; 
            } 

            shader_initstage(shad, currentpass=++(shad->passcount)-1); 
            //                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            // this is a very beautiful piece of code :)
            continue; 
        } 

        // blendtype 
        if (!cmd.compare("blendtype")) 
        { 
            shad->passes[currentpass].blendtype = texbtype_from_string(params.c_str()); 
            continue; 
        } 
        // texture 
        if (!cmd.compare("texture")) 
        { 
            shad->passes[currentpass].texture = gv.texman->load(params.c_str());
            continue; 
        } 

        // texture 
        if (!cmd.compare("texturenocomp")) 
        { 
            shad->passes[currentpass].texture = gv.texman->load(params.c_str(), true);
            continue; 
        } 
        
        // texture 
        if (!cmd.compare("twosided")) 
        { 
            shad->passes[currentpass].twosided = 1;
            continue; 
        } 
        // nodepth
        if (!cmd.compare("nodepth")) 
        { 
            shad->passes[currentpass].nodepth = 1;
            continue; 
        } 

        // lightmap
        if (!cmd.compare("lightmapped")) 
        { 
            shad->passes[currentpass].lightmap = !!atoi(params.c_str());
            continue; 
        } 

        // lightmap
        if (!cmd.compare("fog")) 
        { 
            shad->passes[currentpass].fog = !!atoi(params.c_str());
            continue; 
        } 

        // lightmap
        if (!cmd.compare("ignorediffuse")) 
        { 
            shad->passes[currentpass].ignorediffuse = !!atoi(params.c_str());
            continue; 
        } 

        // shiny 
        if (!cmd.compare("shiny")) 
        { 
            shad->passes[currentpass].shiny = !!atoi(params.c_str()); 
            continue; 
        } 

        // lighting
        if (!cmd.compare("lighting")) 
        { 
            shad->passes[currentpass].lighting = !!atoi(params.c_str()); 
            continue; 
        } 

 
        // rotation 
        if (!cmd.compare("rotation")) 
        { 
            shad->passes[currentpass].rotation = (float)atof(params.c_str()); 
            shad->dynamic = 1;
            shad->passes[currentpass].matrix = true;
            continue; 
        } 

        // rotation 
        if (!cmd.compare("angle")) 
        { 
            shad->passes[currentpass].angle = (float)atof(params.c_str()); 
            shad->passes[currentpass].matrix = true;
            continue; 
        } 
        
        // scale 
        if (!cmd.compare("scale")) 
        { 
            sscanf(params.c_str(), "%f %f",  
                &shad->passes[currentpass].scalex, 
                &shad->passes[currentpass].scaley ); 
            
            shad->passes[currentpass].matrix = true;
            continue; 
        } 
 
        // scroll 
        if (!cmd.compare("scroll")) 
        { 
            sscanf(params.c_str(), "%f %f",  
                &shad->passes[currentpass].scrollx, 
                &shad->passes[currentpass].scrolly ); 
            shad->dynamic = 1;
            shad->passes[currentpass].matrix = true;
            continue; 
        } 
 
        // offset 
        if (!cmd.compare("offset")) 
        { 
            sscanf(params.c_str(), "%f %f",  
                &shad->passes[currentpass].offsetx, 
                &shad->passes[currentpass].offsety ); 
            shad->dynamic = 1;
            shad->passes[currentpass].matrix = true;
            continue; 
        } 
 
        // scaleoffset 
        if (!cmd.compare("scaleoffset")) 
        { 
            sscanf(params.c_str(), "%f %f",  
                &shad->passes[currentpass].soffsetx, 
                &shad->passes[currentpass].soffsety ); 
            shad->dynamic = 1;
            shad->passes[currentpass].matrix = true;
            continue; 
        } 
 
        // filter 
        if (!cmd.compare("filter")) 
        { 
            char filter1[256]; 
            char filter2[256]; 
 
            sscanf(params.c_str(), "%s %s", filter1, filter2 ); 
 
            shad->passes[currentpass].minfilter = texfilter_from_string(filter1); 
            shad->passes[currentpass].magfilter = texfilter_from_string(filter2); 
            continue; 
        } 
 
        // wrap 
        if (!cmd.compare("wrap")) 
        { 
            char wrap1[256]; 
            char wrap2[256]; 
 
            sscanf(params.c_str(), "%s %s", wrap1, wrap2 ); 
 
            shad->passes[currentpass].texwrapu = texwrap_from_string(wrap1); 
            shad->passes[currentpass].texwrapv = texwrap_from_string(wrap2); 
            continue; 
        } 
 
        // color1 
        if (!cmd.compare("color1")) 
        { 
            vec4_t c; 
 
            sscanf(params.c_str(), "%f %f %f %f", &c[0], &c[1], &c[2], &c[3]); 
            shad->passes[currentpass].color1 = color_from_vec(c); 
            shad->passes[currentpass].color = true;
            continue; 
        } 
 
        // color2 
        if (!cmd.compare("color2")) 
        { 
            vec4_t c; 
 
            sscanf(params.c_str(), "%f %f %f %f", &c[0], &c[1], &c[2], &c[3]); 
            shad->passes[currentpass].color2 = color_from_vec(c); 
            continue; 
        } 
 
        // colorwave 
        if (!cmd.compare("colorwave")) 
        { 
            char    form[256]; 
 
            sscanf(params.c_str(), "%s %f %f %f %f", form,  
                &shad->passes[currentpass].colorwave.freq, 
                &shad->passes[currentpass].colorwave.phase, 
                &shad->passes[currentpass].colorwave.amplitude, 
                &shad->passes[currentpass].colorwave.bias ); 
 
            shad->passes[currentpass].colorwave.type = waveform_from_string(form); 
            shad->dynamic = 1;
            shad->passes[currentpass].color = true;
            continue; 
        } 
 
        // scalewavex 
        if (!cmd.compare("scalewavex")) 
        { 
            char    form[256]; 
 
            sscanf(params.c_str(), "%s %f %f %f %f", form,  
                &shad->passes[currentpass].scalewavex.freq, 
                &shad->passes[currentpass].scalewavex.phase, 
                &shad->passes[currentpass].scalewavex.amplitude, 
                &shad->passes[currentpass].scalewavex.bias ); 
 
            shad->passes[currentpass].scalewavex.type = waveform_from_string(form); 
            shad->dynamic = 1;
            shad->passes[currentpass].matrix = true;
            continue; 
        } 
 
        // scalewavey
        if (!cmd.compare("scalewavey")) 
        { 
            char    form[256]; 
 
            sscanf(params.c_str(), "%s %f %f %f %f", form,  
                &shad->passes[currentpass].scalewavey.freq, 
                &shad->passes[currentpass].scalewavey.phase, 
                &shad->passes[currentpass].scalewavey.amplitude, 
                &shad->passes[currentpass].scalewavey.bias ); 
 
            shad->passes[currentpass].scalewavey.type = waveform_from_string(form); 
            shad->dynamic = 1;
            shad->passes[currentpass].matrix = true;
            continue; 
        } 

        _log_printf(MSG_ERROR,  "ERROR: while parsing shader \"%s\" line %u: " 
                                        "invalid keyword \"%s\"", 
                                        (char*)fname, linenum, cmd.c_str()); 
 
    } 
    
    gv.fileman->close(f);

    return shad; 
} 

---