---

r_main.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/18 14:12:16 $
// By           :       $Author: kolrabi $
// $Id: r_main.cpp,v 1.4 2002/12/18 14:12:16 kolrabi Exp $ 

/*

  $Log: r_main.cpp,v $
  Revision 1.4  2002/12/18 14:12:16  kolrabi
  *** empty log message ***

  Revision 1.3  2002/12/12 13:13:39  kolrabi
  made the fullscreen work under X11

  Revision 1.2  2002/12/08 20:08:15  kolrabi
  Now really runs under X11

  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/gui.h"
#include            "omicron/list.h"
#include            "omicron/input.h"
 
/**************************************************************************** 
 **************************************************************************** 
 * RENDERING ROUTINES ******************************************************* 
 **************************************************************************** 
 ****************************************************************************/ 

renderer_c::renderer_c()
{
    SafeDelete(gv.renderer);

    if (gv.init.nogfx) 
        return;

    gv.renderer = this;

    _log_printf(MSG_DEBUG, "- renderer_c::renderer_c() -------------"); 

    isinrender = false;

    _log_printf(MSG_DEBUG, "Creating texture manager"); 
    
    new texture_manager_c;

    // lights
    gv.lights       = new light_t[8];
    gv.lightcount   = 0;
//    _r_update_lights();
    
    glAlphaFunc(GL_GREATER, 0.5);

    // some opengl flags
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); 
    glHint(GL_FOG_HINT, GL_NICEST); 
    glShadeModel(GL_SMOOTH); 

    glEnable(GL_NORMALIZE);

    glClearDepth(1.0f);
    viewDepth       = 10000;

    state.autoclear     = 1; 
    state.bgcolor       = 0;
    state.texwrapu      = 0;
    state.texwrapv      = 0;
    state.texminfilter  = TF_LINEAR_MIPMAP_LINEAR;
    state.texmagfilter  = TF_LINEAR_MIPMAP_LINEAR;
    state.blendtype     = BT_OPAQUE;
    state.zbuffertype   = ZB_LESSEQUAL;

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); 

    // shaders
    gv.shaders = new list_c<shader_t>;
 
    use_shader(shader_create_simple(BT_BLEND, INVALID_INDEX));

    // load this first! this must be #0!
    gv.texman->load("textures/common/notfound");

    notfoundshader  = shader_create_simple(BT_OPAQUE, TEXTURE_NOTFOUND);
    sprintf(notfoundshader->name, "noshader");

    // view.. look from front
    viewPos         = vec3_c( 0, -1,  0);
    viewTarget      = vec3_c( 0,  0,  0);
    viewUp          = vec3_c( 0,  0,  1);

#if defined(WIN32)
    if (extgl_Extensions.NV_vertex_array_range)
    {
        drawvertcount   = 1000;
#if defined(WIN32)
        drawverts = (vertex_t*)wglAllocateMemoryNV(sizeof(vertex_t)*(drawvertcount), 0.2f, 0.2f, 0.5f);
#else
        drawverts = (vertex_t*)glXAllocateMemoryNV(sizeof(vertex_t)*(drawvertcount), 0.2f, 0.2f, 0.5f);
#endif
        glVertexArrayRangeNV(sizeof(vertex_t)*(drawvertcount), drawverts);
    }
    else
#endif
    {
        drawvertcount   = 100000;
        drawverts       = new vertex_t[drawvertcount];
    }

    if (query_glext("GL_EXT_VERTEX_ARRAY"))
    {
        glVertexPointer     (3, GL_FLOAT, sizeof(vertex_t),             drawverts->xyz         );
        glNormalPointer     (GL_FLOAT, sizeof(vertex_t),                drawverts->normal      );
        glColorPointer      (4, GL_UNSIGNED_BYTE,  sizeof(vertex_t),    &drawverts->diffuse    );
        glTexCoordPointer   (2, GL_FLOAT, sizeof(vertex_t),             drawverts->uv[0]       );
        
        glEnable(GL_VERTEX_ARRAY); 
        glEnable(GL_NORMAL_ARRAY); 
        glEnable(GL_TEXTURE_COORD_ARRAY); 
        glEnable(GL_COLOR_ARRAY);
    }


    state.currentcolor      = COLOR_WHITE;
    state.targettexture     = INVALID_INDEX;
    state.lightmap          = INVALID_INDEX;
    state.spheremapping     = false;
    state.fog               = false;

    if (query_glext("GL_NV_FOG_DISTANCE"))  // extgl_Extensions.NV_fog_distance)
        glFogf(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV);

    if (query_glext("GL_EXT_TEXTURE_FILTER_ANISOTROPIC")) // extgl_Extensions.EXT_texture_filter_anisotropic)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 8.0f);

    reset_charmode();

    glEnable(GL_NORMALIZE);
    glPixelZoom(1,-1);
    
    fov             = 90; 

    glEnable(GL_TEXTURE_2D);

    // done
    _log_printf(MSG_DEBUG, "----------------------------------------"); 
}
 
/**************************************************************************** 
 *                                                    deinitialize renderer * 
 ****************************************************************************/ 
renderer_c::~renderer_c()
{
    AssertThis;

    _log_printf(MSG_DEBUG, "- renderer_c::~renderer_c()-------------");

    // destroy shaders..
    _log_printf(MSG_DEBUG, "Destroying all shaders...");

    shader_t   *shader;

    if (gv.shaders)
    {
        shader = (shader_t*)gv.shaders->get_first();

        while(shader)
        {
            SafeDelete(shader);
            shader = (shader_t*)gv.shaders->get_next();
        }
    }
    SafeDelete(gv.shaders);

    // ..texture manager and lights
    SafeDelete(gv.texman);
    SafeArrayDelete(gv.lights);

#if defined(WIN32)
    if (query_glext("GL_NV_VERTEX_ARRAY_RANGE"))
    {
#if defined(WIN32)
        if (drawverts)
            wglFreeMemoryNV(drawverts);
#else
        if (drawverts)
            glXFreeMemoryNV(drawverts);
#endif
    }
    else
#endif
    {
        SafeArrayDelete(drawverts);
    }

    _log_printf(MSG_DEBUG, "----------------------------------------");
}


bool renderer_c::query_glext(const char *name)
{
    _log_printf(0, "%s", name);

    if (strstr((char*)glGetString(GL_EXTENSIONS), name))
        return true;

    _log_printf(0, "not supported...");
    
    return false;
} 
 
/**************************************************************************** 
 * _r_matrix_set3d                                        setup view for 3d * 
 ****************************************************************************/ 
void renderer_c::view_3d()
{ 
    AssertThis;

//    STARTPROFILE("renderer_c::view_3d"); 

    if (fov >= 180.0f)
        fov = 179.9f;

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity();
    gluPerspective(fov/gv.aspect, gv.aspect, 1, 
        gv.renderer->get_viewdepth()); 
 
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity();
 
    gluLookAt(viewPos[0],    viewPos[1],    viewPos[2], 
              viewTarget[0], viewTarget[1], viewTarget[2], 
              viewUp[0],     viewUp[1],     viewUp[2]); 

    float matmdl[16];

    glGetFloatv(GL_MODELVIEW_MATRIX,   matmdl);

    viewDir.set     ( -matmdl[2], -matmdl[6], -matmdl[10]);
    viewUp2.set     (  matmdl[1],  matmdl[5],  matmdl[9] );
    viewRight.set   ( -matmdl[0], -matmdl[4], -matmdl[8] );

    make_frustum();

//    ENDPROFILE("renderer_c::view_3d"); 
} 
 
 
 
 
/**************************************************************************** 
 * _r_matrix_set2d                                        setup view for 2d * 
 ****************************************************************************/ 
void renderer_c::view_2d
( 
    float       width,              // width of screen 
    float       height              // height 
) 
{ 
    AssertThis;

    glMatrixMode(GL_TEXTURE); 
    glLoadIdentity(); 
 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    gluOrtho2D    ( 0, 0, width, height ); 
    glScalef      (  2.0/width,  2.0/height, 1              ); 
    glTranslatef  ( -width/2.0, -height/2.0, 1              ); 

    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 
 
    viewWidth  = width; 
    viewHeight = height; 
} 
 
 
/****************************************************************************
 * _r_render_scene                                       renders everything *
 ****************************************************************************/
void renderer_c::render()
{ 
    AssertThis;

    if (gv.init.nogfx)
        return; 

    if (isinrender)
    {
        _log_printf(MSG_WARNING, "renderer_c::render() called from within itself!");
        return;
    }

    isinrender = true;

    // increase framecounter 
    gv.frame++; 
 
    if (state.autoclear)
    {
        vec4_t c; 
        color_to_vec(state.bgcolor, c); 
        glClearColor(V4TOFS(c));
        glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT); 
    }

    if (gv.iface)
        gv.iface->render(); 
 
    if (gv.gui)
    {
        view_2d(gv.init.hres, gv.init.vres);
        gv.gui->draw();
    }

#if defined(WIN32) 
    SwapBuffers(gv.hdc); 
#else 
    glXSwapBuffers(gv.init.dpy, gv.init.wnd); 
#endif 

    isinrender = false;
} // _r_render_scene 
 

/****************************************************************************
 * _r_render_processed_verts                   renders a number of vertices *
 ****************************************************************************/
void renderer_c::render_verts
(
    const vertex_t *_verts,             // pointer to a vertex buffer
    ulong           count,              // number of vertices
    ushort          type                // how to draw them
)
{
    AssertThis;
    AssertReturn1(_verts);

    if (!state.currentshader)
        return;

    const shader_t *currentshader = state.currentshader;

    use_vertices(_verts, count);
    glMatrixMode(GL_TEXTURE);

    bool fog = state.fog;

#if defined(WIN32)
    if (query_glext("GL_EXT_COMPILED_VERTEX_ARRAY"))
        glLockArraysEXT(0, count);
#endif

    if (query_glext("GL_NV_VERTEX_ARRAY_RANGE"))
        glEnableClientState(GL_VERTEX_ARRAY_RANGE_NV);

    for (ushort pass=0; pass<currentshader->passcount; pass++) 
    { 
        if (!pass || currentshader->passes[pass-1].matrix)
            glLoadIdentity(); 

        set_fog(fog && currentshader->passes[pass].fog);

        if (currentshader->passes[pass].ignorediffuse)
        {
            for (ulong v=0; v<count; v++)
                drawverts[v].diffuse = COLOR_WHITE;
        }
        else if (pass && currentshader->passes[pass-1].ignorediffuse)
        {
            for (ulong v=0; v<count; v++)
                drawverts[v].diffuse = _verts[v].diffuse;
        }

        if (currentshader->passes[pass].color)
        {
            float frac = shader_get_waveform_frac(&currentshader->passes[pass].colorwave);

            color_t ci =             color_interpolate( 
                currentshader->passes[pass].color1, 
                currentshader->passes[pass].color2, 
                frac);

            vec4_t  color, c1;

            if (ci != COLOR_WHITE) 
            {
                if (!ci)
                {
                    for (ulong v=0; v<count; v++)
                        drawverts[v].diffuse = 0;
                }
                else
                {
                    color_to_vec(ci, c1);

                    color[0] =  state.currentcolorvec[0] * c1[0];
                    color[1] =  state.currentcolorvec[1] * c1[1];
                    color[2] =  state.currentcolorvec[2] * c1[2];
                    color[3] =  state.currentcolorvec[3] * c1[3];

                    for (ulong v=0; v<count; v++)
                    {
                        color_to_vec(_verts[v].diffuse, c1); 
                        drawverts[v].diffuse = color_from_floats(
                            color[0] * c1[0],
                            color[1] * c1[1],
                            color[2] * c1[2],
                            color[3] * c1[3]
                            );
                    }
                }
            }
        }
        else if (state.currentcolor != 0xFFFFFFFF)
        {
            vec4_t  c1;

            for (ulong v=0; v<count; v++)
            {
                color_to_vec(_verts[v].diffuse, c1); 
                drawverts[v].diffuse = color_from_floats(
                    state.currentcolorvec[0] * c1[0],
                    state.currentcolorvec[1] * c1[1],
                    state.currentcolorvec[2] * c1[2],
                    state.currentcolorvec[3] * c1[3]
                    );
            }
        }

        set_texture_params(currentshader->passes[pass].minfilter,
            currentshader->passes[pass].magfilter,
            currentshader->passes[pass].texwrapu,
            currentshader->passes[pass].texwrapv);

        // set states according to shader 
        set_spheremapping(currentshader->passes[pass].shiny);

        if (currentshader->passes[pass].matrix)
        {
            if (currentshader->passes[pass].soffsetx ||
                currentshader->passes[pass].soffsety)
                glTranslatef(currentshader->passes[pass].soffsetx, 
                             currentshader->passes[pass].soffsety, 
                             0); 

            if (currentshader->passes[pass].scalex!=1 ||
                currentshader->passes[pass].scaley!=1)
                glScalef    (currentshader->passes[pass].scalex, 
                             currentshader->passes[pass].scaley*
                             (currentshader->passes[pass].shiny?-1:1), 
                             1); 

            if (currentshader->passes[pass].angle)
                glRotatef   (currentshader->passes[pass].angle,0,0,1); 
        }

        if (currentshader->dynamic)
        {
            if (currentshader->passes[pass].scalewavex.type != WF_NONE ||
                currentshader->passes[pass].scalewavey.type != WF_NONE)
            {
              float x = shader_get_waveform_frac(&currentshader->passes[pass].scalewavex); 
              float y = shader_get_waveform_frac(&currentshader->passes[pass].scalewavey); 
              glScalef    (x,y,1); 
            }
 
            if (currentshader->passes[pass].rotation)
                glRotatef   (gv.time*currentshader->passes[pass].rotation,0,0,1); 
 
            if (currentshader->passes[pass].scrollx || currentshader->passes[pass].scrolly || 
                currentshader->passes[pass].offsetx || currentshader->passes[pass].offsety)
                glTranslatef(gv.time*currentshader->passes[pass].scrollx+currentshader->passes[pass].offsetx, 
                gv.time*currentshader->passes[pass].scrolly+currentshader->passes[pass].offsety, 
                0);
        }

        gv.texman->set(currentshader->passes[pass].texture);
        set_blending(currentshader->passes[pass].blendtype);

        push_vertices(type, count);
    } 

#if defined(WIN32)
    if (query_glext("GL_EXT_COMPILED_VERTEX_ARRAY"))
        glUnlockArraysEXT();
#endif

    if (query_glext("GL_NV_VERTEX_ARRAY_RANGE"))
        glDisableClientState(GL_VERTEX_ARRAY_RANGE_NV);
}


/**************************************************************************** 
 * _r_clear_color                                   clears the color buffer * 
 ****************************************************************************/ 
void renderer_c::clear_color()
{ 
    AssertThis;

    glClear(GL_COLOR_BUFFER_BIT); 
} 
 
/**************************************************************************** 
 * _r_clear_zbuffer                                 clears the depth buffer * 
 ****************************************************************************/ 
void renderer_c::clear_depth()
{ 
    AssertThis;

    glClear(GL_DEPTH_BUFFER_BIT); 
} 

/**************************************************************************** 
 * _r_render_quad                                              draws a quad * 
 ****************************************************************************/ 
void renderer_c::render_quad 
( 
    const vertex_t   *verts              // pointer to vertices 
) 
{ 
    AssertThis;

    render_verts( verts, 4, PT_TRIANGLEFAN ); 
} 

/**************************************************************************** 
 * _r_render_line_vec                                         renders a line* 
 ****************************************************************************/ 
void renderer_c::render_line_vec 
( 
    const vec3_t     v1, 
    const vec3_t     v2 
) 
{ 
    AssertThis;

    vertex_t   verts[2];           // the vertex buffer 
 
    // set coordinates 
    vertex_set( &verts[0], v1[0], v1[1], v1[2], 0, 0 ); 
    vertex_set( &verts[1], v2[0], v2[1], v2[2], 0, 0 ); 
 
    render_verts(verts, 2, PT_LINESTRIP); 
} // _r_render_line_vec 
 
 
 
/**************************************************************************** 
 * _r_render_line2d                                          renders a line * 
 ****************************************************************************/ 
void renderer_c::render_line2d 
( 
    float       x, 
    float       y, 
    float       x2, 
    float       y2 
) 
{ 
    AssertThis;

    vec3_c     v1,v2; 
 
    v1.set(x, y, 0); 
    v2.set(x2, y2, 0); 
 
    render_line_vec(v1,v2); 
} // _r_render_line2d 

void renderer_c::make_frustum()
{
    float fovx = fov/2;
    float fovy = fov/2/gv.aspect;

/*    float fovx = tanf(fov/2*DEG2RAD);
    float fovy = tanf(fov/2*DEG2RAD/gv.aspect);
*/
    vec3_c tmp;

    tmp = viewRight;
    tmp.rotate_vec(-fovx, viewUp2).copy(viewFrustum[0].n);

    tmp = viewRight;
    tmp.rotate_vec(180+fovx, viewUp2).copy(viewFrustum[1].n);

    tmp = viewUp2;
    tmp.rotate_vec(fovy, viewRight).copy(viewFrustum[2].n);

    tmp = viewUp2;
    tmp.rotate_vec(180-fovy, viewRight).copy(viewFrustum[3].n);

    viewDir.normalize().copy(viewFrustum[4].n);
    
    tmp = viewDir * -1;
    tmp.copy(viewFrustum[5].n);

    for (ulong i=0; i<6; i++)
        viewFrustum[i].d = viewPos.dot(viewFrustum[i].n);

    viewFrustum[5].d-=viewDepth;
}

void renderer_c::need_vertices(ulong count)
{
    if (count<=drawvertcount)
        return;

    drawvertcount = count;

#if defined(WIN32)
    if (query_glext("GL_NV_VERTEX_ARRAY_RANGE"))
    {
#if defined(WIN32)
        if (drawverts)
            wglFreeMemoryNV(drawverts);

        drawverts = (vertex_t*)wglAllocateMemoryNV(sizeof(vertex_t)*(drawvertcount = count), 0.2f, 0.2f, 0.5f);
#else
        if (drawverts)
            glXFreeMemoryNV(drawverts);

        drawverts = (vertex_t*)glXAllocateMemoryNV(sizeof(vertex_t)*(drawvertcount = count), 0.2f, 0.2f, 0.5f);
#endif
        glVertexArrayRangeNV(sizeof(vertex_t)*(drawvertcount), drawverts);
    }
    else
#endif
    {
        SafeArrayDelete(drawverts);
        drawverts = new vertex_t[drawvertcount];
    }
}

void renderer_c::use_vertices(const vertex_t *verts, ulong count)
{
    need_vertices(count);
    memcpy(drawverts, verts, count*sizeof(vertex_t));

    if (query_glext("GL_EXT_VERTEX_ARRAY"))
    {
        glVertexPointer     (3, GL_FLOAT, sizeof(vertex_t),             drawverts->xyz         );
        glNormalPointer     (GL_FLOAT, sizeof(vertex_t),                drawverts->normal      );
        glColorPointer      (4, GL_UNSIGNED_BYTE,  sizeof(vertex_t),    &drawverts->diffuse    );
        glTexCoordPointer   (2, GL_FLOAT, sizeof(vertex_t),             drawverts->uv[0]       );
    }
}

void renderer_c::push_vertices(ushort ptype, ulong count)
{
    GLuint  pttype = GL_POINTS; 
 
    switch(ptype) 
    { 
        case PT_POINTS:         pttype = GL_POINTS;          break; 
        case PT_LINES:          pttype = GL_LINES;           break; 
        case PT_LINESTRIP:      pttype = GL_LINE_STRIP;      break; 
        case PT_LINELOOP:       pttype = GL_LINE_LOOP;       break; 
        case PT_TRIANGLES:      pttype = GL_TRIANGLES;       break; 
        case PT_TRIANGLESTRIP:  pttype = GL_TRIANGLE_STRIP;  break; 
        case PT_TRIANGLEFAN:    pttype = GL_TRIANGLE_FAN;    break; 
        case PT_QUADS:          pttype = GL_QUADS;           break;
    } 

    if (!query_glext("GL_EXT_VERTEX_ARRAY"))
    {
        glBegin(pttype);
        
        for (ulong i=0; i<count; i++)
        {
            vec4_t v;
            
            color_to_vec(drawverts[i].diffuse, v);
            
            glColor4f(V4TOFS(v));
            glTexCoord2f(V2TOFS(drawverts[i].uv[0]));
            glVertex3fv(drawverts[i].xyz);
        }

        glEnd();
    }
    else
        glDrawArrays(pttype, 0, count);
}

---