---

render.h

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: render.h,v 1.3 2002/12/18 14:12:16 kolrabi Exp $ 

/*

  $Log: render.h,v $
  Revision 1.3  2002/12/18 14:12:16  kolrabi
  *** empty log message ***

  Revision 1.2  2002/12/18 09:31:53  kolrabi
  added string rendering flag SF_RIGHT

  Revision 1.1.1.1  2002/12/07 19:02:19  kolrabi
  initial release


*/

/****************************************************************************
 ****************************************************************************
 * DEFINES ******************************************************************
 ****************************************************************************
 ****************************************************************************/

/* BLENDTYPES ***************************************************************/
#define             BT_OPAQUE           0
#define             BT_ADD              1
#define             BT_BLEND            2
#define             BT_MODULATE         3
#define             BT_ALPHATEST        4
#define             BT_MODULATE2X       5
#define             BT_NONE             -1

/* ZBUFFER TYPES ************************************************************/
#define             ZB_NONE             0
#define             ZB_LESS             1
#define             ZB_LESSEQUAL        2
#define             ZB_EQUAL            3
#define             ZB_GREATEREQUAL     4
#define             ZB_GREATER          5

/* PRIMITIVE TYPES **********************************************************/
#define             PT_POINTS           0
#define             PT_LINES            1
#define             PT_LINESTRIP        2
#define             PT_LINELOOP         3
#define             PT_TRIANGLES        4
#define             PT_TRIANGLESTRIP    5
#define             PT_TRIANGLEFAN      6
#define             PT_QUADS            7

/* BACKFACE CULLING TYPES ***************************************************/
#define             CULL_NONE           0
#define             CULL_CW             1
#define             CULL_CCW            2

/* STRING OUTPUT FLAGS ******************************************************/
#define             SF_CENTERED         1
#define             SF_RIGHT            2

/* SHADER WAVEFORM TYPES ****************************************************/
#define             WF_NONE             0
#define             WF_RECT             1
#define             WF_SINE             2
#define             WF_RECT2D           3
#define             WF_SINE2D           4

/* SOME COLORS **************************************************************/
#define             COLOR_BLACK         0xFF000000
#define             COLOR_WHITE         0xFFFFFFFF

// OpenGL extensions

// GL_NV_fog_distance
#define GL_FOG_DISTANCE_MODE_NV               0x855A
#define GL_EYE_RADIAL_NV                      0x855B
#define GL_EYE_PLANE_ABSOLUTE_NV              0x855C

/****************************************************************************
 ****************************************************************************
 * TYPEDEFS *****************************************************************
 ****************************************************************************
 ****************************************************************************/

#ifndef             OMICRONTYPES_RENDER_DEFINED
#define             OMICRONTYPES_RENDER_DEFINED

/****************************************************************************/
/* RENDERER *****************************************************************/

typedef ulong       color_t;

typedef struct triangle_s               
{
    ulong           vertices[3];        
    vec2_t          uv[3];              
} triangle_t;

typedef struct mesh_s                   
{
    vertex_t        *verts;             
    triangle_t      *tris;              

    ulong           nVerts;             
    ulong           nTris;              
} mesh_t;

typedef struct light_s                  
{ 
    vec3_t          pos;                
    color_t         color;              
    vec3_t          attn;               
} light_t;

typedef struct lensflare_s              
{
    float           position;           
    float           size;               
    float           angle;              
    color_t         color;              
    sshort          texture;            
    ushort          blendttype;         
} lensflare_t; 

typedef struct shader_waveform_s        
{
    ushort          type;               
    float           freq, phase;        
    float           amplitude, bias;    
} shader_waveform_t;

typedef struct shaderpass_s             
{
    bool            lightmap;           
    bool            lighting;           
    bool            twosided;           
    bool            nodepth;            
    bool            shiny;              

    bool            matrix;
    bool            color;

    bool            fog;
    bool            ignorediffuse;

    sshort          texture;            
    ushort          blendtype;          


    float           rotation;           
    float           angle;
    float           scrollx, scrolly;   
    float           offsetx, offsety;   
    float           soffsetx, soffsety; 

    float           scalex, scaley;     
    shader_waveform_t
                    scalewavex, scalewavey;
 
    color_t         color1, color2;     
    shader_waveform_t                   
                    colorwave; 
 
    ushort          minfilter;          
    ushort          magfilter;          
    ushort          texwrapu;           
    ushort          texwrapv;           
} shaderpass_t;

typedef         struct shader_s         
{
    char            name[64];           
    ushort          passcount;          
    shaderpass_t    passes[8];          
    bool            dynamic;            
} shader_t;

typedef struct font_s                   
{
    int             texture;
    class image_c   *images[255];
    uchar           widths[255];

    ushort          width;
    ushort          height;

    shader_t        *shader;
} font_t;

class renderer_c
{
private:

    struct state_s
    {
        // state stuff 
        color_t         bgcolor;            
        bool            autoclear;          

        color_t         currentcolor;       
        vec4_t          currentcolorvec;    
        sshort          targettexture;      
        sshort          lightmap;           
        const struct    shader_s *currentshader;     

        sshort          texminfilter;
        sshort          texmagfilter;
        sshort          texwrapu;
        sshort          texwrapv;

        sshort          blendtype;
        sshort          zbuffertype;

        bool            spheremapping;

        bool            fog;

        bool            font_bold;          
        bool            font_italic;
        color_t         font_color;
    };

    state_s         state;

    vertex_t        *drawverts;
    ulong           drawvertcount;

    bool            isinrender;

// view --------------------------------------------------------------------
 
    // camera data 
    vec3_c          viewPos,            
                    viewTarget, 
                    viewUp; 

    vec3_c          viewDir,            
                    viewRight, 
                    viewUp2; 

    float           viewWidth,          
                    viewHeight;  

    plane_t         viewFrustum[6];     
 
    float           fov;                
    float           viewDepth;          
    
    void
        make_frustum();

    bool
        query_glext(const char *name);
    
public:

    // viewPos

    void                                
        set_viewpos(const vec3_t pos)
    {
        AssertThis;
        AssertReturn1(pos);
        viewPos = pos;
    }

    vec3_c                              
        get_viewpos()
    {
        AssertThisValue(vec3_c());
        return viewPos;
    }

    // viewTarget
    
    void                                
        set_viewtarget(const vec3_t pos)
    {
        AssertThis;
        AssertReturn1(pos);
        viewTarget = pos;
    }

    vec3_c                              
        get_viewtarget()
    {
        AssertThisValue(vec3_c());
        return viewTarget;
    }

    // viewUp
    
    void                                
        set_viewup(const vec3_t pos)
    {
        AssertThis;
        AssertReturn1(pos);

        viewUp = pos;
    }

    vec3_c                              
        get_viewup()
    {
        AssertThisValue(vec3_c());
        return viewUp;
    }
    
    const plane_t *
        get_viewfrustum()
    {
        AssertThisV;
        return viewFrustum;
    }

    vec3_c                              
        get_viewdir()
    {
        AssertThisValue(vec3_c());
        return viewDir;
    }
    
    vec3_c                              
        get_viewright()
    {
        AssertThisValue(vec3_c());
        return viewRight;
    }

    vec3_c                              
        get_viewup2()
    {
        AssertThisValue(vec3_c());
        return viewUp2;
    }
    
    float
        get_viewwidth()
    {
        AssertThisValue(640);
        return viewWidth;
    }
    
    float
        get_viewheight()
    {
        AssertThisValue(480);
        return viewHeight;
    }

    float
        get_viewdepth()
    {
        AssertThisV;
        return viewDepth;
    }

    void
        set_viewdepth(float depth)
    {
        AssertThis;
        viewDepth = depth;
    }

    void
        set_fov(float f)
    {
        AssertThis;
        fov = f;
    }
    
    float
        get_fov()
    {
        AssertThisValue(90);
        return fov;
    }
    
    color_t
        get_bgcolor()
    {
        AssertThisV;
        return state.bgcolor;
    }
    
    void
        set_bgcolor(color_t c)
    {
        AssertThis;
        state.bgcolor = c;
    }


    // view stuff **********

    slong
        view_clipbox(const bbox_t *bbox);

    slong
        view_clipsphere(const vec3_t pos, float radius);

    slong
        view_clippoint(const vec3_t in);

public:

    renderer_c();
    ~renderer_c();

    void
        render();

    void
        reset_charmode();

    void
        need_vertices(ulong count);

    void
        use_vertices(const vertex_t *verts, ulong count);

    void
        push_vertices(ushort type, ulong count);

public:

    struct shader_s *notfoundshader;

    void            
        view_2d(float width, float height);

    void            
        view_3d();

    void            
        clear_color();

    void            
        clear_depth();

    // rendering ********************

    void        
        render_verts(const vertex_t *verts, ulong count, ushort type);

    void        
        render_quad(const vertex_t *verts);

    void        
        render_line_vec(const vec3_t v1, const vec3_t v2); 

    void        
        render_line2d(float x, float y, float x2, float y2); 

    // 2d functions ***********************

    void        
        draw_pic( float x1, float y1, float x2, float y2, float u1, 
        float v1, float u2, float v2, sshort texture, ushort blendtype);

    void        
        draw_pic_shader(float x1, float y1, float x2, float y2,
        float u1, float v1, float u2, float v2, const shader_t *shader);

    void        
        draw_rotated_pic(float angle, float x1, float y1, float width,
        float height, float u1, float v1, float u2, float v2, 
        sshort texture, ushort blendtype);

    void        
        draw_rotated_pic_shader(float angle, float x1, float y1, 
        float width, float height, float u1, float v1, float u2, float v2, 
        const shader_t *shader);

    void        
        draw_billboard(const vec3_t pos, const vec2_t size, 
        sshort texture, ushort blendtype);

    void        
        draw_billboard_shader(const vec3_t pos, const vec2_t size, 
        const shader_t *shader);

// TODO: _r_draw_axis_billboard 
// TODO: _r_draw_axis_billboard_shader 

    void        
        draw_rotated_billboard(const vec3_t pos, const vec2_t size, float angle,
        sshort texture, ushort blendtype);

    void        
        draw_rotated_billboard_shader(const vec3_t pos, const vec2_t size,
        float angle, const shader_t *shader);

    void        
        draw_lensflares(const lensflare_t *flare, const vec2_t pos, ulong count, float intensity);

    float       
        draw_char(float x, float y, float size, char c, const font_t *fnt); 

    float
        get_stringwidth(const char *c, const font_t *fnt);

    ushort
        get_string_pixelwidth(const char *c, const font_t *fnt);

    void        
        draw_string(float x, float y, float size, const char *c,
        const font_t *fnt, ulong flags);

    // state **********************

    void        
        set_color(color_t color);

    color_t
        get_color() { AssertThisV; return state.currentcolor; };

    void        
        set_blending(ushort blendtype); 

    void        
        set_zbuffer(ushort buftype);

    void        
        set_zwrite(bool enable);

    void        
        set_culling(ushort cullmode);

    void        
        set_fog(bool enable);

    void        
        set_fog_params(float near, float far, color_t color);

    void        
        set_lightmap(sshort i);

    void        
        set_target_texture(sshort n);

    void        
        set_target_backbuffer();

    void
        set_spheremapping(bool enable);

    void
        use_shader(const shader_t *shader);

    void
        set_texture_params(sshort minfilter, sshort magfilter, 
            sshort wrapu, sshort wrapv);

    // fonts **********************
    font_t      *font_createfromimage_fixed(class image_c *img, uchar width);
    void        font_free(font_t *fnt);
};
 
#endif                              // _OMICRONTYPES_RENDER_DEFINED 

/**************************************************************************** 
 **************************************************************************** 
 * FUNCTIONS **************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
// void            _r_update_lights();

color_t     color_from_floats(float r, float g, float b, float a); 

color_t     color_from_vec(const vec4_t in);

void        color_to_vec(color_t color, vec4_t out);

color_t     color_interpolate(color_t color1, color_t color2, float frac);
 

shader_t   *shader_create_simple(ushort blendtype, sshort texture); 


shader_t   *shader_create();
 

void        shader_init(shader_t *shader, ushort blendtype, sshort texture); 
 

void        shader_initstage(shader_t *shad, ushort n); 
 

float       shader_get_waveform_frac(const shader_waveform_t *wf); 

shader_t   *shader_load(const char *fname);
 
/*
sshort          _r_texture_process_compiled // process a compiled texture 
( 
    unsigned char *data, 
    ushort    width, 
    ushort    height 
) 
//Creates a texture and processes a compiled texture (procedural). 
;
*/

---