//=============================================================================
  // PSystem.cpp by Frank Luna (C) 2004 All Rights Reserved.
  //=============================================================================
  
  include <PSystem.h>
  include <Camera.h>
  include <d3dApp.h>
  include <d3dUtil.h>
  include <cassert>
  
  PSystem::PSystem(const std::string& fxName, 
                                   const std::string& techName,
                           const std::string& texName, 
                               const D3DXVECTOR3& accel,
                           const AABB& box,
                                   int maxNumParticles,
                           float timePerParticle)
           : mAccel(accel), mBox(box), mTime(0.0f),
             mMaxNumParticles(maxNumParticles), mTimePerParticle(timePerParticle)
  {
          // Allocate memory for maximum number of particles.
          mParticles.resize(mMaxNumParticles);
          mAliveParticles.reserve(mMaxNumParticles);
          mDeadParticles.reserve(mMaxNumParticles);
  
          // They start off all dead.
          for(int i = 0; i < mMaxNumParticles; ++i)
          {
                  mParticles[i].lifeTime = -1.0f;
                  mParticles[i].initialTime = 0.0f;
          }
  
          D3DXMatrixIdentity(&mWorld);
          D3DXMatrixIdentity(&mInvWorld);
  
          // Create the texture.
          HR(D3DXCreateTextureFromFile(gd3dDevice, texName.c_str(), &mTex));
  
          // Create the FX.
          ID3DXBuffer* errors = 0;
          HR(D3DXCreateEffectFromFile(gd3dDevice, fxName.c_str(),
                  0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
          if( errors )
                  MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
  
          mhTech    = mFX->GetTechniqueByName(techName.c_str());
          mhWVP     = mFX->GetParameterByName(0, "gWVP");
          mhEyePosL = mFX->GetParameterByName(0, "gEyePosL");
          mhTex     = mFX->GetParameterByName(0, "gTex");
          mhTime    = mFX->GetParameterByName(0, "gTime");
          mhAccel   = mFX->GetParameterByName(0, "gAccel");
          mhViewportHeight = mFX->GetParameterByName(0, "gViewportHeight");
  
          // We don't need to set these every frame since they do not change.
          HR(mFX->SetTechnique(mhTech));
          HR(mFX->SetValue(mhAccel, mAccel, sizeof(D3DXVECTOR3)));
          HR(mFX->SetTexture(mhTex, mTex));
  
          HR(gd3dDevice->CreateVertexBuffer(mMaxNumParticles*sizeof(Particle),
                  D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
                  0, D3DPOOL_DEFAULT, &mVB, 0));
  }
  
  PSystem::~PSystem()
  {
          ReleaseCOM(mFX);
          ReleaseCOM(mTex);
          ReleaseCOM(mVB);
  }
  
  float PSystem::getTime()
  {
          return mTime;
  }
  
  void PSystem::setTime(float t)
  {
          mTime = t;
  }
  
  const AABB& PSystem::getAABB()const
  {
          return mBox;
  }
  
  void PSystem::setWorldMtx(const D3DXMATRIX& world)
  {
          mWorld = world;
  
          // Compute the change of coordinates matrix that changes coordinates 
          // relative to world space so that they are relative to the particle
          // system's local space.
          D3DXMatrixInverse(&mInvWorld, 0, &mWorld);
  }
  
  void PSystem::addParticle()
  {
          if( mDeadParticles.size() > 0)
          {
                  // Reinitialize a particle.
                  Particle* p = mDeadParticles.back();
                  initParticle(*p);
  
                  // No longer dead.
                  mDeadParticles.pop_back();
                  mAliveParticles.push_back(p);
          }
  }
  
  void PSystem::onLostDevice()
  {
          HR(mFX->OnLostDevice());
  
          // Default pool resources need to be freed before reset.
          ReleaseCOM(mVB);
  }
  
  void PSystem::onResetDevice()
  {
          HR(mFX->OnResetDevice());
  
          // Default pool resources need to be recreated after reset.
          if(mVB == 0)
          {
                  HR(gd3dDevice->CreateVertexBuffer(mMaxNumParticles*sizeof(Particle),
                          D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY|D3DUSAGE_POINTS,
                          0, D3DPOOL_DEFAULT, &mVB, 0));
          }
  }
  
  void PSystem::update(float dt)
  {
          mTime += dt;
  
          // Rebuild the dead and alive list.  Note that resize(0) does
          // not deallocate memory (i.e., the capacity of the vector does
          // not change).
          mDeadParticles.resize(0);
          mAliveParticles.resize(0);
  
          // For each particle.
          for(int i = 0; i < mMaxNumParticles; ++i)
          {
                  // Is the particle dead?
                    if( (mTime - mParticles[i].initialTime) > mParticles[i].lifeTime)
                  {
                          mDeadParticles.push_back(&mParticles[i]);
                  }
                  else
                  {
                          mAliveParticles.push_back(&mParticles[i]);
                  }
          }
  
          // A negative or zero mTimePerParticle value denotes
          // not to emit any particles.
          if( mTimePerParticle > 0.0f )
          {
                  // Emit particles.
                  static float timeAccum = 0.0f;
                  timeAccum += dt;
                  while( timeAccum >= mTimePerParticle )
                  {
                          addParticle();
                          timeAccum -= mTimePerParticle;
                  }
          }
  }
  
  void PSystem::draw()
  {
          // Get camera position relative to world space system and make it 
          // relative to the particle system's local system.
          D3DXVECTOR3 eyePosW = gCamera->pos();
          D3DXVECTOR3 eyePosL;
          D3DXVec3TransformCoord(&eyePosL, &eyePosW, &mInvWorld);
  
          // Set FX parameters.
          HR(mFX->SetValue(mhEyePosL, &eyePosL, sizeof(D3DXVECTOR3)));
          HR(mFX->SetFloat(mhTime, mTime));
          HR(mFX->SetMatrix(mhWVP, &(mWorld*gCamera->viewProj())));
  
          // Point sprite sizes are given in pixels.  So if the viewport size 
          // is changed, then more or less pixels become available, which alters
          // the perceived size of the particles.  For example, if the viewport
          // is 32x32, then a 32x32 sprite covers the entire viewport!  But if
          // the viewport is 1024x1024, then a 32x32 sprite only covers a small
          // portion of the viewport.  Thus, we scale the particle's
          // size by the viewport height to keep them in proportion to the 
          // viewport dimensions.
          HWND hwnd = gd3dApp->getMainWnd();
          RECT clientRect;
          GetClientRect(hwnd, &clientRect);
          HR(mFX->SetInt(mhViewportHeight, clientRect.bottom));
  
          UINT numPasses = 0;
          HR(mFX->Begin(&numPasses, 0));
          HR(mFX->BeginPass(0));
  
          HR(gd3dDevice->SetStreamSource(0, mVB, 0, sizeof(Particle)));
          HR(gd3dDevice->SetVertexDeclaration(Particle::Decl));
  
          AABB boxWorld;
          mBox.xform(mWorld, boxWorld);
          if( gCamera->isVisible( boxWorld ) )
          {
                  // Initial lock of VB for writing.
                  Particle* p = 0;
                  HR(mVB->Lock(0, 0, (void**)&p, D3DLOCK_DISCARD));
                  int vbIndex = 0;
  
                  // For each living particle.
                  for(UINT i = 0; i < mAliveParticles.size(); ++i)
                  {
                          // Copy particle to VB
                          p[vbIndex] = *mAliveParticles[i];
                          ++vbIndex;
                  }
                  HR(mVB->Unlock());
  
                  // Render however many particles we copied over.
                  if(vbIndex > 0)
                  {
                          HR(gd3dDevice->DrawPrimitive(D3DPT_POINTLIST, 0, vbIndex));
                  }
          }
  
          HR(mFX->EndPass());
          HR(mFX->End());
  }