/**
*******************************************************************************

  @file /gui/engine/Effects.h
  @brief Zaklad pro visualni efekty(casticove systemy, sprite,..)


  @author Vajicek
  @version 0.1
 
******************************************************************************/
#ifndef EFFECTS_H
#define EFFECTS_H

//
#include "gui/common/mymath.h"
#include "gui/common/colors.h"
#include "gui/engine/Scene.h"
#include "gui/engine/Camera.h"
#include "gui/engine/Controllers.h"

//
#include <GL/glu.h>
#include <vector>

namespace gui{

/** Vygeneruje nahodny smer.
  Vygenruje nahdny smer z pocatku do kruhu o polomeru r a z vysoko nad pocatkem. 
  Normalizuje a zvetsi na velkost size.
  
  @param r polomer kruhu
  @param z vyska
  @param dir vystupni hodnota smeru
  @param size velikost
*/
static void GenerateRandomDirectionInSector(float r, float z, P3F *dir, float size);

/** Vygeneruje pozici v kruhu.
  @param r polomer kruhu
  @param z vyska, jen se zkopiruje do vystupu
  @param pos vystupni poloha v kruhu
*/
static void GenerateRandomPositionInSector(float r, float z, P3F *pos);

/** Utlum.
  Utlumi hodnotu k nule pokud se nachazi pred t1 nebo za t2.
  
  @param t hodnota
  @param t1 prah1
  @param t2 prah2
*/
static float FadeInOut(float t, float t1 , float t2);



/** Zastresujici objekt efektu pro urcitou scenu. */
class TEffectEngine //## 
{
public:
  P3F p3fSceneGravity;  ///< smer gravitace na scene
  P3F p3fSceneWind;     ///< smer vetru na scene
  TScene* scene;        ///< odkaz na scenu
  TControllerManager* ctrlmng;  ///< odkaz na manager  
  float fSkyHeight; ///< vyska nebe sceny
  int iPRP;         ///< particle refresh period, za jakou dobu v milisekundach se obnovuje

  /** Konstruktor.
    @param sc Scena.
    @param cm Manazer kontroleru na dane scene.
  */
  TEffectEngine(TScene* sc, TControllerManager* cm);

  /// globalni instance effect enginu
  static TEffectEngine* ee;
  /** Inicializuj globalni instanci effect engine.
    @see TEffectEngine
  */
  static void initEffectEngine(TScene* sc, TControllerManager* cm);
  /** Dealokuj effect engine.
  */
  static void destroyEffectEngine();
};



/** Zlepseny kontroler.
  Implementuje specialni pocitani casu.
*/
class TAdvController: public TController
{
public:
  /// jak casto updatovat
  int iGranularity;

  /// posledni hodnota relativniho casu, kvuli monotonii
  int iLastRelativeTime;

  /** Update kontroleru.
    @see TController
  */
  virtual void update(int absoluteTime);
  /** Update efektu..
    @param absoluteTime
    @param rtime
    @param step
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Aktivuj kontroler.
    @see TController
  */
  void activate(int absoluteTime, int recursive = 1);

  /** Konstruktor.
    @param granularity Jak casto se bude provadet vnitrek update.
  */
  TAdvController(int granularity);
};



/** Predek pro casticove systemy. 
  Tato trida je abstraktni.
*/
class TParticles: public TSceneObject, public TAdvController {
public:
  int iCount;         ///< pocet castic
  P3F* p3fDirections; ///< smer pohybu castic
  P3F* p3fPositions;  ///< pozice castic
  
  /** Pridej castici do seznamu. 
    @param pos pozice
    @param dir smer
    @return index
  */
  int addPoint(P3D* pos, P3D* dir);
  
  /** Inicializuj castice.
  */
  virtual int setUp() = 0;
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step) = 0;
  /** Prekresleni sceneobjektu.
    @see TSceneObject
  */
	virtual void drawObject();
  /** Vypocet ohranicujiciho boxu.
    @see TSceneObject
  */  
	virtual void calculateAABB();
  /** Konstruktor. */
  TParticles();
  /** Destruktor. */
  ~TParticles();
};



/** Jednoduchy efekt tryskajicich castic. */
class TSimpleSpray: public TParticles {
protected:
  float fSpeed;     //< rychlost v jednotkach za ms
  float fBaseDiam;  //< prumer zakladny oblasti
  float fDeathProb; //< pravdepodobnost zaniku pohybujici se castice
public:
  /** Inicializuj castice.
  */
  virtual int setUp();
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Konstruktor.
    @param speed rychlost
    @param pcount pocet castic
    @param bdiam prumer oblasti
    @param deathp pravdepodobnost zaniku
  */
  TSimpleSpray(float speed, int pcount, float bdiam, float deathp);
};



/// velikost snezne bunky
#define AE_CELL_SIZE 1100.0f
/// nasobitel rychlosti
#define AE_BASIC_TIMERATIO 5

/** Predek pro atmosfericke efekty, snih a dest. */
class TAtmosphericEffect: public TParticles {
public:
  int iStopped;           ///<
  float fSkyTop;          ///< vyska ve ktere castice vznikaji
  float fGround;          ///< vyska ve ktere zanikaji
  /** Pole pro devet bunek. */
  struct TCell{
    int c1;
    int c2;
    int i;
  } cells[9]; 
  TCell* cellorder[9];
  int posx, posy;
  //
  TCamera* cam;           ///< kamera vuci ktere se bude vykreslovat a aktualizovat
  /** Prehazni bunky pokud prejdu pres okraj prostredni.
  */
  void cellOrderChange();
  /** Inicializuje bunky.
  */
  void setUpCells();
  /** Spocita objemove teleso.
    Melo by byt pres celou scenu. Tzn vzdy viditelne.
  */
  virtual void calculateAABB();
  /** Predefinovane nastavi rychlosti.
    @see TController
  */
  virtual void setTimeRatio(float tr, int recursive);
  /** Postupne zastaveni.
  */
  virtual void stopGradually();
  /** Konstruktor.
    @param center Stred Oblasti/Sceny.
    @param dim Velikost Oblasti.
    @param c Kamera kolem ktere se ma koncentrovat efekt.
  */
  TAtmosphericEffect(P3F* center, P3F* dim, TCamera* c);
  /** Odstraneni ze sceny.
    @param ae Efekt.
  */
  static void uninstallAtmosphericEffect(TAtmosphericEffect* ae);
};



#define SNOWFLAKE_SIZ 4
#define SNOWFLAKE_COL 0.95f,0.95f,0.95f
#define SNOWFLAKE_DENSITY 3000

/** Snih. */
class TSnow: public TAtmosphericEffect{
public:
  float fBaseDiam;        ///< rozptyl smeru pohybu
  float fSpeed;           ///< zakladni rychlost pohybu
  float fSpeedVariation;  ///< rozptyl rychlosti
  int   iAlive;           ///< pocet vlocek na povrchem
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();
  /** Update.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Vykresleni.
    @see TSceneObject
  */
  virtual void drawObject();
  /** Konstruktor.
    @param center 
    @param dim
    @param c
    @param density  
  */
  TSnow(P3F* center, P3F* dim, TCamera* c, int density);
  //installer
  static TSnow* installSnow(int density = SNOWFLAKE_DENSITY);
};



#define RAINDROPS_LEN 10
#define RAINDROPS_SIZ 2
#define RAINDROPS_COL 0.06f,0.40f,0.56f
#define RAINDROPS_DENSITY 5000

#define LIGHTING_INTERVAL_MIN 15000
#define LIGHTING_INTERVAL_MAX 30000
#define LIGHTING_INTERVAL_LEN 400

#define THUNDER_TIMING 3000

/** Dest. */
class TRain: public TAtmosphericEffect{
public:
  P3F fRainDir;             ///< uhel pohybu kapek
  float fSpeed;             ///< zakladni rychlost pohybu
  int lightingTime;         ///< kdy se ma zablesknout
  int thunderTime;          ///< kdy se ma zahrmit
  TLightSource* lsLighting; ///< svetelnej zdroj pouzitej pro blesk
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();
  /** Spusteni/Vypnuti blesku.
    @param on 1=zapnout, 0=vypnout
  */
  void flash(int on);
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Prekresli objekt.
    @see TSceneObject
  */
  virtual void drawObject();
  /** Konstruktor.
    @param center Stred oblasti.
    @param dim Rozmer oblasti.
    @param c Kamera.
    @param density Hustota.
  */
  TRain(P3F* center, P3F* dim, TCamera* c, int density);
  /** Destruktor.
  */
  ~TRain();
  /** Instalator.
    @param density Hustota deste.
  */
  static TRain* installRain(int density = RAINDROPS_DENSITY);
};



#define WEATHER_CHANGE_DELAY 5000
#define WEATHER_WINTER_SKYCOLOR 0.5f, 0.5f, 0.5f
#define WEATHER_SUMMER_SKYCOLOR 0.75f, 0.75f, 0.50f
#define WEATHER_AUTUMN_SKYCOLOR 0.5f, 0.625f, 0.75f

/// Typ pocasi
enum TWeatherState{
  wsSummer, 
  wsAutumn,
  wsWinter
};

/** Kontrola pocasi("Porucime vetru, desti") */
class TWeatherController: public TController{
public:
  /// Ukazatel na mlhu na scene.
  TSceneFog* scenefog;
  /// Ukazatel na aktualni atmosfericky efekt, nebo NULL
  TAtmosphericEffect* atmosphericeffect;
  /// Predchozi stav pocasi
  TWeatherState previous_state;
  /// Aktualni stav pocasi
  TWeatherState state;
  /** Updatuj udalost.
    @see TController
  */
  virtual void update(int absoluteTime);
  /** Inicializuje zmenu stavu.
    @param new_state Novy stav pocasi.
  */
  void change(TWeatherState new_state);
  /** Konstruktor.
    @param scfog Mlha na scene.
    @param initial_state Inicialni stav.
  */
  TWeatherController(TSceneFog* scfog, TWeatherState initial_state);
  /** Destruktor.
  */
  virtual ~TWeatherController();  
  /** Instalator.
    @param initial_state Inicialni stav pocasi.
  */
  static TWeatherController* installWeatherController(TWeatherState initial_state);
};



#define BLOODSPLASH_COLOR           0.9f, 0, 0
#define SMALL_BLOODSPLASH_ANGLE     (float)((16/20.0)*M_PI)
#define SMALL_BLOODSPLASH_PARTICLES 30

/** Vystrik krve. */
class TBloodSplash: public TParticles{
public:
  /// Inicializacni data.
  //@{
  float fAngle;           ///< rozptyl smeru vystriku
  float fStartSpeedMin;   ///< minimalni pocatecni rychlost
  float fStartSpeedMax;   ///< maximalni pocatecni rychlost
  P3F p3fStartDirection;  ///< pocatecni smer
  P3F p3fStartPosition;   ///< pocatecni pozice
  //@}
  
  /// Pridane vlastnosti castic.
  //@{
  float* pfAlpha;         ///< pruhlednost castic
  //@}
  
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();  
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Prekresli objekt.
    @see TSceneObject
  */
	virtual void drawObject();

  /** Konstruktor.
    @param dir Smer vysece.
    @param pos Poloha zdroje castic nad nulovou hladinou. 
    @param pc Pocet castic.
    @param ang Cas pocatku.
    @param startAt Cas zacatku.
    @param ssmin Minimalni pocatecni rychlost.
    @param ssmax Maximalni pocatecni rychlost.
  */
  TBloodSplash(P3F* dir, P3F* pos, int pc, float ang, int startAt, float ssmin, float ssmax);
  /** Destruktor.
  */
  ~TBloodSplash();

  /** Instalator.
    @param dir Smer vysece.
    @param scpos Poloha nulove hladiny na scene.
    @param pos Poloha zdroje castic. 
    @param startAt Cas zacatku.
    @return Vystrik.
  */
  static TBloodSplash* installSmallBloodSplash(P3F* dir, P3F* scpos, P3F* pos, int startAt);         
};



#define EXPLOSION_COLOR 0.43f, 0.28f, 0

/** Vybuch. */
class TExplosion: public TParticles{
public:
  //
  int draw_on;          ///< Zdali vykreslovat, nebo ne
  float fadeout_factor; ///< Jak rychle mizet(koeficient geom posl).
  float disapper_limit; ///< V jake fazi viditelnosti zmizet
  
  /// inicializacni data
  //@{
  float fStartSpeedMin;   ///< minimalni pocatecni rychlost
  float fStartSpeedMax;   ///< maximalni pocatecni rychlost
  P3F p3fStartDirection;  ///< pocatecni smer
  P3F p3fStartPosition;   ///< pocatecni pozice
  //@}
  
  /// pridane vlastnosti castic
  //@{
  float* pfAlpha;     ///< pruhlednost castic
  float* pfPointSize; ///< velikost castic
  int iSoundFlag;     ///< jestli uz hraje sample
  //@}
    
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Prekresli objekt.
    @see TSceneObject
  */
	virtual void drawObject();
  /** Installer.
    @param dir Smer vybuchu.
    @param scpos Poloha na scene
    @param pos
    @param startAt
    @param particles
    @param speed 
    @return Nova instance vybuchu.
  */
  static TExplosion* installExplosion(P3F* dir, P3F* scpos, P3F* pos, int startAt, int particles, float speed);
  /** Konstruktor.
    @param dir
    @param pos
    @param pc
    @param startAt
    @param ssmin
    @param ssmax  
  */
  TExplosion(P3F* dir, P3F* pos, int pc, int startAt, float ssmin, float ssmax);
  /** Destruktor.    
  */
  ~TExplosion();
};



/** Predek pro billboardy. */
class TBillBoard //##
{
protected:
  TCamera *camera;  ///< Kamera 
public:
  /** Konstruktor. 
  */
  TBillBoard(TCamera *cam);
  /** Spocita vektory tvorici bazi plochy rovnobezne s pohledem.
    @param x vodorovny vektor
    @param y svisly vektor
  */
  void screenBase(P3F* x, P3F* y);
};



#define SMOKE_BASIC_TIMERATIO 5
#define SMOKE_BASIC_HEIGHT 70

/** Kour. */
class TSmoke: public TParticles, public TBillBoard{
public:
  float fMaxHeight; ///< vyska ve ktere oblacek koure mizi
  float fBaseDiam;  ///< zakaldni polomer ve kterem se kour objevuje
  float fSpeedMin;  ///< minimalni rychlost stoupani
  float fSpeedMax;  ///< maximalni rychlost stoupani
  HWTID hTextureID; ///< id textury
  int* piOn;        ///< za jak dlouho po zacatku zacne oblacek stoupat
  int iPermanent;   ///< kouri porad
  int iDur;         ///< za jak dlouho dokouri
  
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Prekresli objekt.
    @see TSceneObject
  */
	virtual void drawObject();
  /** Predefinovane nastavi rychlosti.
    @see TController
  */
  virtual void setTimeRatio(float tr, int recursive);
  /** Zmena z trvaleho koure na docasny.
    @param time Jak dlouho se maji jeste generovat nove castice.
  */
  void smokeOut(int time);
  /** Konstruktor.
    @param bid        Id rastru s texturou castice.
    @param cam        Kamera.
    @param clcount    Pocet castic.
    @param maxheight  Vyska do ktere ma stoupat.
    @param dur        Trvani, -1 nekonecne.
    @param basediam   Zakladni polomer oblasti.
    @param speedmin   Max rychlost
    @param speedmax   Minimalni rychlost
  */
  TSmoke(int bid, TCamera* cam, int clcount, float maxheight, int dur=-1, float basediam = 10, float speedmin = 0.1f , float speedmax = 0.5f);    
  /** Destruktor.
  */
  virtual ~TSmoke();
  /** Installer.
    Nastavi zakladni parametry.
    @param scpos    Pozice na scene.
    @param startAt  Zacatek.
    @param dur      Trvani, -1 nekonecne.
    @return Novy kour.
  */
  static TSmoke* installSmoke(P3F* scpos, int startAt, int dur=-1);
  /// Id zakladni textury oblacku.
  static HWTID hSmokeTextureID;
  /** Nacte zakladni texturu.
  */
  static void initSmokeTexture();
};



//#define SIMPLESHADOW_MAGIC_CONSTANT 0.5f

/** Jednoduchy stin pod AABB. */
class TSimpleShadow //##
{
protected:
  /// Rohy stinu
  P3F points[4];
  /// Objekt.
  TAABB* object;
  /// Id pouzite textury/shadowmapy.
  HWTID hShadowTextureID;
public:
  /// Textura stinu.
  static HWTID hSmallShadowTextureID;
  /// Seznam stinu do sceny.
  static std::vector<TSimpleShadow*> shadows;
  /** Inicializuj textury pro stiny.
  */
  static void initShadowTextures();
  /** Druhy pruchod - modifikace zbufferu.
  */
  static void drawSecondPassShadows();
  /** Treti pruchod - vykreseleni stinu se zbufferem.
  */
  static void drawThirdPassShadows();
  /** Pozadavek na zarazeni konkretniho stinu do seznamu.
  */
  virtual void drawShadowRequest();
  /** Vykresleni konkretniho stinu.
  */
  virtual void drawRealShadow();
  /** Pozadavek na zarazeni konkretniho stinu do seznamu.
  */
  virtual void drawShadow();
  /** Konstruktor
    @param obj Objekt.
    @param bid Id rasteru jeho stinu/shadowmapy.
  */
  TSimpleShadow(TAABB* obj, int bid);
};



#define DA_BASIC_TIMERATIO 2

/// typ efektu vzdaleneho utoku
enum TDistantAttackType{
  datArrow, 
  datCatapultProjectile, 
  datMagicMissile
};

/** Vizualizace strelby. 
  prvni verze.
  @deprecated
*/
class TDistantAttack: public TParticles{
public:

  ///charakteristicky data pro strelu
  //@{
  TDistantAttackType datType;       ///< typ utoku
  P3F p3fPos;                       ///< poloha
  P3F p3fDir;                       ///< pohybova slozka v jednotkach na iPRP
  P3F p3fGrav;                      ///< gravitacni slozka v jednotkach na iPRP
  int iDur;                         ///< trvani v ms
  int iRemaining;                   ///< kolik casu zbyva
  int iStarted;                     ///< ve vzduchu
  int iSoundFlag;                   ///< jestli uz hraje sample  
  TModelSceneObject* msoProjectile; ///< projektil
  float* fvVisibility;              ///< viditelnost
  //@}
  
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Prekresli objekt.
    @see TSceneObject
  */
	virtual void drawObject();
  /** Predefinovane nastavi rychlosti.
    @see TController
  */
  virtual void setTimeRatio(float tr, int recursive);
  /** Spocitej aabb.
  */  
  virtual void calculateAABB();
  /** Konstruktor.
    @param attacker Utocnik
    @param target   Cil.
    @param dat      Typ utoku.
    @param startAt  Start.
  */
  TDistantAttack(P3F* attacker, P3F* target, TDistantAttackType dat, int startAt);
};



/** Predek pro vsechny strelecke utoky. */
class TDistant_Attack: public TController{
public:
  P3F p3fSource;    ///< Poloha strelce.
  P3F p3fTarget;    ///< Poloha cile.
  P3F* pp3fHoming;  ///< ukazatel na polohu, ktera se muze menit, strela ma moznost mirit na ni.
  int iStarted;     ///< ve vzduchu
  int iSoundSample; ///< sample  
  int iDur;         ///< trvani v ms
  int iRemaining;   ///< kolik casu zbyva

  /** Updatuj udalost.
    @see TController
  */
  virtual void update(int absoluteTime);
  /** Predefinovane nastavi rychlosti.
    @see TController
  */
  virtual void setTimeRatio(float tr, int recursive);

  /** Konstruktor. 
    @param source Zdroj.
    @param target Cil strelby.
    @param homing Cil strelby ktery ma strela sledovat.
    @param startAt Zacatek.
  */
  TDistant_Attack(P3F* source, P3F* target, P3F* homing, int startAt);
};



/// barva strely(pokud nebude texturovana)
#define PROJECTILE_ATTACK_COLOR 0.3f, 0.3f, 0.3f, 1 

/** Strelba projektilu. */
class TProjectileAttack: public TDistant_Attack, public TModelSceneObject{
public:
  P3F p3fPos;       ///< poloha
  P3F p3fDir;       ///< pohybova slozka v jednotkach na iPRP
  P3F p3fGrav;      ///< gravitacni slozka v jednotkach na iPRP
  /** Updatuj udalost.
    @see TController
  */
  virtual void update(int absoluteTime);
  /** Prekresli objekt.
    @see TSceneObject
  */
  void drawObject();
  /** Konstruktor.
    @param source
    @param target
    @param homing
    @param startAt
    @param speed
    @param envres
    @param mod
  */
  TProjectileAttack(P3F* source, P3F* target, P3F* homing, int startAt, float speed, float envres, TModel* mod);
  /** Vrat model.
    @param id Idcko modelu.
    @return Model.
  */
  static TModel* getProjectileModel(int id);
  /** Instalator projektilu.
    @param attacker Utocnik.
    @param target Cil.
    @param dat Typ utoku.
    @param startAt Start
    @return Nova strelba projektilu.
  */
  static TProjectileAttack* installSimpleProjectile(P3F* attacker, P3F* target, TDistantAttackType dat, int startAt);  
  /// Textura pro jiskry castice
  static HWTID hParticleTexture;
  /// Textura pro tlakovou vlnu
  static HWTID hWaveTexture;
  /** Inicializuj textury.
  */
  static void initProjectiles();
};



/// Pocet bodu ve stope
#define TRACE_SIZE  6
/// Delka mezi body
#define TRACE_STEP_SIZE 6.0f

/** Sip se stopou. 
  @see TProjectileAttack
*/
class TArrowAttack: public TProjectileAttack
{
public:
  /// Stopa.
  P3F trace[TRACE_SIZE];
  /** Updatuj udalost.
    @see TProjectileAttack
  */
  virtual void update(int absoluteTime);
  /** Prekresli objekt.
    @see TProjectileAttack
  */
  void drawObject();
  /** Konstruktor.
    @see TProjectileAttack
  */
  TArrowAttack(P3F* source, P3F* target, P3F* homing, int startAt, float speed, float envres, TModel* mod);
  /** Instalator sipu.
    @param attacker Pozice utocnika.
    @param target Cil.
    @param startAt Cas zactku.
  */
  static TArrowAttack* installArrowAttack(P3F* attacker, P3F* target, int startAt);
};



#define CATAPULT_TRACE_DENSITY          0.5f
#define CATAPULT_TRACE_PARTICLE_SIZE    10
#define CATAPULT_TRACE_PARTICLE_COLOR   0, 0, 0
#define CATAPULT_WAVE_COLOR             0, 0, 0

/** Katapult. 
  @see TProjectileAttack
*/
class TCatapultAttack: public TProjectileAttack, public TParticles, public TBillBoard
{
public: 
  float* fvVisibility;      ///< pruhlednost jisker
  float fWaveRadius;        ///< polomer vlny
  float fWaveTransparency;  ///< pruhlednost vlny
  GLUquadric* disk;         ///< disk tlakove vlny

  virtual int setUp();
	virtual void drawObject();
  virtual void calculateAABB();

  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Update kontroleru.
    @see TParticles
    @see TProjectileAttack
  */
  virtual void update(int absoluteTime);
  /** Konstruktor.
    Hromada parametru.
  */
  TCatapultAttack(TCamera* cam, P3F* source, P3F* target, P3F* homing, int startAt, float speed, float envres, TModel* mod);
  ~TCatapultAttack();

  static TCatapultAttack* installCatapultProjectile(P3F* attacker, P3F* target, int startAt);
};



#define MAGIC_TRACE_DENSITY         0.2f
#define MAGIC_TRACE_PARTICLE_SIZE   5
#define MAGIC_TRACE_PARTICLE_COLOR  1, 1, 0
#define MAGIC_MISSILE_COLOR         1, 0.8f, 0    
#define MAGIC_MISSILE_WAVE_COLOR    0.2f, 0.425f, 1

/** Magicka strela. 
  @see TProjectileAttack
*/
class TMagicMissileAttack: public TProjectileAttack, public TParticles, public TBillBoard{
public: 
  float* fvVisibility;      ///< pruhlednost jisker
  float fWaveRadius;        ///< polomer vlny
  float fWaveTransparency;  ///< pruhlednost vlny
  GLUquadric* disk;         ///< disk tlakove vlny

  virtual int setUp();
	virtual void drawObject();
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Update kontroleru.
    @see TParticles
    @see TProjectileAttack
  */
  void update(int absoluteTime);
  /** Konstruktor.
    Hromada parametru.
  */
  TMagicMissileAttack(TCamera* cam, P3F* source, P3F* target, P3F* homing, int startAt, float speed, float envres, TModel* mod);
  ~TMagicMissileAttack();

  static TMagicMissileAttack* installMagicMissileAttack(P3F* attacker, P3F* target, int startAt);
};



/// Sila otresu v blizkosti vybuchu
#define MAX_SHAKERSTRENGTH  10
/// Vzdalenost utlumu
#define MAX_SHAKERDISTANCE  250
/// Velkost jister vyletujicich z vybuchu
#define FLARESIZE           8
/// Barva podkladu vybuchu
#define DESTRUCTION_SPHERE_COLOR  1, 0.94f, 0
/// Barva disku
#define DESTRUCTION_DISK_COLOR    0.2f, 0.425f, 1
/// Barva jisker
#define DESTRUCTION_SPARKLE_COLOR 1, 0.26f, 0

/** Sfericky vybuch s odletujicimi casticemi. */
class TDestruction: public TParticles, public TBillBoard{
public:
  float* pfAlpha;     ///< pruhlednost jisker
  GLUquadric* sphere; ///< kvadrika sfery exploze
  GLUquadric* disk;   ///< disk tlakove vlny
  float fDiskRad;     ///< polomer disku
  float fRad;         ///< aktualni polomer koule
  float fRadMax;      ///< maximalni polomer koule
  float fRadMin;      ///< minimalni polomer koule
  int iSoundFlag;     ///< jestli uz hraje sample
  int iDur;           ///< doba vybuchu
  float fTransparency;///< pruhlednost
  /** Nastaveni castic.
    @see TParticles
  */
  virtual int setUp();
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  /** Prekresli objekt.
    @see TSceneObject
  */
	virtual void drawObject();
  /** Predefinovane nastavi rychlosti.
    @see TController
  */
  virtual void setTimeRatio(float tr, int recursive);
  /** Konstruktor.
    @param scpos Pozice na scene.
    @param cam Kamera.
    @param startAt Zacatek.
    @param dur Trvani.
    @param rmin Minimalni velikost vybuchu.
    @param rmax Maximalni velikost.
    @param flares Pocet jisker.
  */
  TDestruction(P3F* scpos, TCamera* cam, int startAt, int dur, float rmin, float rmax, int flares);
  /** Destruktor
  */
  ~TDestruction();
  /// Textury.
  //@{
  static HWTID hSimpleWaveTextureID;
  static HWTID hSimpleSphereTextureID;
  static HWTID hSimpleParticleTextureID;
  //@}
  /** Inicializace textur.
  */
  static void initParticleTextures();
  /** Instalator.
    @param scpos Pozice na scene.
    @param len Doba trvani vybuchu.
    @param size Velkost vybuchu.
    @param startAt Zacatek.
    @return Efekt vybuchu.
  */
  static TDestruction* installDestruction(P3F* scpos, int len, float size, int startAt);
};

/** Rozleteni. */
class TFlyAway: public TController{
public:
  int iDur; ///< Doba trvani
  P3F dir;  ///< Smer pohybu
  P3F rot;  ///< Rotace
  /** Update kontroleru. 
    @see TController
  */
  virtual void update(int absoluteTime);
  /** Konstruktor. 
    @param so Objekt na scene.
    @param speed Rychlos pohybu.
    @param rspeed Rychlost rotace.
    @param dur Trvani.
    @param startAt Cas zacatku.
  */
  TFlyAway(TSceneObject* so, float speed, float rspeed, int dur, int startAt);
  /** Installace efektu.
    @see TFlyAway::TFlyAway
  */
  static TFlyAway* installFlyAway(TSceneObject* so, float speed, float rspeed, int dur, int startAt);
};



/// Implicitni doba trvani
#define SPARKLE_DEFAULT_DUR       8000
/// Implicitni rychlost stoupani
#define SPARKLE_DEFAULT_SPEED     0.4f
/// Implicitni rychlost rotace kolem stredu
#define SPARKLE_DEFAULT_ROT_SPEED 0.04f
/// Implicitni hustota
#define SPARKLE_PARTICLE_DENSITY  0.0005f
/// Implicitni stredni velikost
#define SPARKLE_PARTICLE_SIZE     20
/// Implicitni rozptyl velikosti
#define SPARKLE_PARTICLE_SIZE_VAR 10
/// Implicitni barva
#define SPARKLE_DEFAULT_COLOR     1, 1, 0.4f

/** Jiskry */
class TSparkle: public TParticles, public TBillBoard{
protected:
  float fBaseDiam;      ///< prumer oblasti
  float fHeight;        ///< vyska oblasti
  float fSpeed;         ///< max rychlost
  float fRotSpeed;      ///< rychlost otaceni v rad za ms;
  float fTransparency;  ///< pruhlednost
  int iSoundFlag;       ///< priznak, zda byl prehran zvuk
  int iDur;             ///< doba trvani
  float *pfSize;        ///< valikost
  float pfColor[3];     ///< barva
  HWTID hParticleTextureID; ///< id textury
public:
  virtual int setUp();
  //
//  virtual void update(int absoluteTime);
  /** Update kontroleru.
    @see TAdvController
  */
  virtual void update(int absoluteTime, int rtime, int step);
  virtual void drawObject();
  //
  TSparkle(TCamera* cam, P3F* scpos, int dur, float speed, float rotspeed, int pcount, float bdiam, float height, int startAt);

  /// Textura pro jednoduche hvezdicky
  static HWTID hSimpleParticleTextureID;
  /// Textura pro srdicka
  static HWTID hHeartParticleTextureID;
  /// Textura pro krizky
  static HWTID hCrossTextureID;
  /// Textura pro hlavicky
  static HWTID hHeadParticleTextureID;
  /** Inicializace textur.
  */
  static void initParticleTextures();
  /** Obecnejsi instalace jisker.
    @param scpos Pozice na scene.
    @param bdiam Polomer oblasti.
    @param height Vyska oblasti.
    @param c Pocet castic.
    @param hT Textura castic.
  */
  static TSparkle* installSparkle(P3F* scpos, float bdiam, float height, float* c, HWTID hT);
  /** Instalace hvezdicek. */
  static TSparkle* installSparkle(P3F* scpos, float bdiam, float height);
  /** Instalace srdicek. */
  static TSparkle* installHearts(P3F* scpos, float bdiam, float height);
  /** Instalace krizku. */
  static TSparkle* installCross(P3F* scpos, float bdiam, float height);
  /** Instalace hlavicek. */
  static TSparkle* installHeads(P3F* scpos, float bdiam, float height);
};



/*
class TFire: public TParticles{
};

class TCloud: public TParticles{
};
*/

}//namespace

#endif
/*****************************************************************************/