//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------

#ifndef _PRECIPITATION_H_
#define _PRECIPITATION_H_

#include "game/gameBase.h"
#include "audio/audioDataBlock.h"

/// How many drops are on a side of the material texture
#define DROPS_PER_SIDE 4
/// How many frames are on a side of a splash animation
#define FRAMES_PER_SIDE 2

//--------------------------------------------------------------------------
/// Precipitation datablock.
class PrecipitationData : public GameBaseData {
   typedef GameBaseData Parent;

  public:
   AudioProfile* soundProfile;
   S32           soundProfileId;    ///< Ambient sound

   StringTableEntry mDropName;      ///< Texture filename for raindrop
   StringTableEntry mSplashName;    ///< Texture filename for splash

   F32 mDropSize;                   ///< Droplet billboard size
   F32 mSplashSize;                 ///< Splash billboard size
   bool mUseTrueBillboards;         ///< True to use true billboards, false for axis-aligned billboards
   S32 mSplashMS;                   ///< How long in milliseconds a splash will last

   PrecipitationData();
   DECLARE_CONOBJECT(PrecipitationData);
   bool onAdd();
   static void  initPersistFields();
   virtual void packData(BitStream* stream);
   virtual void unpackData(BitStream* stream);
};
DECLARE_CONSOLETYPE(PrecipitationData)

struct Raindrop
{
   F32 velocity;           ///< How fast the drop is falling downwards
   Point3F position;       ///< Position of the drop
   Point3F renderPosition; ///< Interpolated render-position of the drop
   F32 time;               ///< Time into the turbulence function
   F32 mass;               ///< Mass of drop used for how much turbulence/wind effects the drop

   U32 texCoordIndex;      ///< Which piece of the material will be used

   bool toRender;          ///< Don't want to render all drops, just the ones that pass a few tests
   bool valid;             ///< Drop becomes invalid after hitting something.  Just keep updating
                           ///<   the position of it, but don't render until it hits the bottom
                           ///<   of the renderbox and respawns

   Point3F hitPos;         ///< Point at which the drop will collide with something

   Raindrop *nextSplashDrop; ///< Linked list cruft for easily adding/removing stuff from the splash list
   Raindrop *prevSplashDrop; ///< Same as next but previous!
   SimTime animStartTime;    ///< Animation time tracker
   U32 splashIndex;          ///< Texture index for which frame of the splash to render
   U32 hitType;              ///< What kind of object the drop will hit

   Raindrop* next;         ///< linked list cruft

   Raindrop()
   {
      velocity = 0;
      time = 0;
      mass = 1;
      texCoordIndex = 0;
      next = NULL;
      toRender = false;
      valid = true;
      nextSplashDrop = NULL;
      prevSplashDrop = NULL;
      animStartTime = 0;
      splashIndex = 0;
      hitType = 0;
      hitPos = Point3F(0,0,0);
   }
};

//--------------------------------------------------------------------------
class Precipitation : public GameBase
{
  private:

   typedef GameBase Parent;
   PrecipitationData*   mDataBlock;

   Raindrop *mDropHead;    ///< Drop linked list head
   Raindrop *mSplashHead;  ///< Splash linked list head
   Point2F texCoords[4 * DROPS_PER_SIDE*DROPS_PER_SIDE];  ///< texture coords for rain texture
   Point2F splashCoords[4 * FRAMES_PER_SIDE*FRAMES_PER_SIDE]; ///< texture coordinates for splash texture

   AUDIOHANDLE mAudioHandle;        ///< Ambient sound handle
   TextureHandle mDropHandle;    ///< Texture handle for raindrop
   TextureHandle mSplashHandle;     ///< Texture handle for splash

   //console exposed variables
   S32 mNumDrops;                ///< Number of drops in the scene
   F32 mPercentage;              ///< Server-side set var (NOT exposed to console)
                                 ///< which controls how many drops are present [0,1]

   F32 mMinSpeed;                ///< Minimum downward speed of drops
   F32 mMaxSpeed;                ///< Maximum downward speed of drops

   F32 mMinMass;                 ///< Minimum mass of drops
   F32 mMaxMass;                 ///< Maximum mass of drops

   F32 mBoxWidth;                ///< How far away in the x and y directions drops will render
   F32 mBoxHeight;               ///< How high drops will render

   F32 mMaxTurbulence;           ///< Coefficient to sin/cos for adding turbulence
   F32 mTurbulenceSpeed;         ///< How fast the turbulence wraps in a circle
   bool mUseTurbulence;          ///< Whether to use turbulence or not (MAY EFFECT PERFORMANCE)

   bool mRotateWithCamVel;       ///< Rotate the drops relative to the camera velocity
                                 ///< This is useful for "streak" type drops

   bool mDoCollision;            ///< Whether or not to do collision

   struct
   {
      bool valid;
      U32 startTime;
      U32 totalTime;
      F32 startPct;
      F32 endPct;
   } mStormData;

   //other functions...
   void processTick(const Move*);
   void interpolateTick(F32 delta);

   VectorF getWindVelocity();
   void fillDropList();                      ///< Adds/removes drops from the list to have the right # of drops
   void killDropList();                      ///< Deletes the entire drop list
   void spawnDrop(Raindrop *drop);           ///< Fills drop info with random velocity, x/y positions, and mass
   void spawnNewDrop(Raindrop *drop);        ///< Same as spawnDrop except also does z position
   void findDropCutoff(Raindrop *drop);      ///< Casts a ray to see if/when a drop will collide
   inline void wrapDrop(Raindrop *drop, Box3F &box); ///< Wraps a drop within the specified box

   void createSplash(Raindrop *drop);        ///< Adds a drop to the splash list
   void destroySplash(Raindrop *drop);       ///< Removes a drop from the splash list


  protected:
   bool onAdd();
   void onRemove();

   // Rendering
   bool prepRenderImage(SceneState*, const U32, const U32, const bool);
   void renderObject(SceneState*, SceneRenderImage*);
   void renderPrecip(SceneState *state);
   void renderSplashes(SceneState *state);

  public:

   Precipitation();
   ~Precipitation();
   void inspectPostApply();

   enum
   {
      DataMask       = Parent::NextFreeMask << 0,
      PercentageMask = Parent::NextFreeMask << 1,
      StormMask      = Parent::NextFreeMask << 2,
      NextFreeMask   = Parent::NextFreeMask << 3
   };

   bool onNewDataBlock(GameBaseData* dptr);
   DECLARE_CONOBJECT(Precipitation);
   static void initPersistFields();

   U32  packUpdate(NetConnection*, U32 mask, BitStream* stream);
   void unpackUpdate(NetConnection*, BitStream* stream);

   void setPercentage(F32 pct);
   void modifyStorm(F32 pct, U32 ms);
};

inline void Precipitation::wrapDrop(Raindrop *drop, Box3F &box)
{
   bool recalcCutoff = false;
   //could probably be slightly optimized to get rid of the while loops
   if (drop->position.x < box.min.x)
   {
      while (drop->position.x < box.min.x)
         drop->position.x += mBoxWidth;
      recalcCutoff = true;
   }
   else if (drop->position.x > box.max.x)
   {
      while (drop->position.x > box.max.x)
         drop->position.x -= mBoxWidth;
      recalcCutoff = true;
   }

   if (drop->position.y < box.min.y)
   {
      while (drop->position.y < box.min.y)
         drop->position.y += mBoxWidth;
      recalcCutoff = true;
   }
   else if (drop->position.y > box.max.y)
   {
      while (drop->position.y > box.max.y)
         drop->position.y -= mBoxWidth;
      recalcCutoff = true;
   }

   if (drop->position.z < box.min.z)
   {
      spawnDrop(drop);
      drop->position.x += box.min.x;
      drop->position.y += box.min.y;
      while (drop->position.z < box.min.z)
         drop->position.z += mBoxHeight;
      recalcCutoff = true;
   }
   else if (drop->position.z > box.max.z)
   {
      while (drop->position.z > box.max.z)
         drop->position.z -= mBoxHeight;
      recalcCutoff = true;
   }
   
   if(recalcCutoff)
      findDropCutoff(drop);
}

#endif // PRECIPITATION_H_