common.h

Go to the documentation of this file.

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 5 -*- */

/*
 * Combination of a first person action and a real time strategy battle game.
 */

/*
 * common.h
 * MetalWarriors
 * $Revision: 1.32 $
 *
 * Created by Daniel Aarno on Sun Oct 12 2003.
 * Copyright (c) 2003 Daniel Aarno and Erik Ytterberg - All rights reserved.
 *
 * 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 _COMMON_
#define _COMMON_

//Project headers
#include "ActionMenu.h"
#include "ResourceHandler.h"
#include "GLText.h"

//System headers
#include <cmath>
#include <string>
#include <list>
#include <vector>

//Forward declarations
class Camera;
class Player;
class Hud;
class Terrain;
class Sprite;
class SensitiveSprite;
class SoundHandler;

//Used for more efficient sqrt computations
extern float *g_sqrtTable;
static const char FAST_SQRT_MAX = 5;
static const float FAST_SQRT_STEP = 0.01f;
template<typename T>
inline float FAST_SQRT_UNSAFE(const T &f) {
     int idx = static_cast<int>(f / FAST_SQRT_STEP);
     return g_sqrtTable[idx];
}
template<typename T>
inline float FAST_SQRT(const T &f) {
  return f < FAST_SQRT_MAX ? FAST_SQRT_UNSAFE(f) : sqrt(f);
}
template<typename T>
inline T  SQR(const T &a) { return a*a; }

template<typename T>
inline T POW2(const T &a) { return SQR(a); }

template<typename T>
inline double Deg2Rad(const T &deg) { return deg*M_PI/180.0; }

template<typename T>
inline double Rad2Deg(const T &rad) { return rad*180.0/M_PI; }

template<typename T>
inline void NormalizeDeg(T &deg) {
     while(deg < 180) 
          deg += 360; 
     while(deg > 180) 
          deg -= 360;
}

template<typename T>
inline void NormalizeRad(T &rad) {
     while(rad < M_PI) 
          rad += 2*M_PI; 
     while(rad > M_PI)
          rad -= 2*M_PI;
}

template<typename T> 
inline T Abs(const T &a) { return a < 0 ? -a : a; }

template<typename T>
inline T AbsMin(const T &a, const T &b) { return Abs(a) < Abs(b) ? a : b; }

typedef std::list<Sprite*> SpriteList;
typedef SpriteList::iterator SpriteIterator;

typedef struct {
  Player *player;   
  int fpsRef;       
  float trueFps;    
  Camera *camera;   
  Hud *hud;             
  Terrain *terrain; 

  std::vector< Player* > playerList;
  std::list< Sprite* > sprites;    
  std::list< Sprite* > transparentSprites;
  std::list<Sprite*> updateSprites;
  //list of all transparent sprites that needs to be updated
  std::list<Sprite*> updateTransSprites;
  bool fullScreen;
  
  ResourceHandler resourceHandler;
  SoundHandler *sh;
  GLText glText;
  ActionMenu actionMenu;
} Global;

extern Global g;

//========================================
//     Global function prototypes
//========================================

void Quit(int exitval=0);   

template<typename T, bool zero=false>
class ElemDeleter {
public:
     void operator()(T* &o) {
          delete o;
#ifdef NDEBUG
          if(zero)
#endif
               o = 0;
     }
};

template<typename T> inline ElemDeleter<T, false> 
DelElem() { return ElemDeleter<T, false>(); }

template<typename T>
inline void DelNZero(T* &o) { delete o; o = NULL; }

template<typename T, typename X>
class AtScopeExit {
public:
     AtScopeExit(T func, X target) : m_func(func), m_target(target) {}
     ~AtScopeExit() { m_func(m_target); }
     
private:
     T m_func;
     X m_target;
};

inline void DownCase(char &c) { c = tolower(c); }
inline void UpCase(char &c) { c = toupper(c); }

template<typename PtrType, typename Collection>
void ClearCollection(Collection &col)
{
     std::for_each(col.begin(), col.end(), DelElem<PtrType>());
     col.clear();
}

#endif //_COMMON_

---