---

r_state.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_state.cpp,v 1.1.1.1 2002/12/07 19:02:04 kolrabi Exp $ 

/*

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


*/

#include            "omicron/internal.h" 
#include            "omicron/render.h" 
#include            "omicron/texture.h"
#include            "omicron/list.h" 

static ulong _gl_texfilter[] =
{ 
    GL_NEAREST, 
    GL_LINEAR, 
    GL_NEAREST_MIPMAP_NEAREST, 
    GL_LINEAR_MIPMAP_NEAREST, 
    GL_NEAREST_MIPMAP_LINEAR, 
    GL_LINEAR_MIPMAP_LINEAR 
}; 
 
static ulong _gl_texwrap[] =  
{ 
    GL_REPEAT, 
    GL_CLAMP 
}; 
 
/**************************************************************************** 
 **************************************************************************** 
 * RENDERING STATE ROUTINES ************************************************* 
 **************************************************************************** 
 ****************************************************************************/ 
 
 

/**************************************************************************** 
 * _r_set_color_from                                 sets the current color * 
 ****************************************************************************/ 
void renderer_c::set_color 
( 
    color_t         color 
) 
{ 
    AssertThis;

    state.currentcolor = color; 
    color_to_vec(state.currentcolor, state.currentcolorvec);
} 
 
 
 

/****************************************************************************
 * _r_set_blending                                             set blending *
 ****************************************************************************/
void renderer_c::set_blending
(
    ushort          blendtype
)
{
    AssertThis;

//    if (blendtype == state.blendtype)
//        return;

    state.blendtype = blendtype;

    switch(blendtype) 
    { 
        case BT_ADD: 
            glBlendFunc(GL_ONE, GL_ONE); 
            break; 
 
        case BT_BLEND: 
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
            break; 
 
        case BT_MODULATE: 
            glBlendFunc(GL_ZERO, GL_SRC_COLOR); 
            break; 
 
        case BT_MODULATE2X: 
            glBlendFunc(GL_ONE, GL_SRC_COLOR); 
            break; 

        case BT_OPAQUE: 
            glDisable(GL_BLEND);
            return;

        case BT_ALPHATEST:
            glDisable(GL_BLEND);
            glEnable(GL_ALPHA_TEST);
            return;

    }
    glDisable(GL_ALPHA_TEST);
    glEnable(GL_BLEND);
} 
 
 
 
/****************************************************************************
 * _r_set_zbuffer                                          set zbuffer mode *
 ****************************************************************************/
void renderer_c::set_zbuffer
(
    ushort      buftype
)
{
    AssertThis;

//    if (buftype == state.zbuffertype)
//        return;

    state.zbuffertype = buftype;

    switch(buftype) 
    { 
        case ZB_NONE: 
            glEnable(GL_DEPTH_TEST); 
            glDepthFunc(GL_ALWAYS); 
            break; 
 
        case ZB_LESS: 
            glEnable(GL_DEPTH_TEST); 
            glDepthFunc(GL_LESS); 
            break; 
 
        case ZB_LESSEQUAL: 
            glEnable(GL_DEPTH_TEST); 
            glDepthFunc(GL_LEQUAL); 
            break; 
 
        case ZB_EQUAL: 
            glEnable(GL_DEPTH_TEST); 
            glDepthFunc(GL_EQUAL); 
            break; 
 
        case ZB_GREATEREQUAL: 
            glEnable(GL_DEPTH_TEST); 
            glDepthFunc(GL_GEQUAL); 
            break; 
 
        case ZB_GREATER: 
            glEnable(GL_DEPTH_TEST); 
            glDepthFunc(GL_GREATER); 
            break; 
    } 
} 
 
 
 
/**************************************************************************** 
 * _r_set_zwrite                                            set zwrite mode * 
 ****************************************************************************/ 
void renderer_c::set_zwrite 
( 
    bool        enable 
) 
{ 
    AssertThis;

    glDepthMask(enable); 
} 
 
 
 
/****************************************************************************
 * _r_set_culling                                 set backface culling mode *
 ****************************************************************************/
void renderer_c::set_culling
(
    ushort      cullmode
)
{
    AssertThis;

    switch(cullmode) 
    { 
        case CULL_NONE: 
            glDisable(GL_CULL_FACE); 
            break; 
 
        case CULL_CW: 
            glEnable(GL_CULL_FACE); 
            glCullFace(GL_FRONT); 
            break; 
 
        case CULL_CCW: 
            glEnable(GL_CULL_FACE); 
            glCullFace(GL_BACK); 
            break; 
    } 
} 
 
 
 
/**************************************************************************** 
 * _r_set_spheremapping                        enable/disable spheremapping * 
 ****************************************************************************/ 
void renderer_c::set_spheremapping 
( 
    bool        enable 
) 
{ 
    AssertThis;

    //if (enable == state.spheremapping)
        //return;

    state.spheremapping = enable;

    if (enable) 
    { 
        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); 
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); 
        glEnable(GL_TEXTURE_GEN_S); 
        glEnable(GL_TEXTURE_GEN_T); 
 
    } 
    else 
    { 
        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); 
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); 
        glDisable(GL_TEXTURE_GEN_S); 
        glDisable(GL_TEXTURE_GEN_T); 
    } 
} 
 
 
 
/**************************************************************************** 
 * _r_set_fog                                            enable/disable fog * 
 ****************************************************************************/ 
void renderer_c::set_fog 
( 
    bool        enable 
) 
{ 
    AssertThis;

    if (state.fog == enable)
        return;

    if (state.fog = enable) 
        glEnable(GL_FOG); 
    else 
        glDisable(GL_FOG); 
} 
 
 
 
/**************************************************************************** 
 * _r_set_fog_params                                     set fog parameters * 
 ****************************************************************************/ 
void renderer_c::set_fog_params 
( 
    float       n,
    float       f,
    color_t     color
) 
{ 
    AssertThis;

    vec4_t colvec; 
 
    glFogi(GL_FOG_MODE, GL_LINEAR); 
    glFogf(GL_FOG_START, n ); 
    glFogf(GL_FOG_END, f );

    color_to_vec(color, colvec);
 
    glFogfv(GL_FOG_COLOR, colvec); 
} 
 
 
 
/**************************************************************************** 
 * _r_use_shader                                         set current shader * 
 ****************************************************************************/ 
void renderer_c::use_shader 
( 
    const shader_t   *shader 
) 
{ 
    AssertThis;

    state.currentshader = shader; 
} 
 
 
/****************************************************************************
 * _r_set_target_backbuffer                              renders to texture *
 ****************************************************************************/
void renderer_c::set_target_texture(sshort n) 
{ 
    // WARNING: everything will still be written to the backbuffer.
    // the actual transfer to the texture is in set_target_backbuffer()
    // which copies the backbuffer contents into the texture you define here.

    if (!gv.texman->get_gltexture(n)) 
        return; 
 
    glViewport(0,0, gv.texman->get_width(n), gv.texman->get_height(n)); 
    state.targettexture = n; 

    /* dont forget to call set_target_backbuffer() */
} 

 
/****************************************************************************
 * _r_set_target_backbuffer                           renders to backbuffer *
 ****************************************************************************/
void renderer_c::set_target_backbuffer() 
{ 
    AssertThis;

    if (state.targettexture == -1) 
      return; 
 
    sshort num = state.targettexture; 
    ushort w   = gv.texman->get_width(num); 
    ushort h   = gv.texman->get_height(num);  
 
    char *buf = new char[4*w*h]; 

    /* put backbuffer into texture */
    glReadBuffer(GL_BACK); 
    glBindTexture(GL_TEXTURE_2D, gv.texman->get_gltexture(num)); 
 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0,0, w,h, 0); 
 
    glViewport(0,0,gv.init.hres, gv.init.vres); 
 
    SafeArrayDelete(buf); 
} 

/****************************************************************************
 * _r_set_lightmap                                 sets the active lightmap *
 ****************************************************************************/
void renderer_c::set_lightmap(sshort i)
{
    AssertThis;

    if (i<0)
        i = -1;

    gv.lightmap = i;
}

void renderer_c::set_texture_params
(
    sshort          minfilter,
    sshort          magfilter,
    sshort          wrapu,
    sshort          wrapv
)
{
    //if (state.texminfilter != minfilter)
    {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
            _gl_texfilter[minfilter]); 

        state.texminfilter = minfilter;
    }

    //if (state.texmagfilter != magfilter)
    {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 
            _gl_texfilter[magfilter]); 

        state.texmagfilter = magfilter;
    }

    if (state.texwrapu != wrapu)
    {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
            _gl_texwrap[wrapu]);

        state.texwrapu = wrapu;
    }

    if (state.texwrapv != wrapv)
    {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
            _gl_texwrap[wrapv]);

        state.texwrapv = wrapv;
    }
}

/****************************************************************************
 * _r_update_lights                                update light information *
 ****************************************************************************/
void _r_update_lights()
{
    if (gv.lightcount)
    {
        glEnable(GL_LIGHTING);

        for (ulong i=0; i<8; i++)
        {
            if (i>=gv.lightcount)
            {
                glDisable(GL_LIGHT0+i);
                continue;
            }

            glEnable(GL_LIGHT0+i);

            vec4_t color;

            color_to_vec(gv.lights[i].color, color);

            glLightfv(GL_LIGHT0+i, GL_DIFFUSE, color);
            glLightfv(GL_LIGHT0+i, GL_POSITION, gv.lights[i].pos);
        }
    }
    else
        glDisable(GL_LIGHTING);
}


/**************************************************************************** 
 * _r_color_from_floats                                         get a color * 
 ****************************************************************************/ 
color_t color_from_floats 
( 
    float       r, 
    float       g, 
    float       b, 
    float       a 
) 
{ 
    return _COLOR2LONG(CLAMP(r,0,1),CLAMP(g,0,1),CLAMP(b,0,1),CLAMP(a,0,1)); 
} 
 
 
/**************************************************************************** 
 * _r_color_from_vec                                            get a color * 
 ****************************************************************************/ 
color_t color_from_vec 
( 
    const vec4_t     color 
) 
{ 
    return color_from_floats( V4TOFS(color) ); 
} 
 
/**************************************************************************** 
 * _r_color_to_vec                                          convert a color * 
 ****************************************************************************/ 
void color_to_vec 
( 
    color_t         color, 
    vec4_t          out 
) 
{ 
    vec4_c(
        ((float)((color>>0)&0xff))/255.0f, 
        ((float)((color>>8)&0xff))/255.0f, 
        ((float)((color>>16)&0xff))/255.0f,
        ((float)((color>>24)&0xff))/255.0f).copy(out); 
} 

/****************************************************************************
 * _r_color_interpolate                        interpolate between 2 colors *
 ****************************************************************************/
color_t color_interpolate 
( 
    color_t         color1, 
    color_t         color2, 
    float           frac 
) 
{ 
    vec4_t     c1, c2;

    if (!frac)
        return color1;

    if (frac==1)
        return color2;

    color_to_vec(color1, c1); 
    color_to_vec(color2, c2); 
 
    return color_from_vec(vec4_c::linear(c1,c2, frac));
} 

---