ch17p2_tiletransition_onevb.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:
  virtual void Setup(int iIndexX, int iIndexY, float x, float y, int iNumTilesX, int iNumTilesY, int iVBIndex, VERTEX_XYZ_DIFFUSE_TEX1 *pVerts)
  {
    m_fX = x; m_fY = y; m_iNumTilesX = iNumTilesX; m_iNumTilesY = iNumTilesY; m_iVBIndex = iVBIndex;
    m_iIndexX = iIndexX; m_iIndexY = iIndexY;

    float fWidth = 2.0f / (float)iNumTilesX;
    float fHeight = 2.0f / (float)iNumTilesY;

    // first tri
    
    pVerts[iVBIndex].color = 0;
    pVerts[iVBIndex].position = D3DXVECTOR3(x+fWidth,y+fHeight,0);
    pVerts[iVBIndex].tu = (float)(m_iIndexX+1) / (iNumTilesX);
    pVerts[iVBIndex].tv = 1.0f-((float)(m_iIndexY+1) / (iNumTilesY));

    pVerts[iVBIndex+1].color = 0;
    pVerts[iVBIndex+1].position = D3DXVECTOR3(x+fWidth,y,0);
    pVerts[iVBIndex+1].tu = (float)(m_iIndexX+1) / (iNumTilesX);
    pVerts[iVBIndex+1].tv = 1.0f-((float)m_iIndexY / (iNumTilesY));

    pVerts[iVBIndex+2].color = 0;
    pVerts[iVBIndex+2].position = D3DXVECTOR3(x,y,0);
    pVerts[iVBIndex+2].tu = (float)m_iIndexX / (iNumTilesX);
    pVerts[iVBIndex+2].tv = 1.0f-((float)m_iIndexY / (iNumTilesY));
    
    // second tri
    pVerts[iVBIndex+3].color = 0;
    pVerts[iVBIndex+3].position = D3DXVECTOR3(x,y+fHeight,0);
    pVerts[iVBIndex+3].tu = (float)(m_iIndexX) / (iNumTilesX);
    pVerts[iVBIndex+3].tv = 1.0f-((float)(m_iIndexY+1) / (iNumTilesY));


    pVerts[iVBIndex+4].color = 0;
    pVerts[iVBIndex+4].position = D3DXVECTOR3(x+fWidth,y+fHeight,0);
    pVerts[iVBIndex+4].tu = (float)(m_iIndexX+1) / (iNumTilesX);
    pVerts[iVBIndex+4].tv = 1.0f-((float)(m_iIndexY+1) / (iNumTilesY));
    
    pVerts[iVBIndex+5].color = 0;
    pVerts[iVBIndex+5].position = D3DXVECTOR3(x,y,0);
    pVerts[iVBIndex+5].tu = (float)(m_iIndexX) / (iNumTilesX);
    pVerts[iVBIndex+5].tv = 1.0f-((float)(m_iIndexY) / (iNumTilesY));
    
  }
  virtual void Update(float fElapsedTime, VERTEX_XYZ_DIFFUSE_TEX1 *pVerts) = 0;
  virtual void SetDuration(float fDuration) { m_fDuration = fDuration; }

  float GetDelay(void) const { return(m_fDelay); }
  void SetDelay(const float data) { m_fDelay = data; }
  
protected:
  float m_fX;
  float m_fY;
  int m_iIndexX;
  int m_iIndexY;
  int m_iNumTilesX;
  int m_iNumTilesY;
  int m_iVBIndex;
  float m_fDuration;
  
  float m_fDelay;
};

class CTileTransitionBehavior_Shrink : public CTileBehavior
{
public:
  virtual void Setup(int iIndexX, int iIndexY, float x, float y, int iNumTilesX, int iNumTilesY, int iVBIndex, VERTEX_XYZ_DIFFUSE_TEX1 *pVerts);
  virtual void Update(float fElapsedTime, VERTEX_XYZ_DIFFUSE_TEX1 *pVerts);
};

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!");
  }
  
  // now create the tile VB
  {
    if(FAILED(pDev->CreateVertexBuffer(iNumTilesX*iNumTilesY*6*sizeof(VERTEX_XYZ_DIFFUSE_TEX1),
              0, D3DFVF_XYZ_DIFFUSE_TEX1, D3DPOOL_MANAGED, &m_pVBTiles)))
      throw("Can't create vertex buffer!");

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

    int index=0;
    for (int x=0; x < iNumTilesX; x++) {
      for (int y=0; y < iNumTilesY; y++) {
        TTileBehavior tb;
        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, index, pVertices);
        m_Tiles.push_back(tb);
        index += 6;
      }
    }
    if(FAILED(m_pVBTiles->Unlock())) throw("Can't unlock!");
  }
  
  SetDuration(100.0f);
}


  virtual ~CTileTransition()
  {
    SAFE_RELEASE(m_pVBQuad);
    SAFE_RELEASE(m_pVBTiles);
  }

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

    if (m_fFadeTime < m_fDuration) {
      HRESULT hr;
      VERTEX_XYZ_DIFFUSE_TEX1* pVertices; 
 
      if( FAILED( hr = m_pVBTiles->Lock( 0, m_iNumTilesX*m_iNumTilesY*6*sizeof(VERTEX_XYZ_DIFFUSE_TEX1), 
          (BYTE**)&pVertices, 0 ) ) )
        return;

      int index=0;
      for (int x=0; x < m_iNumTilesX; x++) {
        for (int y=0; y < m_iNumTilesY; y++) {
          m_Tiles[index++].Update(fTransTime, pVertices);
        }
      }
      if(FAILED(hr = m_pVBTiles->Unlock())) return;
    }
  }

  void DoRender(void)
  {  
    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->SetStreamSource( 0, m_pVBTiles, sizeof(VERTEX_XYZ_DIFFUSE_TEX1) );
    m_pd3dDevice->SetVertexShader( D3DFVF_XYZ_DIFFUSE_TEX1 );
    m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, m_iNumTilesX*m_iNumTilesY*2);
  }

  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;
  LPDIRECT3DVERTEXBUFFER8 m_pVBTiles;
  LPDIRECT3DTEXTURE8 m_pNewImage;

};

#endif