VRS - The Virtual Rendering System

version 3.3

config.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2008 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  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 Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

#ifndef VRS_CONFIG_H
#define VRS_CONFIG_H

//
// About this vrs version
//
#define VRS_VERSION 0x040000
#define VRS_MAJOR_VERSION 4
#define VRS_MINOR_VERSION 0
#define VRS_PATCH_VERSION 0

//
// Plattform specific settings
//

// WINDOWS
#if defined(WIN32) || defined(WIN64)

#define VRS_HAS_WSTRING


// dll import/export
#ifdef VRS_CORE_EXPORTS
# define VRS_CORE_API __declspec(dllexport)
#else // VRS_CORE_EXPORTS
# define VRS_CORE_API __declspec(dllimport)
#endif // VRS_CORE_EXPORTS


// automatic linkage with release- or debug-lib
#ifndef VRS_CORE_EXPORTS
# ifdef NDEBUG
#  pragma comment(lib, "vrs_core.lib") /* link with vrs lib */
# else // NDEBUG
#  pragma comment(lib, "vrs_core_debug.lib") /* link with vrs lib in debug mode */
# endif //NDEBUG
#endif // VRS_CORE_EXPORTS


#ifdef _MSC_VER // microsoft visual studio compiler

# pragma warning(disable: 4251) // class X needs to have dll-interface to be used by clients of class Y
# pragma warning(disable: 4275) // non dll-interface class X used as base for dll-interface class Y
# pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
# pragma warning(disable: 4786) // identifier was truncated to X characters in the debug information
# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false' (performance warning)
# pragma warning(disable: 4996) // function call with parameters that may be unsafe 

#endif //_MSC_VER

#endif // WIN32 || WIN64

//
// UNIX & LINUX
//
#ifndef WIN32
# define VRS_CORE_API
# define VRS_HAS_WSTRING
# include <vrs/autoconf.h>
# include <cstring>
#endif // WIN32


//
// Endian
//
#ifndef VRS_WORDS_BIGENDIAN
# define VRS_HAS_LITTLE_ENDIAN 1
#else // VRS_WORDS_BIGENDIAN
# define VRS_HAS_BIG_ENDIAN 1
#endif // VRS_WORDS_BIGENDIAN


#ifndef M_PI
# define M_PI 3.14159265358979323846
#endif // M_PI

#include <iostream>
#include <string>



//
// macro VRS_ANONYMOUS_IDENTIFIER() generates a unique identifier
// (use it inside of an unnamed namespace)
//
#define VRS_CONCATENATE_DIRECT(STR_A, STR_B) STR_A##STR_B
#define VRS_CONCATENATE(STR_A, STR_B) VRS_CONCATENATE_DIRECT(STR_A, STR_B)
#ifdef _MSC_VER  // Necessary for edit & continue in MS Visual C++.
# define VRS_ANONYMOUS_IDENTIFIER(str) VRS_CONCATENATE(str, __COUNTER__)
#else // _MSC_VER
# define VRS_ANONYMOUS_IDENTIFIER(str) VRS_CONCATENATE(str, __LINE__)
#endif // _MSC_VER


// Localization:
// Macros for the "lupdate" tool of Qt to find strings to be translated by the "Qt Linguist"
// that are not defined inside the scope of 'QObject'.
#define QT_TR_NOOP(x) (x)
#define QT_TRANSLATE_NOOP(scope,x) (x)


namespace VRS {

//
// Mathematical constants
//
const double INF = 1e42;
const double deg2rad = (M_PI / 180.0);
const double rad2deg = (180.0 / M_PI);

//
// Version
//
const unsigned int Version      = VRS_VERSION;
const unsigned int MinorVersion = VRS_MINOR_VERSION;
const unsigned int MajorVersion = VRS_MAJOR_VERSION;
const unsigned int PatchVersion = VRS_PATCH_VERSION;

typedef unsigned char  UCHAR;
typedef unsigned short USHORT;
typedef unsigned int   UINT;
typedef unsigned long  ULONG;

typedef unsigned char  UINT8;
typedef char           INT8;
typedef unsigned short UINT16;
typedef short          INT16;
        
typedef unsigned int   UINT32;
typedef int            INT32;

#ifdef WIN32

# ifndef VRS_HAS_INT64
#  define VRS_HAS_INT64
# endif // VRS_HAS_INT64

    typedef unsigned __int64 UINT64;
    typedef __int64          INT64;

#else // WIN32

// must be adjusted for different compilers!!!
# ifndef VRS_HAS_INT64
#  define VRS_HAS_INT64
# endif // VRS_HAS_INT64

    // for gcc:
        #ifdef __LP64__
          typedef unsigned long int UINT64;
      typedef long int          INT64;
    #else
          typedef unsigned long long int UINT64;
          typedef long long int          INT64;
    #endif
        
#endif // WIN32

// test for endianess: ENDIAN.IS.BIG or ENDIAN.IS.LITTLE
const union {
    USHORT dummy;
    struct { UCHAR LITTLE, BIG; } IS;
} ENDIAN = { 1 };

// static assert implementation
template<bool x> struct STATIC_ASSERTION_FAILURE;
template<> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
template<int x> struct static_assert_test { };
#define VRS_STATIC_ASSERT(B) \
    typedef VRS::static_assert_test<\
        sizeof(VRS::STATIC_ASSERTION_FAILURE<(bool)(B)>)\
    > VRS_ANONYMOUS_IDENTIFIER(vrs_static_assert_typedef_)

} // namespace VRS

// memory leak detection

#include <vrs/memoryleakdetector.h>

#if !defined(NDEBUG) && defined(WIN32) && !defined(VRS_NO_MEM_LEAK_DETECTOR)

// redefine new/delete for tracking memory leaks during a debug session
inline void* operator new     (size_t size)   { return VRS::MemoryLeakDetector::alloc(size); }
inline void* operator new[]   (size_t size)   { return VRS::MemoryLeakDetector::alloc(size); }
inline void  operator delete  (void* pointer) { VRS::MemoryLeakDetector::dealloc(pointer);   }
inline void  operator delete[](void* pointer) { VRS::MemoryLeakDetector::dealloc(pointer);   }

#endif // !NDEBUG && WIN32 && !VRS_NO_MEM_LEAK_DETECTOR

#include <vrs/errorhandler.h>

// define macros for std::string to std::wstring conversion and vice versa...
#define VRS_S2W(str) VRS::StringUtils::String2WString(str)
#define VRS_W2S(str) VRS::StringUtils::WString2String(str)

#endif // VRS_CONFIG_H

---

Generated on Mon May 20 06:00:20 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact