Definitions.h

Go to the documentation of this file.

/* $Id: Definitions.h,v 1.4 2002/11/05 14:31:15 anonymous Exp $ */

#ifndef __DEFINITIONS_H
#define __DEFINITIONS_H

#ifdef WIN32
#include <wtypes.h>
#undef max
#endif

#include <vecmath/Vector4d.h>
#include <vecmath/Vector4f.h>
#include <vecmath/Vector3f.h>
#include <vecmath/Vector3d.h>
#include <vecmath/Vector2f.h>
#include <vecmath/Vector2d.h>
#include <vecmath/Matrix3f.h>
#include <vecmath/Matrix4f.h>
#include <vecmath/Matrix3d.h>
#include <vecmath/Matrix4d.h>
#include <vecmath/Color3f.h>

//#if defined(_MSC_VER)
#include <float.h>
#define MAXFLOAT FLT_MAX
#define MAXDOUBLE DBL_MAX
#define MINDOUBLE DBL_MIN
//#else
//#include <values.h>
//#endif

#include <math.h>
#include <typeinfo>
#include <stack>

#include <esg/Export>

#if defined(WIN32) && !defined(__MINGW32__) 
#  include <hash_map>       
     namespace Sgi = std; 
#else 
#  if (__GNUC__ < 3) 
#    include <hash_map> 
    namespace Sgi { using ::hash_map; }; /* inherit globals */ 
#  else 
#    include <ext/hash_map> 
#    if (__GNUC__ == 3 && __GNUC_MINOR__ == 0) 
    namespace Sgi = std;                 /* GCC 3.0 */ 
#    else 
    namespace Sgi = ::__gnu_cxx;         /* GCC 3.1 and later */ 
#    endif 
#  endif 
#endif 

using namespace std;


namespace esg {

class OGSCENE_EXPORT SceneGraphObject; // declaration

typedef Vector4d Vector4;
typedef Vector3d Vector3;
typedef Vector3d Vertex3;
typedef Vector2d Vector2;
typedef Vector2d Vertex2;
typedef Matrix3d Matrix3;
typedef Matrix4d Matrix4;
typedef double   ESGfloat;
typedef int      ESGbitmask;
typedef int      ESGint;

#define ESG_MAXFLOAT  MAXDOUBLE
#define ESG_MINFLOAT -MAXDOUBLE

#define MAX_VEC_VALUE  MAXFLOAT
#define MIN_VEC_VALUE -MAXFLOAT

#ifndef MAXUNSIGNED
#define MAXUNSIGNED UINT_MAX
#endif
#ifndef MINUNSIGNED
#define MINUNSIGNED UINT_MIN
#endif

#ifndef PI
#define PI M_PI
#endif


struct Cache {
    virtual ~Cache() {}
};


struct Interval {
    float min;
    float max;

#ifdef WIN32
    Interval (float a = MAXFLOAT, float b = -MAXFLOAT) { min = a; max = b; }
    Interval (const Interval& src) { min = src.min; max = src.max; }
#else
    Interval (float a = MAXFLOAT, float b = -MAXFLOAT) : min(a), max(b) {}
    Interval (const Interval& src) : min(src.min), max(src.max) {}
#endif
};


#define IS_INSTANCE_OF(a,b) (typeid(a) == typeid(b))

    /*
     * Macros for ray transformation
     */

#define ESG_INVERSE_TR_RAY(rMat,tVec,sVec,srcO,dstO,srcD,dstD) {\
    (rMat).transpose(); \
    (rMat).transform(srcD, dstD); \
    (dstO).sub(srcO, tVec);   /* origin = (R^T * origin) - (R^T * tr) = */ \
    (rMat).transform(dstO);   /*        = R^T * (origin - tr)           */ \
    if ((sVec).x) (dstO).x *= 1.0 / (sVec).x; \
    if ((sVec).y) (dstO).y *= 1.0 / (sVec).y; \
    if ((sVec).z) (dstO).z *= 1.0 / (sVec).z; }

#define ESG_INVERSE_TR_POINT(rMat, tVec, sVec, srcP, dstP) { \
    (rMat).transpose(); \
    (dstP).sub(srcP, tVec); \
    (rMat).transform(dstP); \
    if ((sVec).x) (dstP).x *= 1.0 / (sVec).x; \
    if ((sVec).y) (dstP).y *= 1.0 / (sVec).y; \
    if ((sVec).z) (dstP).z *= 1.0 / (sVec).z; }

#define ESG_INVERSE_TR_DIR(rMat, srcD, dstD) { \
    (rMat).transpose(); \
    (rMat).transform(srcD, dstD); }

    /*
     * Random number generators
     */
    //#define ESG_INIT_RAND()  { srand((unsigned int) time(NULL)); }
    //#define ESG_DBL_RAND_H   ((double)(    (double)rand()/(RAND_MAX + 1.0)))//[0,1)
    //#define ESG_DBL_RAND_F   ((double)(    (double)rand()/(double)RAND_MAX))//[0,1]
    //#define ESG_INT_RAND_H(x)((int)   ((x)*(double)rand()/(RAND_MAX + 1.0)))//[0,x)
    //#define ESG_INT_RAND_F(x)((int)   ((x)*(double)rand()/(double)RAND_MAX))//[0,x]
    
#define ESG_INIT_RAND() { srand((long int) time(NULL)); }

#ifdef WIN32
#define ESG_DBL_RAND ((double)((double)rand()/(RAND_MAX + 1.0))) //[0,1)
#else
#define ESG_DBL_RAND ((double)drand48()) //[0,1)
#endif
    
#define ESG_INT_RAND(x) ((int)((x)*(double)rand()/(RAND_MAX + 1.0))) //[0,x)

    
    /*
     * Portable gaussian random number generator
     * (from "Numerical Recipes", GASDEV)
     * Returns a uniform random deviate between 0.0 and 1.0.  'iseed' must be
     * less than M1 to avoid repetition, and less than (2**31-C1)/A1 [= 300718]
     * to avoid overflow.
     */
#define ESG_M1  134456
#define ESG_IA1   8121
#define ESG_IC1  28411
#define ESG_RM1 1.0/ESG_M1

#define ESG_GAUSS_RAND(/*long*/ iseed, ret) { \
    double v1, v2, r; \
    long   ix1 = 0; \
    long   ix2 = (iseed); \
    do { \
        ix1 = (ESG_IC1 + ix2 * ESG_IA1) % ESG_M1; \
        ix2 = (ESG_IC1 + ix1 * ESG_IA1) % ESG_M1; \
        v1  = ix1 * 2.0 * ESG_RM1 - 1.0; \
        v2  = ix2 * 2.0 * ESG_RM1 - 1.0; \
        r   = v1 * v1 + v2 * v2; \
    } while (r >= 1.0); \
    ret = v1 * sqrt((double)(-2.0 * log((double)r) / r)); \
}

    /*
     * Bob Jenkins invented this great, reasonably fast, very nice
     * hash function.  Check out his web page:
     * http://ourworld.compuserve.com/homepages/bob_jenkins/blockcip.htm
     */
#define ESG_HASH_RAND(/*int*/ _a, /*int*/ _b, /*int*/ _c, ret) { \
    int a = _a; \
    int b = _b; \
    int c = _c; \
    a -= b; a -= c; a ^= (c>>13); \
    b -= c; b -= a; b ^= (a<<8);  \
    c -= a; c -= b; c ^= (b>>13); \
    a -= b; a -= c; a ^= (c>>12); \
    b -= c; b -= a; b ^= (a<<16); \
    c -= a; c -= b; c ^= (b>>5);  \
    a -= b; a -= c; a ^= (c>>3);  \
    b -= c; b -= a; b ^= (a<<10); \
    c -= a; c -= b; c ^= (b>>15); \
    ret = c & 0xffff ; \
}


}; // namespace

#endif // __DEFINITIONS_H

---