gfx_types_vertex.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef GFX_TYPES_VERTEX_HH
#define GFX_TYPES_VERTEX_HH 1

namespace gfx {

// Basic types must be fast.  Virtual functions incur overhead from C++ vtable.
#define virtual VIRTUAL_METHODS_IN_BASIC_TYPES_IS_TOO_SLOW

typedef uint16 Vix;
typedef uint16 Nix;  // index of a normal vector

struct Vector2
{
    Vector2( void )
  //:   x(0), y(0)  // would slow STL resize()
    {
        // NOP
    }

    Vector2( fp X, fp Y )
    :   x(X), y(Y)
    {
        // NOP
    }

    explicit Vector2( const fp f[2] )
    :   x(f[XX]), y(f[YY])
    {
        // NOP
    }

    void Set( fp X, fp Y )
    {
        x = X;
        y = Y;
    }

    void Set( const fp f[2] )
    {
        x = f[XX];
        y = f[YY];
    }

    bool operator==( const Vector2& src ) const
    {
        return x == src.x
            && y == src.y;
    }

    bool operator!=( const Vector2& src ) const
    {
        return x != src.x
            || y != src.y;
    }

    Vector2& operator+=( const Vector2& src )
    {
        x += src.x;
        y += src.y;
        return *this;
    }

    Vector2& operator-=( const Vector2& src )
    {
        x -= src.x;
        y -= src.y;
        return *this;
    }

    Vector2& operator*=( const Vector2& src )
    {
        x *= src.x;
        y *= src.y;
        return *this;
    }

    Vector2& operator/=( const Vector2& src )
    {
        x /= src.x;
        y /= src.y;
        return *this;
    }

    void Check( void ) const
    {
        // NOP (typesig omitted).
    }

    fp x;
    fp y;
};

INLINE Vector2 operator+( const Vector2& v1, const Vector2& v2 )
{
    return Vector2( v1.x + v2.x,
                    v1.y + v2.y );
}

INLINE Vector2 operator-( const Vector2& v1, const Vector2& v2 )
{
    return Vector2( v1.x - v2.x,
                    v1.y - v2.y );
}

INLINE Vector2 operator*( const Vector2& v1, const Vector2& v2 )
{
    return Vector2( v1.x * v2.x,
                    v1.y * v2.y );
}
INLINE Vector2 operator/( const Vector2& v1, const Vector2& v2 )
{
    return Vector2( v1.x / v2.x,
                    v1.y / v2.y );
}

INLINE Vector2 operator+( const Vector2& v, fp f )
{
    return Vector2( v.x + f,
                    v.y + f );
}

INLINE Vector2 operator-( const Vector2& v, fp f )
{
    return Vector2( v.x - f,
                    v.y - f );
}

INLINE Vector2 operator*( const Vector2& v, fp f )
{
    return Vector2( v.x * f,
                    v.y * f );
}

INLINE Vector2 operator/( const Vector2& v, fp f )
{
    return Vector2( v.x / f,
                    v.y / f );
}

// Vector2.
INLINE ostream&
operator<<( ostream& strm, const Vector2& v )
{
    ios::fmtflags savedFlags = strm.flags();
    strm << '('
         << OMANIP_FIELD(8) << v.x << ','
         << OMANIP_FIELD(8) << v.y << ')';
    strm.flags(savedFlags);
    return strm;
}

struct Vector3
{
    Vector3( void )
  //:   x(0), y(0), z(0)  // would slow STL resize()
    {
        // NOP
    }

    Vector3( fp X, fp Y, fp Z )
    :   x(X), y(Y), z(Z)
    {
        // NOP
    }

    explicit Vector3( const fp f[3] )
    :   x(f[XX]), y(f[YY]), z(f[ZZ])
    {
        // NOP
    }

    void Set( fp X, fp Y, fp Z )
    {
        x = X;
        y = Y;
        z = Z;
    }

    void Set( const fp f[3] )
    {
        x = f[XX];
        y = f[YY];
        z = f[ZZ];
    }

    bool operator==( const Vector3& src ) const
    {
        return x == src.x
            && y == src.y
            && z == src.z;
    }

    bool operator!=( const Vector3& src ) const
    {
        return x != src.x
            || y != src.y
            || z != src.z;
    }

    Vector3& operator+=( const Vector3& src )
    {
        x += src.x;
        y += src.y;
        z += src.z;
        return *this;
    }

    Vector3& operator-=( const Vector3& src )
    {
        x -= src.x;
        y -= src.y;
        z -= src.z;
        return *this;
    }

    Vector3& operator*=( const Vector3& src )
    {
        x *= src.x;
        y *= src.y;
        z *= src.z;
        return *this;
    }

    Vector3& operator/=( const Vector3& src )
    {
        x /= src.x;
        y /= src.y;
        z /= src.z;
        return *this;
    }

    fp& operator[]( uint i )
    {
    ASSERT( i < 3 );
        return reinterpret_cast<fp*>(&x)[i];
    }

    const fp& operator[]( uint i ) const
    {
    ASSERT( i < 3 );
        return reinterpret_cast<const fp*>(&x)[i];
    }

    // Useful with templates where a Vector3 is a template arg.
    // Check() isn't virtual since Vector3 should be POD.
    void Check( void ) const
    {
        // NOP (typesig omitted).
    }

    fp  x;
    fp  y;
    fp  z;

  //  // prevents EyeVertex being convertible to GLfloat[3]
};

#define VECTOR3 Vector3
#include "gfx_types_vertex_ops.hh"
#undef VECTOR3

struct LocalVertex : public Vector3
{
    LocalVertex( fp X, fp Y, fp Z )
    :   Vector3(X,Y,Z)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_LOCAL);
    }

    explicit LocalVertex( const fp f[3] ) 
    :   Vector3(f)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_LOCAL);
    }

    explicit LocalVertex( const Vector3& v )  // explicit should keep Vertex types distinct
    :   Vector3(v)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_LOCAL);
    }

  //LocalVertex& operator=( const Vector3& src )  // would erode distinct Vertex types

    void Check( void ) const
    {
        CHECK_TYPESIG(this,TYPESIG_VERTEX_LOCAL);
    }

    
};

#define VECTOR3 LocalVertex
#include "gfx_types_vertex_ops.hh"
#undef VECTOR3

struct WorldVertex : public Vector3
{
    WorldVertex( fp X, fp Y, fp Z )
    :   Vector3(X,Y,Z)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_WORLD);
    }

    explicit WorldVertex( const fp f[3] )
    :   Vector3(f)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_WORLD);
    }

    explicit WorldVertex( const Vector3& v )  // explicit should keep Vertex types distinct
    :   Vector3(v)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_WORLD);
    }

  //WorldVertex& operator=( const Vector3& src )  // would erode distinct Vertex types

    void Check( void ) const
    {
        CHECK_TYPESIG(this,TYPESIG_VERTEX_WORLD);
    }

    
};

#define VECTOR3 WorldVertex
#include "gfx_types_vertex_ops.hh"
#undef VECTOR3

struct EyeVertex : public Vector3
{
    EyeVertex( void )
  //:   x(0), y(0), z(0)  // would slow resize()
    {
    }

    EyeVertex( fp X, fp Y, fp Z )
    :   Vector3(X,Y,Z)
    {
    }

    explicit EyeVertex( const fp f[3] )
    :   Vector3(f)
    {
    }

    explicit EyeVertex( const Vector3& v )  // explicit should keep Vertex types distinct
    :   Vector3(v)
    {
    }

  //EyeVertex& operator=( const Vector3& src )  // would erode distinct Vertex types

    void Check( void ) const
    {
        // NOP (typesig omitted).
    }

  //  // EyeVertex be convertible to GLfloat[3]
};

#define VECTOR3 EyeVertex
#include "gfx_types_vertex_ops.hh"
#undef VECTOR3

struct NormalVertex : public Vector3
{
    NormalVertex( fp X, fp Y, fp Z )
    :   Vector3(X,Y,Z)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_NORMAL);
    }

    explicit NormalVertex( const fp f[3] )
    :   Vector3(f)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_NORMAL);
    }

    explicit NormalVertex( const Vector3& v )  // explicit should keep Vertex types distinct
    :   Vector3(v)
    {
        SET_TYPESIG(this,TYPESIG_VERTEX_NORMAL);
    }

    void Check( void ) const
    {
        CHECK_TYPESIG(this,TYPESIG_VERTEX_NORMAL);
    }

    
};

#define VECTOR3 NormalVertex
#include "gfx_types_vertex_ops.hh"
#undef VECTOR3

// Array typedefs.
// Plural "s" ending is terse albeit easy to mistype.
//
// [2007/03] Matrix class expects vertex arrays to be based on Array template class.
// A possible future optimization is the template specialization Array<EyeVertexs>
// which would reuse a pre-allocated array.  But it may cause trouble.
//
typedef Array<LocalVertex>  LocalVertexs;
typedef Array<WorldVertex>  WorldVertexs;
typedef Array<EyeVertex>    EyeVertexs;
typedef Array<NormalVertex> NormalVertexs;
typedef Array<Vix>          Vixs;  // array of vertex indexs

#undef virtual

} // namespace gfx

#endif // GFX_TYPES_VERTEX_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:11 2007