Моделирование и визуализация водных поверхностей

>    m_mTex._22 = -0.5f;

    m_mTex._42 =  0.5f;

}

//--------------------------------------------------------------------------

NXWaterCore::~NXWaterCore() {}

//--------------------------------------------------------------------------

void NXWaterCore::Init(float fLevel, float fShift)

{

    m_fLevel = fLevel;

    m_fShift = fShift; 

    D3DXVECTOR3 vPoint      ( 0.0f, fLevel, 0.0f );

    D3DXVECTOR3 vPointUp    ( 0.0f, fLevel + fShift, 0.0f );

    D3DXVECTOR3 vPointDown  ( 0.0f, fLevel - fShift, 0.0f );

    D3DXVECTOR3 vNormalUp   ( 0.0f,  1.0f, 0.0f );

    D3DXVECTOR3 vNormalDown ( 0.0f, -1.0f, 0.0f ); 

    D3DXPlaneFromPointNormal( &m_plNormal, &vPoint, &vNormalUp );

    D3DXPlaneFromPointNormal( &m_plLower, &vPointDown, &vNormalUp );

    D3DXPlaneFromPointNormal( &m_plUpper, &vPointUp, &vNormalDown );

    D3DXMatrixReflect( &m_mReflect, &m_plNormal );

}

//--------------------------------------------------------------------------

void NXWaterCore::RebuildProjectionMatrix(float fFOV)

{

    m_fFOV = fFOV; 

    float fAspect = m_mProj(0,0) / m_mProj(1,1);

    float fh = 1.0f / tanf(0.5f * fFOV);

    m_mProj(1,1) = fh;

    m_mProj(0,0) = fh * fAspect;

}

//--------------------------------------------------------------------------

void NXWaterCore::InitProjectionMatrix(float fFOV, D3DXMATRIX* pMatrix)

{

    if (pMatrix)

    {

        m_mProj = *pMatrix;

        RebuildProjectionMatrix(fFOV);

    }

}

//--------------------------------------------------------------------------

DepthTexture::DepthTexture(int iWidth, int iHeight,D3DFORMAT TexFormat)

{

    m_Texture         = NULL;

    m_TopSurface      = NULL;

    m_RTS             = NULL; 

    m_iWidth          = iWidth;

    m_iHeight         = iHeight;

    m_iMipLevels      = 1; 

    m_bUseDepthBuffer = true;

    m_bAutoGenMip     = false; 

    m_TexFormat       = TexFormat;

    m_DepthFormat     = D3DFMT_D24S8; 

    m_ViewPort        = 0;

} 

DepthTexture::~DepthTexture()

{

    OnLostDevice();

} 

void DepthTexture::OnLostDevice()

{

    SafeRelease(m_Texture);

    SafeRelease(m_RTS);

    SafeRelease(m_TopSurface);

} 

void DepthTexture::OnResetDevice(IDirect3DDevice9* pDevice)

{ 

    D3DXCreateTexture(pDevice, m_iWidth, m_iHeight, m_iMipLevels, D3DUSAGE_RENDERTARGET, m_TexFormat, D3DPOOL_DEFAULT, &m_Texture);

    D3DXCreateRenderToSurface(pDevice, m_iWidth, m_iHeight, m_TexFormat, m_bUseDepthBuffer, m_DepthFormat, &m_RTS);

    m_Texture->GetSurfaceLevel(0, &m_TopSurface);

} 

void DepthTexture::BeginScene()

{

    m_RTS->BeginScene(m_TopSurface, m_ViewPort);

} 

void DepthTexture::EndScene()

{

    m_RTS->EndScene(D3DX_FILTER_LINEAR);

}

//--------------------------------------------------------------------------

NXWater:: NXWater()

{

    m_pDevice     = NULL;

    m_pMesh       = NULL;

    m_pEffect     = NULL; 

    m_pReflectTex = NULL;

    m_pRefractTex = NULL;

    m_pMaskTex    = NULL;

   

    m_pFresnelTex = NULL;

    m_pNormalsTex = NULL;

    m_pBackBuffer = NULL;

   

    Init();

}

//--------------------------------------------------------------------------

NXWater::~NXWater()

{

}

//--------------------------------------------------------------------------

void NXWater::Init(float fLevel, float fClipShift)

{

    m_Core.Init(fLevel, fClipShift);

}

//--------------------------------------------------------------------------

void NXWater::InitProjection(float fCameraFOV, D3DXMATRIX* pMatrix)

{

    m_Core.InitProjectionMatrix(fCameraFOV, pMatrix);

}

//--------------------------------------------------------------------------

void NXWater::OnInitDevice(IDirect3DDevice9* pDevice)

{

    m_pDevice = pDevice;

    m_pDevice->AddRef(); 

    D3DXCreateEffectFromFile(m_pDevice, L"water.fx", NULL, NULL, 0, NULL, &m_pEffect, NULL ); 

    D3DXCreateTextureFromFile(m_pDevice, L"Media/fresnel.dds", &m_pFresnelTex);

    D3DXCreateTextureFromFile(m_pDevice, L"Media/normalmap.jpg", &m_pNormalsTex); 

    m_pEffect->SetTexture( "NormalMap", m_pNormalsTex );

    m_pEffect->SetTexture( "FresnelMap", m_pFresnelTex ); 

    SafeRelease( m_pFresnelTex );

    SafeRelease( m_pNormalsTex ); 

    CreateRegularGrid(2, 2, 1.0, 1.0);  

}

//--------------------------------------------------------------------------

void NXWater::OnDestroyDevice()

{

    SafeRelease( m_pMesh ); 

    SafeRelease( m_pEffect );

    SafeRelease( m_pDevice );

}

//--------------------------------------------------------------------------

void NXWater::OnLostDevice()

{

    SafeRelease(m_pReflectTex);

    SafeRelease(m_pRefractTex);

    SafeRelease(m_pMaskTex);

    m_pDepthTex->OnLostDevice();

    m_pDepthTex2->OnLostDevice();

    delete m_pDepthTex;

    delete m_pDepthTex2; 

    SafeRelease(m_pBackBuffer);   

    m_pEffect->OnLostDevice();

}

//--------------------------------------------------------------------------

void NXWater::OnResetDevice()

{

    D3DSURFACE_DESC desc;

    m_pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &m_pBackBuffer);

    m_pBackBuffer->GetDesc(&desc); 

    UINT w = desc.Width, h = desc.Height;

    D3DXCreateTexture(m_pDevice, w, h, 1, D3DUSAGE_RENDERTARGET, desc.Format, D3DPOOL_DEFAULT, &m_pReflectTex);

    D3DXCreateTexture(m_pDevice, w, h, 1, D3DUSAGE_RENDERTARGET, desc.Format, D3DPOOL_DEFAULT, &m_pRefractTex);

    D3DXCreateTexture(m_pDevice, w, h, 1, D3DUSAGE_RENDERTARGET, desc.Format, D3DPOOL_DEFAULT, &m_pMaskTex);

    m_pDepthTex=new DepthTexture(w, h, D3DFMT_R32F);

    m_pDepthTex2=new DepthTexture(w, h, D3DFMT_R32F); 

    m_pDepthTex->OnResetDevice(m_pDevice);

    m_pDepthTex2->OnResetDevice(m_pDevice); 

    m_pEffect->OnResetDevice();

    m_pEffect->SetTexture( "ReflectMap", m_pReflectTex );

    m_pEffect->SetTexture( "RefractMap", m_pRefractTex );

    m_pEffect->SetTexture( "MaskMap", m_pMaskTex );

    m_pEffect->SetTexture( "DepthMap", m_pDepthTex->m_Texture );

      m_pEffect->SetTexture( "DepthMap2", m_pDepthTex2->m_Texture );

}

//--------------------------------------------------------------------------

void NXWater::CreateRegularGrid(int iXCount, int iZCount, float fXWidth, float fZWidth)

{

    SafeRelease(m_pMesh); 

    D3DXVECTOR3 v(0, 0, 0);

    NXCreateRegularGrid(&m_pMesh, m_pDevice, iXCount, iZCount, fXWidth, fZWidth, v);

}

//--------------------------------------------------------------------------

void NXWater::Render(D3DXMATRIX& mView, D3DXMATRIX& mProj)

{

    D3DXMATRIX mViewProj = mView * mProj;

    D3DXMATRIX mTex      = mView * m_Core.ProjExMatrix() * m_Core.ScreenToTexMatrix();

    D3DXMATRIX mWorld;

    D3DXMatrixTranslation(&mWorld, 0, m_Core.GetLevel(), 0); 

    m_pEffect->SetMatrix("g_mWorld", &mWorld);

    m_pEffect->SetMatrix("g_mViewProj", &mViewProj);

    m_pEffect->SetMatrix("g_mTex", &mTex);   

    UINT uPasses;

    m_pEffect->Begin( &uPasses, 0 );

    for(UINT iPass = 0; iPass < uPasses; iPass++ )

    {

        m_pEffect->BeginPass( iPass );

        m_pMesh->DrawSubset(0);

        m_pEffect->EndPass();

    }

    m_pEffect->End();

}

//--------------------------------------------------------------------------

void NXWater::SetParams(float fTime, D3DXVECTOR3& vEye)

{

    D3DXVECTOR4 v(0, 0, 0, 1);

    memcpy(&v, &vEye, sizeof(vEye));

    m_pEffect->SetFloat( "g_fTime", fTime );

    m_pEffect->SetVector( "g_vEyePos", &v );

}

//--------------------------------------------------------------------------

void NXWater::SetReflectRefract(bool bReflect, bool bRefract)

{

    m_pEffect->SetBool( "g_bReflect", bReflect );

    m_pEffect->SetBool( "g_bRefract", bRefract );

}

//--------------------------------------------------------------------------