---

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

/*

  $Log: r_draw.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"

/****************************************************************************
 ****************************************************************************
 * 2D & 3D RENDERING FUNCTIONS **********************************************
 ****************************************************************************
 ****************************************************************************/

/****************************************************************************
 ****************************************************************************
 * 2D FUNCTIONS *************************************************************
 ****************************************************************************
 ****************************************************************************/

/****************************************************************************
 * renderer_c::draw_pic                                  draws a 2d picture *
 ****************************************************************************/
void renderer_c::draw_pic
( 
    float           x1,                 // screen coordinates 
    float           y1,
    float           x2,
    float           y2,
    float           u1,                 // texture coordinates 
    float           v1,
    float           u2,
    float           v2,
    sshort          texture,
    ushort          blendtype
)
{
    AssertThis;

    vertex_t   verts[]=
    {
        {{  0,  0, 0 }, {{u1, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1,  0, 0 }, {{u2, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1,  1, 0 }, {{u2, v1}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  0,  1, 0 }, {{u1, v1}, {0,0}}, {0,0,-1}, state.currentcolor}
    };           // the vertex buffer 
 
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    glTranslatef(x1,y1,0);
    glScalef((x2-x1),(y2-y1),1);

    // draw! 
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();

    set_spheremapping(false);
    set_blending(blendtype);
    set_texture_params(TF_LINEAR,TF_LINEAR,0,0);
    gv.texman->set(texture);

    use_vertices(verts, 4);
    push_vertices(PT_QUADS, 4);

    glPopMatrix();
}
 
 
 
/****************************************************************************
 * renderer_c::draw_pic_shader                           draws a 2d picture *
 ****************************************************************************/
void renderer_c::draw_pic_shader 
( 
    float           x1,                 // screen coordinates
    float           y1,
    float           x2,
    float           y2,
    float           u1,                 // texture coordinates
    float           v1,
    float           u2,
    float           v2,
    const shader_t  *shader
)
{
    AssertThis;

    vertex_t   verts[]=
    {
        {{  0,  0, 0 }, {{u1, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1,  0, 0 }, {{u2, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1,  1, 0 }, {{u2, v1}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  0,  1, 0 }, {{u1, v1}, {0,0}}, {0,0,-1}, state.currentcolor}
    };           // the vertex buffer 
 
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    glTranslatef(x1,y1,0);
    glScalef((x2-x1),(y2-y1),1);

    // draw! 
    use_shader(shader); 
    render_verts(verts,4,PT_QUADS); 

    glPopMatrix();
} // _r_draw_pic_shader 



/****************************************************************************
 * render_c::draw_rotated_pic                            draws a 2d picture *
 ****************************************************************************/
void renderer_c::draw_rotated_pic 
( 
    float           angle,
    float           x1,                 // screen coordinates (center) 
    float           y1,
    float           w,                  // width and height 
    float           h,
    float           u1,                 // texture coordinates 
    float           v1,
    float           u2,
    float           v2,
    sshort          texture,
    ushort          blendtype
) 
{ 
    AssertThis;

    vertex_t   verts[]=
    {
        {{ -1, -1, 0 }, {{u1, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1, -1, 0 }, {{u2, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1,  1, 0 }, {{u2, v1}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{ -1,  1, 0 }, {{u1, v1}, {0,0}}, {0,0,-1}, state.currentcolor}
    };           // the vertex buffer 
 
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    glTranslatef(x1,y1,0);
    glRotatef(angle, 0, 0, 1);
    glScalef(w/2,h/2,1);

    // draw! 
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();

    set_spheremapping(false);
    set_blending(blendtype);
    gv.texman->set(texture);

    use_vertices(verts, 4);
    push_vertices(PT_QUADS, 4);

    glPopMatrix();
} // _r_draw_rotated_pic 



/****************************************************************************
 * renderer_c::draw_rotated_pic_shader                   draws a 2d picture *
 ****************************************************************************/
void renderer_c::draw_rotated_pic_shader
(
    float           angle,
    float           x1,                 // screen coordinates (center)
    float           y1,
    float           w,                  // width and height
    float           h,
    float           u1,                 // texture coordinates
    float           v1,
    float           u2,
    float           v2,
    const shader_t  *shader
) 
{ 
    AssertThis;

    vertex_t   verts[]=
    {
        {{ -1, -1, 0 }, {{u1, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1, -1, 0 }, {{u2, v2}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{  1,  1, 0 }, {{u2, v1}, {0,0}}, {0,0,-1}, state.currentcolor},
        {{ -1,  1, 0 }, {{u1, v1}, {0,0}}, {0,0,-1}, state.currentcolor}
    };           // the vertex buffer 
 
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    glTranslatef(x1,y1,0);
    glRotatef(angle, 0, 0, 1);
    glScalef(w/2,h/2,1);

    // draw! 
    use_shader(shader); 
    render_quad(verts); 

    glPopMatrix();
} // _r_draw_rotated_pic_shader 
 
 
/**************************************************************************** 
 * render_c::draw_lensflares                               draws lensflares * 
 ****************************************************************************/ 
void renderer_c::draw_lensflares
( 
    const lensflare_t     *flare,         // array of flares
    const vec2_t    pos,
    ulong           count,
    float           intensity
) 
{ 
    AssertThis;

    AssertReturn3(flare, pos, count);

    vec3_c         p, sp; 
 
    p.set(pos[VECT_X]-gv.renderer->get_viewwidth()/2, pos[VECT_Y]-gv.renderer->get_viewheight()/2, 0 );

    gv.renderer->set_texture_params(TF_LINEAR_MIPMAP_LINEAR, TF_LINEAR_MIPMAP_LINEAR, TW_REPEAT, TW_REPEAT);
 
    for (ulong i=0; i<count; i++) 
    { 
        sp = p * flare[i].position; 
        set_blending(flare[i].blendttype); 

        gv.renderer->set_color(color_interpolate(0, flare[i].color, intensity));

        draw_rotated_pic( flare[i].angle, sp[VECT_X]+gv.renderer->get_viewwidth()/2, 
            sp[VECT_Y]+gv.renderer->get_viewheight()/2,  flare[i].size*intensity, flare[i].size*intensity, 
            0,0, 1,1, flare[i].texture, flare[i].blendttype); 
    } 
} // _r_draw_lensflare 



/****************************************************************************
 ****************************************************************************
 * 3D FUNCTIONS *************************************************************
 ****************************************************************************
 ****************************************************************************/

/****************************************************************************
 * renderer_c::draw_billboard                             draws a billboard *
 ****************************************************************************/
void renderer_c::draw_billboard
( 
    const vec3_t    pos,                // position of billboard
    const vec2_t    size,               // size
    sshort          texture,
    ushort          blendtype
)
{
    AssertThis;
    AssertReturn2(pos, size);

    vertex_t    verts[4];          // the vertex buffer 
 
    vec3_c      vup,vright; 
    float       sizeu, sizev;
 
    vup     = gv.renderer->get_viewup2()    * size[1];
    vright  = gv.renderer->get_viewright()  * size[0];

    sizeu = size[0]/2;
    sizev = size[1]/2;

    for ( ulong i=0; i<4; i++ ) 
    { 
        vec3_c tmp;

        tmp = pos + vright *    (QUADVERTX(i)*sizeu);
                tmp = tmp + vup    *    (QUADVERTY(i)*sizev);

        tmp.copy(verts[i].xyz);

        vec2_c(NQUADVERTX(i), NQUADVERTY(i)).copy(verts[i].uv[0]);
        verts[i].diffuse = state.currentcolor;
    } 
 
    // draw! 
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();

    set_spheremapping(false);
    set_blending(blendtype);
    gv.texman->set(texture);

    use_vertices(verts, 4);
    push_vertices(PT_QUADS, 4);
} // _r_draw_billboard 
 
 
 
 
/****************************************************************************
 * renderer_c::draw_billboard_shader                      draws a billboard *
 ****************************************************************************/
void renderer_c::draw_billboard_shader
( 
    const vec3_t    pos,                // position of billboard
    const vec2_t    size,               // size
    const shader_t  *shader 
) 
{
    AssertThis;
    AssertReturn3(pos, size, shader);

    vertex_t   verts[4];          // the vertex buffer 
 
    vec3_c     vup,vright; 
    float       sizeu, sizev;
 
    vup     = gv.renderer->get_viewup2()    * size[1];
    vright  = gv.renderer->get_viewright()  * size[0];

    sizeu = size[0]/2;
    sizev = size[1]/2;

    for ( ulong i=0; i<4; i++ ) 
    { 
        vec3_c tmp;

        tmp = pos + vright *    (QUADVERTX(i)*sizeu);
                tmp = tmp + vup    *    (QUADVERTY(i)*sizev);
        tmp.copy(verts[i].xyz);

        vec2_c(NQUADVERTX(i), NQUADVERTY(i)).copy(verts[i].uv[0]);
        verts[i].diffuse = state.currentcolor;
    } 
 
    // draw! 
    use_shader(shader); 
    render_quad(verts); 
} // _r_draw_billboard 
 
   
   
/****************************************************************************
 * _r_draw_rotated_billboard                              draws a billboard *
 ****************************************************************************/
void renderer_c::draw_rotated_billboard
( 
    const vec3_t    pos,                // position of particle
    const vec2_t    size,               // size of the particle
    float           angle,
    sshort          texture,
    ushort          blendtype
)
{
    AssertThis;
    AssertReturn2(pos, size);

    vertex_t   verts[4];          // the vertex buffer

    vec3_c     vup,vright; 
 
    vup     = gv.renderer->get_viewup2();
    vright  = gv.renderer->get_viewright(); 
    
    vec3_t     upright[4]; 
 
    // rotated vup and vright vectors 
    float       rad       = (float)(-angle / 180.0f*PI); 
    float       radsin    = (float)(sin(rad)); 
    float       radcos    = (float)(cos(rad)); 
    vec3_c      tmp,tmp2; 

    for (ulong i=0; i<4; i++) 
    { 
        upright[i][0] = QUADVERTX(i)*size[0];     
        upright[i][1] = QUADVERTY(i)*size[1]; 

        tmp = upright[i];
 
        upright[i][0] = tmp[0]*radcos-tmp[1]*radsin; 
        upright[i][1] = tmp[0]*radsin+tmp[1]*radcos; 
 
        tmp     = vright * upright[i][0];
        tmp2    = vup * upright[i][1];
 
        tmp     = tmp + tmp2 + pos;
        tmp.copy(verts[i].xyz);

        // set texture coordinates 
        vec2_c(NQUADVERTX(i), NQUADVERTY(i)).copy(verts[i].uv[0]);

        verts[i].diffuse = state.currentcolor;
    } 

    // draw! 
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();

    set_spheremapping(false);
    set_blending(blendtype);
    gv.texman->set(texture);

    use_vertices(verts, 4);
    push_vertices(PT_QUADS, 4);
} // _r_draw_rotated_billboard 
 
 
 
/**************************************************************************** 
 * _r_draw_rotated_billboard_shader                       draws a billboard * 
 ****************************************************************************/ 
void renderer_c::draw_rotated_billboard_shader 
( 
    const vec3_t    pos,                // position of particle
    const vec2_t    size,               // size of the particle
    float           angle,
    const shader_t  *shader
)
{
    AssertThis;
    AssertReturn3(pos, size, shader);

    vertex_t   verts[4];          // the vertex buffer 
 
    vec3_c     vup,vright; 
 
    vup     = gv.renderer->get_viewup2();
    vright  = gv.renderer->get_viewright();
 
    vec3_t     upright[4]; 
 
    // rotated vup and vright vectors 
    float       rad       = (float)(-angle / 180.0f*PI); 
    float       radsin    = (float)(sin(rad)); 
    float       radcos    = (float)(cos(rad)); 
    vec3_c     tmp,tmp2; 

    for (ulong i=0; i<4; i++) 
    { 
        upright[i][0] = QUADVERTX(i)*size[0];     
        upright[i][1] = QUADVERTY(i)*size[1]; 

        tmp = upright[i];
 
        upright[i][0] = tmp[0]*radcos-tmp[1]*radsin; 
        upright[i][1] = tmp[0]*radsin+tmp[1]*radcos; 
 
        tmp     = vright * upright[i][0];
        tmp2    = vup    * upright[i][1];
 
        tmp     = tmp + tmp2 + pos;
        tmp.copy(verts[i].xyz);

        // set texture coordinates 
        vec2_c(NQUADVERTX(i), NQUADVERTY(i)).copy(verts[i].uv[0]);

        verts[i].diffuse = state.currentcolor;
    } 
 
    // draw! 
    use_shader(shader);
    render_quad(verts);
} // _r_draw_rotated_billboard_shader 
 
   
/****************************************************************************
 * render_c::draw_particle                                 draws a particle *
 ****************************************************************************/
/*
void renderer_c::draw_particle
(
    particle_t      *part
)
{
    AssertThis;
    AssertReturn1(part);

    vec2_t s;
 
    if (!(part->flags&PF_ACTIVE)) 
        return; 
 
    if (part->birthtime>gv.time) 
        return; 
 
    set_color_from_vec(part->color); 
    vector2_copy(part->size, s);
 
    float angle = 0; 
 
    if (part->flags & PF_ALIGNEDTOMOTION) 
    { 
        float x,y; 
 
        x = gv.renderer->get_viewright().dot(part->dir); 
        y = gv.renderer->get_viewup2().dot(part->dir); 
 
        angle = (float)(atan(x/y)/PI*180.0f); 
    } 
 
    draw_rotated_billboard(part->pos, s, angle+part->angle, 
        part->texture, part->blendtype); 
} // _r_draw_particle 
 
 */
 
/****************************************************************************
 * renderer_c::draw_particles                               draws particles *
 ****************************************************************************/
/*
void renderer_c::draw_particles
( 
    particle_t      *parts,
    ulong           count
)
{
    AssertThis;
    AssertReturn2(parts, count);

    for (ulong i=0; i<count; ++i)
        draw_particle(&parts[i]);
} // _r_draw_particles 
*/

---