gfxlib_struct.h

Go to the documentation of this file.

/*
 * Vega Strike
 * Copyright (C) 2001-2002 Daniel Horn
 *
 * http://vegastrike.sourceforge.net/
 *
 * This program 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.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef _GFXLIB_STRUCT
#define _GFXLIB_STRUCT
#include "gfx/vec.h"
#include "endianness.h"

#ifndef GFXBOOL
#define GFXBOOL unsigned char
#endif
#define GFXTRUE 1
#define GFXFALSE 0

const int INDEX_BYTE     = sizeof (unsigned char);
const int INDEX_SHORT    = sizeof (unsigned short);
const int INDEX_INT      = sizeof (unsigned int);
const int CHANGE_MUTABLE = (sizeof (unsigned int)*2);
const int CHANGE_CHANGE  = (sizeof (unsigned int)*4);
const int HAS_COLOR      = (sizeof (unsigned int)*8);
#define USE_DISPLAY_LISTS
const int HAS_INDEX      = sizeof (unsigned char)|sizeof (unsigned short)|sizeof (unsigned int);

extern int /*GFXDRVAPI*/ GFXCreateList();
extern GFXBOOL /*GFXDRVAPI*/ GFXEndList();
extern void /*GFXDRVAPI*/ GFXDeleteList( int list );

struct GFXVertex
{
    //Texcoord
    float s;
    float t;

    //Normal
    float i;
    float j;
    float k;

    //Position
    float x;
    float y;
    float z;

    //Tangent
    float tx;
    float ty;
    float tz;
    float tw;

    GFXVertex() {}
    GFXVertex( const QVector &vert, const Vector &norm, float s, float t )
    {
        SetVertex( vert.Cast() );
        SetNormal( norm );
        SetTexCoord( s, t );
    }
    GFXVertex( const Vector &vert, const Vector &norm, float s, float t )
    {
        SetVertex( vert );
        SetNormal( norm );
        SetTexCoord( s, t );
    }
    GFXVertex( float x, float y, float z, float i, float j, float k, float s, float t )
    {
        this->x = x;
        this->y = y;
        this->z = z;
        this->i = i;
        this->j = j;
        this->k = k;
        this->s = s;
        this->t = t;
    }
    GFXVertex& SetTexCoord( float s, float t )
    {
        this->s = s;
        this->t = t;
        return *this;
    }
    GFXVertex& SetNormal( const Vector &norm )
    {
        i = norm.i;
        j = norm.j;
        k = norm.k;
        return *this;
    }
    GFXVertex& SetVertex( const Vector &vert )
    {
        x = vert.i;
        y = vert.j;
        z = vert.k;
        return *this;
    }
    GFXVertex& SetTangent( const Vector &tgt, float parity = 1.f )
    {
        tx = tgt.x;
        ty = tgt.y;
        tz = tgt.z;
        tw = parity;
        return *this;
    }
    Vector GetVertex() const
    {
        return Vector( x, y, z );
    }
    const Vector& GetConstVertex() const
    {
        return *( (Vector*) &x );
    }
    Vector GetNormal() const
    {
        return Vector( i, j, k );
    }
    Vector GetPosition() const
    {
        return Vector( x, y, z );
    }
    Vector GetTangent() const
    {
        return Vector( tx, ty, tz );
    }
    float GetTangentParity() const
    {
        return tw;
    }
};

//Stores a color (or any 4 valued vector)
struct GFXColor
{
    float r;
    float g;
    float b;
    float a;
    GFXColor() {}
    GFXColor( const Vector &v, float a = 1.0 )
    {
        this->r = v.i;
        this->g = v.j;
        this->b = v.k;
        this->a = a;
    }
    GFXColor( float r, float g, float b )
    {
        this->r = r;
        this->g = g;
        this->b = b;
        this->a = 1.0;
    }

    GFXColor( float r, float g, float b, float a )
    {
        this->r = r;
        this->g = g;
        this->b = b;
        this->a = a;
    }
    void netswap()
    {
        this->r = VSSwapHostFloatToLittle( this->r );
        this->g = VSSwapHostFloatToLittle( this->g );
        this->b = VSSwapHostFloatToLittle( this->b );
        this->a = VSSwapHostFloatToLittle( this->a );
    }

    GFXColor clamp() const
    {
        return GFXColor( ( (r < 0) ? 0 : ( (r > 1) ? 1 : r ) ), ( (g < 0) ? 0 : ( (g > 1) ? 1 : g ) ),
                        ( (b < 0) ? 0 : ( (b > 1) ? 1 : b ) ), ( (a < 0) ? 0 : ( (a > 1) ? 1 : a ) ) );
    }
};

inline GFXColor operator*( float s, const GFXColor &c )
{
    return GFXColor( s*c.r, s*c.g, s*c.b, s*c.a );
}
inline GFXColor operator*( const GFXColor &c, float s )
{
    return GFXColor( s*c.r, s*c.g, s*c.b, s*c.a );
}
inline GFXColor operator+( const GFXColor &c0, const GFXColor &c1 )
{
    return GFXColor( c0.r+c1.r, c0.g+c1.g, c0.b+c1.b, c0.a+c1.a );
}
inline GFXColor operator-( const GFXColor &c0, const GFXColor &c1 )
{
    return GFXColor( c0.r-c1.r, c0.g-c1.g, c0.b-c1.b, c0.a-c1.a );
}

struct GFXColorVertex
{
    //Texcoord
    float s;
    float t;

    //Color
    float r;
    float g;
    float b;
    float a;

    //Normal
    float i;
    float j;
    float k;

    //Position
    float x;
    float y;
    float z;

    //Tangent
    float tx;
    float ty;
    float tz;
    float tw;

    GFXColorVertex() {}
    GFXColorVertex( const Vector &vert, const Vector &norm, const GFXColor &rgba, float s, float t )
    {
        SetVertex( vert );
        SetNormal( norm );
        SetColor( rgba );
        SetTexCoord( s, t );
    }
    GFXColorVertex( float x, float y, float z, float i, float j, float k, float r, float g, float b, float a, float s, float t )
    {
        this->x = x;
        this->y = y;
        this->z = z;
        this->i = i;
        this->j = j;
        this->k = k;
        this->r = r;
        this->g = g;
        this->b = b;
        this->a = a;
        this->s = s;
        this->t = t;
    }
    GFXColorVertex& SetTexCoord( float s, float t )
    {
        this->s = s;
        this->t = t;
        return *this;
    }
    GFXColorVertex& SetNormal( const Vector &norm )
    {
        i = norm.i;
        j = norm.j;
        k = norm.k;
        return *this;
    }
    GFXColorVertex& SetVertex( const Vector &vert )
    {
        x = vert.i;
        y = vert.j;
        z = vert.k;
        return *this;
    }
    GFXColorVertex& SetColor( const GFXColor &col )
    {
        r = col.r;
        g = col.g;
        b = col.b;
        a = col.a;
        return *this;
    }
    GFXColorVertex& SetTangent( const Vector &tgt, float parity = 1.f )
    {
        tx = tgt.x;
        ty = tgt.y;
        tz = tgt.z;
        tw = parity;
        return *this;
    }
    Vector GetNormal() const
    {
        return Vector( i, j, k );
    }
    Vector GetPosition() const
    {
        return Vector( x, y, z );
    }
    void SetVtx( const GFXVertex &vv )
    {
        s = vv.s;
        t = vv.t;
        i = vv.i;
        j = vv.j;
        k = vv.k;
        x = vv.x;
        y = vv.y;
        z = vv.z;
    }

    Vector GetTangent() const
    {
        return Vector( tx, ty, tz );
    }
    float GetTangentParity() const
    {
        return tw;
    }
};

enum LIGHT_TARGET
{
    ATTENUATE=1,
    DIFFUSE  =2,
    SPECULAR =4,
    AMBIENT  =8,
    POSITION =16,
    EMISSION =32
};

class GFXLight
{
public:
    int   target;
    float vect[3];
    int   options;
    float diffuse[4];
    float specular[4];
    float ambient[4];
    float attenuate[3];
    float direction[3];
    float exp;
    float cutoff;
    float size;
    
public: 
    GFXLight()
    {
        //vect[0]=vect[1]=vect[2]=vect[3]=0;
        vect[0] = vect[1] = vect[2] = 0;
        attenuate[0] = 1;
        attenuate[1] = attenuate[2] = 0;
        diffuse[0]   = diffuse[1] = diffuse[2] = 0; //openGL defaults
        specular[0]  = specular[1] = specular[2] = 0; //openGL defaults
        ambient[0]   = ambient[1] = ambient[2] = options = 0;
        diffuse[3]   = specular[3] = ambient[3] = 1;
        target = -1; //physical GL light its saved in

        direction[0] = direction[1] = direction[2] = 0.0;
        exp = 0.0f;
        cutoff = 180.0f;
        size = 0.0f;
    }

    GFXLight( const bool enabled, const GFXColor &vect, 
              const GFXColor &diffuse = GFXColor( 0, 0, 0, 1 ), 
              const GFXColor &specular = GFXColor( 0, 0, 0, 1 ), 
              const GFXColor &ambient = GFXColor( 0, 0, 0, 1 ), 
              const GFXColor &attenuate = GFXColor( 1, 0, 0 ), 
              const GFXColor &direction = GFXColor( 0, 0, 0 ), 
              float exp = 0.0f, 
              float cutoff = 180.0f,
              float size = 0.0f );

    void SetProperties( enum LIGHT_TARGET, const GFXColor &color );
    GFXColor GetProperties( enum LIGHT_TARGET ) const;
    
    void setSize(float size_) { size = size_; }
    float getSize() const { return size; }
    
    Vector getPosition() const { return Vector(vect[0], vect[1], vect[2]); }
    
    void disable();
    void enable();
    bool attenuated() const;
    void apply_attenuate( bool attenuated );
};
struct GFXTVertex //transformed vertex
{
    float x;
    float y;
    float z;
    float rhw;
    int   diffuse;
    int   specular;
    float s, t;
    float u, v;
};

struct GFXLightLocal
{
    GFXLight ligh;
    bool     islocal;
};

enum POLYTYPE
{
    GFXTRI,
    GFXQUAD,
    GFXLINE,
    GFXTRISTRIP,
    GFXQUADSTRIP,
    GFXTRIFAN,
    GFXLINESTRIP,
    GFXPOLY,
    GFXPOINT
};

enum POLYMODE
{
    GFXPOINTMODE,
    GFXLINEMODE,
    GFXFILLMODE
};

enum POLYFACE
{
    GFXFRONT,
    GFXBACK,
    GFXFRONTANDBACK
};

class /*GFXDRVAPI*/ GFXQuadList
{
    int  numVertices;
    int  numQuads;
    int *quadassignments;
    union VCDAT
    {
        GFXVertex *vertices;
        GFXColorVertex *colors;
    }
    data;
    GFXBOOL isColor;
    int     Dirty;
public:
    GFXQuadList( GFXBOOL color = GFXFALSE );
    ~GFXQuadList();
    void Draw();
    int AddQuad( const GFXVertex *vertices, const GFXColorVertex *colors = 0 );
    void DelQuad( int which );
    void ModQuad( int which, const GFXVertex *vertices, float alpha = -1 );
    void ModQuad( int which, const GFXColorVertex *vertices );
};

class /*GFXDRVAPI*/ GFXVertexList
{
    friend class GFXSphereVertexList;
protected:
    const GFXVertex * GetVertex( int index ) const;
    const GFXColorVertex * GetColorVertex( int index ) const;
    int numVertices;
    union VDAT
    {
        GFXVertex *vertices;
        GFXColorVertex *colors;
        VDAT() : vertices(0) {};
    }
    data;
    union INDEX
    {
        unsigned char  *b; //stride 1
        unsigned short *s; //stride 2
        unsigned int   *i; //stride 4
        INDEX() : i(0) {};
    }
    index;
    enum POLYTYPE *mode;
    bool unique_mode; //See Draw()
    int  display_list; //doubles as vbo_elements
    int  vbo_data;
    int  numlists;
    int *offsets;
    char changed;
    static void VtxCopy( GFXVertexList *thus, GFXVertex *dst, int offset, int howmany );
    static void ColVtxCopy( GFXVertexList *thus, GFXVertex *dst, int offset, int howmany );
    static void ColIndVtxCopy( GFXVertexList *thus, GFXVertex *dst, int offset, int howmany );
    static void IndVtxCopy( GFXVertexList *thus, GFXVertex *dst, int offset, int howmany );
    void Init( enum POLYTYPE *poly,
               int numVertices,
               const GFXVertex *vert,
               const GFXColorVertex *colors,
               int numlists,
               int *offsets,
               bool Mutable,
               unsigned int *indices );
public:
    void RefreshDisplayList();
protected:
    virtual void Draw( enum POLYTYPE *poly, const INDEX index, const int numLists, const int *offsets );
    void RenormalizeNormals();
    GFXVertexList();
public:
    inline GFXVertexList( enum POLYTYPE poly,
                          int numVertices,
                          const GFXVertex *vertices,
                          int numindices,
                          bool Mutable = false,
                          unsigned int *index = 0 )
    {
        Init( &poly, numVertices, vertices, 0, 1, &numindices, Mutable, index );
    }
    inline GFXVertexList( enum POLYTYPE *poly,
                          int numVertices,
                          const GFXVertex *vertices,
                          int numlists,
                          int *offsets,
                          bool Mutable = false,
                          unsigned int *index = 0 )
    {
        Init( poly, numVertices, vertices, 0, numlists, offsets, Mutable, index );
    }
    inline GFXVertexList( enum POLYTYPE poly,
                          int numVertices,
                          const GFXColorVertex *colors,
                          int numindices,
                          bool Mutable = false,
                          unsigned int *index = 0 )
    {
        Init( &poly, numVertices, 0, colors, 1, &numindices, Mutable, index );
    }
    inline GFXVertexList( enum POLYTYPE *poly,
                          int numVertices,
                          const GFXColorVertex *colors,
                          int numlists,
                          int *offsets,
                          bool Mutable = false,
                          unsigned int *index = 0 )
    {
        Init( poly, numVertices, 0, colors, numlists, offsets, Mutable, index );
    }
    virtual ~GFXVertexList();
    virtual int numTris() const;
    virtual int numQuads() const;
    unsigned int GetIndex( int offset ) const;
    POLYTYPE *GetPolyType() const;
    int *GetOffsets() const;
    int GetNumLists() const;
    bool hasColor() const;

    int GetNumVertices() const
    {
        return numVertices;
    }
    virtual VDAT * Map( bool read, bool write );
    void UnMap();
    virtual VDAT * BeginMutate( int offset );
    virtual void EndMutate( int newsize = 0 );
    void LoadDrawState();
    virtual void BeginDrawState( GFXBOOL lock = GFXTRUE );
    virtual void Draw();
    void Draw( enum POLYTYPE poly, int numV );
    void Draw( enum POLYTYPE poly, int numV, unsigned char *index );
    void Draw( enum POLYTYPE poly, int numV, unsigned short *index );
    void Draw( enum POLYTYPE poly, int numV, unsigned int *index );
    void DrawOnce();
    virtual void EndDrawState( GFXBOOL lock = GFXTRUE );
    virtual void GetPolys( GFXVertex **vert, int *numPolys, int *numTris );
};

class /*GFXDRVAPI*/ GFXSphereVertexList : public GFXVertexList
{
protected:
    float radius;
    GFXVertexList *sphere;
    virtual void Draw( enum POLYTYPE *poly, const INDEX index, const int numLists, const int *offsets );
public:
    GFXSphereVertexList( float radius, int detail, bool insideout, bool reverse_normals );
    ~GFXSphereVertexList();

    virtual VDAT * BeginMutate( int offset );
    virtual void EndMutate( int newsize = 0 );
    virtual void BeginDrawState( GFXBOOL lock = GFXTRUE );
    virtual void Draw();
    virtual void EndDrawState( GFXBOOL lock = GFXTRUE );
    virtual void GetPolys( GFXVertex **vert, int *numPolys, int *numTris );
    virtual void ProceduralModification();
};

struct GFXMaterial
{
    float ar;
    float ag;
    float ab;
    float aa;
    float dr;
    float dg;
    float db;
    float da;
    float sr;
    float sg;
    float sb;
    float sa;
    float er;
    float eg;
    float eb;
    float ea;
    float power;
};
//Textures may only be cube maps, Texture1d, Texture2d or Texture3d
enum TEXTURE_TARGET
{
    TEXTURE1D,
    TEXTURE2D,
    TEXTURE3D,
    CUBEMAP,
    TEXTURERECT
};
enum TEXTURE_IMAGE_TARGET
{
    TEXTURE_1D,
    TEXTURE_2D,
    TEXTURE_3D,
    CUBEMAP_POSITIVE_X,
    CUBEMAP_NEGATIVE_X,
    CUBEMAP_POSITIVE_Y,
    CUBEMAP_NEGATIVE_Y,
    CUBEMAP_POSITIVE_Z,
    CUBEMAP_NEGATIVE_Z,
    TEXTURE_RECTANGLE
};

enum MATRIXMODE
{
    MODEL,
    PROJECTION,
    VIEW
};

enum TEXTUREFORMAT
{
    DUMMY=0,
    PALETTE8   =1,
    RGB16      =2,
    RGBA16     =3,
    RGB24      =4,
    RGBA32     =5,
    RGB32      =6,
    DXT1       =7,
    DXT1RGBA   =8,
    DXT3       =9,
    DXT5       =10,
    PNGPALETTE8=11,
    PNGRGB24   =12,
    PNGRGBA32  =13
};
enum STATE
{
    LIGHTING,
    DEPTHTEST,
    DEPTHWRITE,
    COLORWRITE,
    TEXTURE0,
    TEXTURE1,
    CULLFACE,
    SMOOTH,
    STENCIL
};

enum CLIPSTATE
{
    GFX_NOT_VISIBLE,
    GFX_PARTIALLY_VISIBLE,
    GFX_TOTALLY_VISIBLE
};

enum ADDRESSMODE
{
    WRAP,
    MIRROR,
    CLAMP,
    BORDER,
    DEFAULT_ADDRESS_MODE
};

enum FOGMODE
{
    FOG_OFF,
    FOG_EXP,
    FOG_EXP2,
    FOG_LINEAR
};
enum BLENDFUNC
{
    ZERO=1,
    ONE=2,
    SRCCOLOR=3,
    INVSRCCOLOR  =4,
    SRCALPHA     =5,
    INVSRCALPHA  =6,
    DESTALPHA    =7,
    INVDESTALPHA =8,
    DESTCOLOR    =9,
    INVDESTCOLOR =10,
    SRCALPHASAT  =11,
    CONSTALPHA   =12,
    INVCONSTALPHA=13,
    CONSTCOLOR   =14,
    INVCONSTCOLOR=15
};

enum FILTER
{
    NEAREST  =0x0,
    BILINEAR =0x1,
    MIPMAP   =0x2,
    TRILINEAR=0x4
};

enum DEPTHFUNC
{
    NEVER, LESS, EQUAL, LEQUAL, GREATER, NEQUAL, GEQUAL, ALWAYS
};

enum STENCILOP
{
    KEEP, CLEAR, REPLACE, INCR, DECR, INVERT
};

struct PickData
{
    int   name;
    int   zmin;
    int   zmax;

    PickData( int name, int zmin, int zmax ) : name( name )
        , zmin( zmin )
        , zmax( zmax ) {}
};

#endif