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

  @file /gui/engine/Scene.h
  @brief Zakladni trida pro reprezentaci 3D sceny


  @author Vajicek+Pavel
  @version 0.1
 
******************************************************************************/
#ifndef SCENE_H
#define SCENE_H

//
#include "gui/common/mymath.h"
#include "gui/common/Screen.h"
#include "gui/engine/SceneGeom.h"
#include "gui/engine/Animation.h"
#include "gui/model/selection.h"
#include "gui/model/ModelRep.h"
#include "gui/model/DrawModel.h"

//
#include <vector>

namespace gui{

// stupne oslabeni objektu
#define FADE_UNDEF -1
#define FADE_0   0
#define FADE_1   1
#define FADE_2   2
#define FADE_3   3
#define FADE_4   4

//FWD
class TCamera; 
class TScene; 

/*TSceneFog***************************************************************/

/** Mlha. */
class TSceneFog //##
{
public:
  int iFogOn;         ///< Mlha zapnuta.
	float f4FogColor[4];///< Barva mlhy.
  float fFogStart;    ///< Zacatek mlhy
  float fFogEnd;      ///< Konec mlhy.
  float fFogDensity;  ///< hustota mlhy.
  /** Kosntruktor. 
    @param s Zacatek.
    @param e Konec. 
    @param d Hustota.
  */
  TSceneFog(float s, float e, float d);
  /** Nastaveni barvy.
    @param r R.
    @param g G.
    @param b B.
    @param a Alpha..
  */
  void setColor(float r, float g, float b, float a);
  /** Nastav renderer.
  */
  void apply();
};

/*TLightSource***********************************************************/

/** Jakekoli svetlo ve scene. */
class TLightSource //##
{
protected:
	HWID hId;     ///< HW Identifikator svetelneho zdroje.
	KHANDLE hName;///< Handler.
public:
	int iEnabled; ///< Priznak zapnuto/vypnuto.
	
	/// Parametery svetla.
  //@{
	P4F p4fPosition;  ///< Pozice.
	P4F p4fAmbient;   
	P4F p4fDiffuse;
	P4F p4fSpecular;
	P3F p3fAttenuation;
	P3F p3fSpotDirection;
	float fSpotExponent;
	float fSpotCutoff;
  //@}
public:
	/** Nastavi jako svetelny zdroj rendereru.
  */
	virtual void setupRendererLight();
  /** Konstruktor.
    @param name Handle.
    @param id Id.
  */
  TLightSource(KHANDLE name, HWID id);
  /** Destruktor. 
  */
	~TLightSource();
  //
  friend class TScene;
};

/// vektor svetelnych zdroju
typedef std::vector<TLightSource*> Tlightsources;

/*TSceneObject*************************************************************/
/** Predek vsech objektu, ktere maji polohu ve scene.
*/
class TSceneObject: public TAABB, public TSelectableObject
{
protected:
	MX4 mx4Pos;						//transformacni matice vzhledem k pocatku
public:
  /// ukazatel na vlastni scenu
  TScene *myscene;
	/// promenne pro volne pouziti pro potomka
  int tag, tag2;
  /// cas posledniho vykresleni
	int iRenderTime;
	/// indikator, zda se jedna o polopruhledny objekt
	bool transparent;
	/// "oslabeni objektu" ( 0 = plny objekt, 1 = oslabeny objekt, 2 = objekt zmizel)
	int fade;

  ///POHLEDOVE TRANSFORMACE
  //@{
	virtual void positionUpdated();               	  
	virtual void setPosition(P3F* pos);	  
	virtual void setPosition(float x, float y, float z);	  
  virtual void setPosition(P3F* pos, P3F* dir, P3F* up);
	virtual void getPosition(P3F* pos);	  
	virtual void setOrientation(P3F* dir, P3F* up);	  
	virtual void setOrientation(float dx, float dy, float dz, 
                              float ux, float uy, float uz);	  
	virtual void setPositionMX4(MX4 mx4);	  
	virtual void getPositionMX4(MX4 mx4);	
	virtual void moveTo(float x,float y,float z);
	virtual void moveBy(float x,float y,float z);
	virtual void rotateTo(float x,float y,float z);
	virtual void rotateBy(float x,float y,float z);
	virtual void uniformScale(float scl);
  //@}
	
  /** Vykresli objekt.
  */ 
	virtual void drawObject();
  /** Konstruktor.
  */
	TSceneObject();
  /** Destruktor.
  */
  virtual ~TSceneObject();

  /// Statick pocitadlo vytvorenych objektu.
  static int iSceneObjects;

  /** ??
  */
  int getRealFade();
};

/// rychly check a update
#define TS(a,b) ((a.iTimeStamp<b)?(a.iTimeStamp=b):0)

/// vektor objektu na scene
typedef std::vector<TSceneObject*> Tsceneobjs;


/*TModelSceneObject*********************************************************/

/** Obsahuje model.
  Je to dynamicky objekt(pohyblivy, animovany), ale lze pouzit i jen jako staticky(hromada vrcholu, ploch).
*/
class TModelSceneObject: public TSceneObject
{
protected:
  /// Instance modelu.
  TModelInstance* inst;
  /// Pozice.
  P3F p3fTranslate;
  /// Otoceni.
  AXISANG axisangRotate;  
  /// Flag definujici zpusob vykresleni.
  DWORD dwDrawFlag;
  /** Prepocet matice z pozice a otoceni.
  */
  void calculateMatrix();
public:
  /** Konstruktor.
    @param mid Model.
  */
	TModelSceneObject(TModel *mid);
  /** Destruktor.
  */
	virtual ~TModelSceneObject();
  /** Zpetvna vazba pri zmene pozice.
  */
	virtual void positionUpdated();
  /** Spocita AABB instance modelu.
  */
	virtual void calculateAABB();
  /** Vykresli objekt.
  */
	virtual void drawObject();
	/** Kolize s paprskem.
    Zjisti zda ray prochazi timto AABB a do t pripadne ulozi 
    nejmensi parametr, ze start+t*dir je bod z AABB
    
    @param ray Paprsek.
    @param[out] t Parametr kde doslo k pruseciku.
  */
	virtual bool Collision(TRay* ray, float *t);
};



/*TQuadNode*********************************************************************/

/* konstanty, ktere urcuji interval z-ove souradnice ve kterem se mohou pohybovat 
  SceneObjekty. v QuadTree */
#define LOW_NODE_HEIGHT		(-2*HEX_EDGE_LENGTH)
#define HIGH_NODE_HEIGHT	(6*HEX_EDGE_LENGTH)


class TQuadNode; //fwd

/// ukazatel na guadnod
typedef TQuadNode* PQuadNode;

/** Axis aligned QuadTreeNode */
class TQuadNode : public TAABB
{
public:
  /// Priznak zda je list.
	bool bIsLeaf;
  /// Potomci.  
	PQuadNode Childs[4];
  /// Hloubka.
	int quadrNodeDepth;

  /// Staticke parametry sceny.
  //@{
	static bool bTreeBuilt;
	static int iRenderTime;
  static float high_node_height;
  static float low_node_height;
  static float min_leaf_dim;
  //@}
  
	///nod data
	//@{
	/// pole nepruhlednych objeku
	Tsceneobjs objs;
	/// pole pruhlednych objektu
	Tsceneobjs tobjs;
	//@}
  
	///manipulace s daty
	//@{
	/** prida objekt do uzlu
    @param so Umistovany oxbjektu.
  */
	virtual void addObject(TSceneObject* so);
	/** smaze staticky nebo dynamicky objekt z uzlu
    @param so Odsranovany objekt.
  */
	TSceneObject *remFromScene(TSceneObject* so);
	/** Nakresli pruhledne i nepruhledne viditelne objekty.
    Vykresli objekty v jehlanu.
    @param fr Jehlan.
  */
	void drawObject(TFrustum *fr);
	/** Spocita kolize s Frustem a vykresli bud vse pruhledne nebo vse nepruhledne, co je v nem 
    @param fr Jehlan
    @param transparent Priznak vykreslovani pruhlednych.
  */
	void drawObject(TFrustum *fr, bool transparent);
	/** Rozdeli uzel podle statickych objektu a zavola se rekursivne na potomky    
  */
	void buildTree();
	/** Umisti objekt, ktery uz ve stromu byl na spravne misto
    @param so Objekt.
  */
	void placeObject(TSceneObject* so);
	/** uvolni pamet
  */
	void destroyTree();
	/** je potreba zavolat po kazdem pohyby so, aby se tento zatridil na spravne misto ve strome
    @param so Premistovany objekt.
  */
	virtual void reinstalObject(TSceneObject* so);
	//@}	
  
	/** Kolize s paprskem. 
    Zjisti zda ray prochazi nejakym AABB v podstromu tohoto QuadNode a do t 
		pripadne ulozi nejmensi parametr, ze start+t*dir je bod z takoveho AABB.
		*mso bude ukazatel na modelSceneObject, ktery ma tento AABB 
    
    @param ray Paprsek.
    @param[out] t Parametr paprsku.
    @param mso Objekt se kterym doslo ke kolizi.
    @return Zda doslo ke kolizi.    
  */
	bool Collision(TRay* ray, float *t, TSceneObject **mso);
  /** Konstruktor.
  */
	TQuadNode();
  /** ekvivalent konstruktoru
  */
  void init();  
  /** Nastaveni parameteru, vola se pred vkladanim do stromu.
    @param _low_node_height Nejmensi z-ova souradnice v budouci scene.
    @param _high_node_height Nejvetsi z-ova souradnice v budouci scene.
    @param _min_leaf_dim Nejmensi pripustna x-ova nebo y-ova dimenze listu stromu.
  */
  void setBounds(float _low_node_height, float _high_node_height, float _min_leaf_dim);

  /** Najde scene object v podstromu. */
  void findSceneObject(TSceneObject* so);

};



/** Predek vsech scen. */
class TScene: public TQuadNode, public TButton
{
private:
  /// Svetelne zdroje.
	Tlightsources vLightSources;
public:
  ///manipulace se svetly
  //{@
  /** Najdi svetelny zdroj podle handleru
    @param id Handler.
    @return Svetelny zdroj, NULL.
  */
	TLightSource* getLight(KHANDLE id);
  /** Pridej svetelny zdroj.
    @param ls Pridavany zdroj.
  */
	void addLightSource(TLightSource* ls);
  /** Odstraneni svetelneho zdroje.
    @param id Handle zdroje.
    @return Odstraneny zdroj, NULL pokud neexistuje.
  */
	TLightSource* remLightSource(KHANDLE id);
  //)@

  /// Mlha
  TSceneFog* fog;

  /** Konstruktor
    @param _x Souradnice sceny.
    @param _y Souradnice sceny.
    @param _width Sirka sceny.
    @param _height Vyska sceny.
  */
	TScene(int _x, int _y, int _width, int _height);
  /** Ekvivalent konstruktoru
  */
  void init();
  /** Nastaveni rendereru.
  */
	virtual void setupScene();
  /** Obnoveni parametru rendereru.
  */
	virtual void resetScene();

	/** Vykresli scenu z pohledu kamery.
    @param cam Kamera.
  */
	virtual void drawScene(TCamera* cam);
	/** Uvolni pamet, ale nenici SceneObjecty 
  */
	virtual void destroyScene();
	/** Nastavi vsechny svetla 
  */
	virtual void setupLights();

	/** prida objekt do uzlu
    @param so Objekt.
  */
	virtual void addObject(TSceneObject* so);
	/** je potreba zavolat po kazdem pohyby so, aby se tento zatridil na spravne misto ve strome
    @param so Objekt.    
  */
	virtual void reinstalObject(TSceneObject* so);
  /** spocita stupen utlumu v zavislosti na tag (typicky vola TSceneObject)
    ??
  */
  virtual int getFadeFromTag(int tag, int tag2);
};

}//namespace
#endif
/*****************************************************************************/