ch17p2_tiletransition.h

游戏开发特殊技巧-special.effects.game.programming

#ifndef CH17P2_TileTransition_DEFINED
#define CH17P2_TileTransition_DEFINED

#include "Ch17p2_Transition.h"
#include "MinMax.h"
#include <vector>

class CTileBehavior
{
public:
  CTileBehavior() { m_pVBTile = NULL; }
  virtual ~CTileBehavior() { SAFE_RELEASE(m_pVBTile); }

  virtual void Render(D3DXMATRIX mFinal)
  {
    // set local xform matrix
    m_pd3dDevice->SetTransform( D3DTS_WORLD, &mFinal );
    m_pd3dDevice->SetStreamSource( 0, m_pVBTile, sizeof(VERTEX_XYZ_DIFFUSE_TEX1) );
    m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
  }

  virtual void Setup(int iIndexX, int iIndexY, float x, float y, int iNumTilesX, int iNumTilesY, LPDIRECT3DDEVICE8 pDev)
  {
    D3DXMatrixIdentity( &m_matPosition );

    m_fX = x; m_fY = y; m_iNumTilesX = iNumTilesX; m_iNumTilesY = iNumTilesY;
    m_iIndexX = iIndexX; m_iIndexY = iIndexY;
    m_pd3dDevice = pDev;

    float fU1 = ((float)iIndexX / (float)iNumTilesX);
    float fU2 = ((float)(iIndexX+1) / (float)iNumTilesX);

    float fV1 = ((float)(iNumTilesY-iIndexY) / (float)iNumTilesY);
    float fV2 = ((float)(iNumTilesY-iIndexY-1) / (float)iNumTilesY);

    if(FAILED(pDev->CreateVertexBuffer(6*sizeof(VERTEX_XYZ_DIFFUSE_TEX1),
                    0, D3DFVF_XYZ_DIFFUSE_TEX1, D3DPOOL_MANAGED, &m_pVBTile)))
      throw("Can't create tile VB!");

    VERTEX_XYZ_DIFFUSE_TEX1 *pVertices;
    
    if( FAILED(m_pVBTile->Lock( 0, 6*sizeof(VERTEX_XYZ_DIFFUSE_TEX1), (BYTE**)&pVertices, 0 ) ) )
        throw("Can't lock VB!");

    // first triangle
    pVertices[0].position = D3DXVECTOR3(-1.0f, 1.0f, 0.0f);
    pVertices[0].color    = 0;
    pVertices[0].tu       = fU1;
    pVertices[0].tv       = fV2;

    pVertices[1].position = D3DXVECTOR3(1.0f, 1.0f, 0.0f);
    pVertices[1].color    = 0;
    pVertices[1].tu       = fU2;
    pVertices[1].tv       = fV2;

    pVertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f);
    pVertices[2].color    = 0;
    pVertices[2].tu       = fU2;
    pVertices[2].tv       = fV1;

    // second triangle
    pVertices[3].position = D3DXVECTOR3(-1.0f, 1.0f, 0.0f);
    pVertices[3].color    = 0;
    pVertices[3].tu       = fU1;
    pVertices[3].tv       = fV2;

    pVertices[4].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f);
    pVertices[4].color    = 0;
    pVertices[4].tu       = fU2;
    pVertices[4].tv       = fV1;

    pVertices[5].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f);
    pVertices[5].color    = 0;
    pVertices[5].tu       = fU1;
    pVertices[5].tv       = fV1;

    if(FAILED(m_pVBTile->Unlock())) throw("Can't unlock!");
  }
  virtual void Update(float fElapsedTime) = 0;
  virtual void SetDuration(float fDuration) { m_fDuration = fDuration; }

protected:
  D3DXMATRIX m_matPosition;
  float m_fX;
  float m_fY;
  int m_iIndexX;
  int m_iIndexY;
  int m_iNumTilesX;
  int m_iNumTilesY;
  float m_fDuration;
  
  LPDIRECT3DDEVICE8 m_pd3dDevice;
  LPDIRECT3DVERTEXBUFFER8 m_pVBTile;

};

class CTileTransitionBehavior_Shrink : public CTileBehavior
{
public:
  virtual void Setup(int iIndexX, int iIndexY, float x, float y, int iNumTilesX, int iNumTilesY, LPDIRECT3DDEVICE8 pDev);
  virtual void Update(float fElapsedTime);
  virtual void Render(D3DXMATRIX mFinalScale);
protected:
  float m_fScaleFactor;
  float m_fFadeTime;
};

class CTileTransitionBehavior_TwirlAndShrink : public CTileBehavior
{
public:
  virtual void Setup(int iIndexX, int iIndexY, float x, float y, int iNumTilesX, int iNumTilesY, LPDIRECT3DDEVICE8 pDev);
  virtual void Update(float fElapsedTime);
  virtual void Render(D3DXMATRIX mFinalScale);
protected:
  float m_fScaleFactor;
  float m_fFadeTime;
};

template <class TTileBehavior> 
class CTileTransition : public CTransition
{
public:
  CTileTransition(LPDIRECT3DDEVICE8 pDev, LPDIRECT3DTEXTURE8 pOrigImage, LPDIRECT3DTEXTURE8 pNewImage,
    int iNumTilesX, int iNumTilesY)
  {
  m_pNewImage = pNewImage;
  m_pOrigImage = pOrigImage;
  m_pd3dDevice = pDev;
  m_fFadeTime = 0;
  m_iNumVertsX = iNumTilesX+1;
  m_iNumVertsY = iNumTilesY+1;
  m_iNumTilesX = iNumTilesX;
  m_iNumTilesY = iNumTilesY;
  
  // create vertex buffer for one quad
  if (FAILED(CreateQuad(&m_pVBQuad, D3DPOOL_MANAGED, 2, 0, pDev))) {
    throw("Error creating quad vertex buffer!");
  }

  for (int x=0; x < iNumTilesX; x++) {
    for (int y=0; y < iNumTilesY; y++) {
      TTileBehavior *tb = new TTileBehavior;
      float fx = (2.0f / (float)iNumTilesX * x)-1.0f;
      float fy = (2.0f / (float)iNumTilesY * y)-1.0f;

      tb->Setup(x, y, fx, fy, iNumTilesX, iNumTilesY, m_pd3dDevice);
      m_Tiles.push_back(tb);
    }
  }
  
  SetDuration(100.0f);
}


  virtual ~CTileTransition()
  {
    SAFE_RELEASE(m_pVBQuad);
    for (std::vector<TTileBehavior *>::iterator i=m_Tiles.begin(); i != m_Tiles.end(); i++) {
      delete (*i);
    }
  }

  virtual void DoTransition(float fTransTime)
  {
    m_fFadeTime += fTransTime;

    if (m_fFadeTime < m_fDuration) {
      for (std::vector<TTileBehavior *>::iterator i=m_Tiles.begin(); i != m_Tiles.end(); i++) {
          (*i)->Update(fTransTime);
      }
    }
  }

  void DoRender(D3DXMATRIX mFinalScale)
  {  
    m_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

    // set up our texture stages 
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1 );

    // no bilinear filtering!
    /*m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_POINT);
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_POINT);
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER, D3DTEXF_POINT);
    */
    if (m_fFadeTime > 0.0f) {
      // set up texture stage states 
      m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
      m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE );
      m_pd3dDevice->SetTexture( 0, m_pNewImage);
  
      m_pd3dDevice->SetStreamSource(0, m_pVBQuad, sizeof(VERTEX_XYZ_DIFFUSE_TEX1));
      m_pd3dDevice->SetVertexShader(D3DFVF_XYZ_DIFFUSE_TEX1);
      m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
    }

    // set our texture active...
    m_pd3dDevice->SetTexture( 0, m_pOrigImage );
 
    // draw our mesh
    m_pd3dDevice->SetVertexShader( D3DFVF_XYZ_DIFFUSE_TEX1 );
    
    
    for (std::vector<TTileBehavior *>::iterator i=m_Tiles.begin(); i != m_Tiles.end(); i++) {
      (*i)->Render(mFinalScale);
    }
    

    //(*(m_Tiles.begin()+rand() % 25))->Render(mFinalScale);

  }

  virtual void SetDuration(const float data)
  { 
    CTransition::SetDuration(data);
    
    for (std::vector<TTileBehavior *>::iterator i=m_Tiles.begin(); i != m_Tiles.end(); i++) {
      (*i)->SetDuration(data);
    }
  }

  
protected:
  std::vector<TTileBehavior *> m_Tiles;
  float m_fFadeTime;
  int m_iNumVertsX, m_iNumVertsY;
  int m_iNumTilesX, m_iNumTilesY;
  CMinMax<float> m_FallSpeed;
  
  LPDIRECT3DVERTEXBUFFER8 m_pVBQuad;
  LPDIRECT3DTEXTURE8 m_pNewImage;

};

#endif