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

        void OnResetDevice(IDirect3DDevice9* pDevice); 

        IDirect3DTexture9* m_Texture; 

        int           m_iWidth;

        int           m_iHeight;

        int           m_iMipLevels;

        D3DFORMAT     m_TexFormat;

        bool          m_bUseDepthBuffer;

        D3DFORMAT     m_DepthFormat;

        D3DVIEWPORT9* m_ViewPort;

        bool          m_bAutoGenMip;

};

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

class NXWater

{

    protected:

        IDirect3DDevice9*  m_pDevice;

        ID3DXEffect*       m_pEffect;

        ID3DXMesh*         m_pMesh;

        IDirect3DTexture9* m_pReflectTex;

        IDirect3DTexture9* m_pRefractTex;

        IDirect3DTexture9* m_pMaskTex;

        DepthTexture*     m_pDepthTex;

        DepthTexture*      m_pDepthTex2;

       

        IDirect3DTexture9* m_pFresnelTex;

        IDirect3DTexture9* m_pNormalsTex;

        IDirect3DSurface9* m_pBackBuffer;     

        NXWaterCore        m_Core;

       

    public:

        NXWater();

        ~NXWater(); 

        void Init(float fLevel = 0.0f, float fClipShift = 0.0f);

        void InitProjection(float fCameraFOV, D3DXMATRIX* pMatrix); 

        void OnInitDevice(IDirect3DDevice9* pDevice);

        void OnDestroyDevice();

        void OnResetDevice();

        void OnLostDevice();

        void CreateRegularGrid(int iXCount, int iZCount, float fXWidth, float fZWidth);

        void Render(D3DXMATRIX& mView, D3DXMATRIX& mProj); 

        void SetParams(float fTime, D3DXVECTOR3& vEye);

        void SetReflectRefract(bool bReflect, bool bRefract);

        void SaveReflectionTexture();

        void SaveRefractionTexture();

        void SaveMaskTexture(); 

            inline void SetNormalMap(IDirect3DTexture9* tex)

            {

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

            } 
 

        inline void SetTech(LPCSTR sTech)

        {

            m_pEffect->SetTechnique(sTech);

        }

        inline void SetDistortionScale(float fScale)

        {

            D3DXVECTOR4 v = D3DXVECTOR4( 0.16f, 0.14f, -0.12f, -0.12f ) * fScale;

           

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

        }       

        inline IDirect3DTexture9* reflecttex() { return m_pReflectTex; }

        inline IDirect3DTexture9* refracttex() { return m_pRefractTex; }

        inline DepthTexture* depthtex()     { return m_pDepthTex; }

            inline DepthTexture* depthtex2()    { return m_pDepthTex2; } 

        inline NXWaterCore& Core() { return m_Core; } 

            void DepthPostProcessing(D3DXMATRIX& mView, D3DXMATRIX& mProj);

};

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

#endif 

NXWater.cpp

#include "NXWater.h" 

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

HRESULT NXCreateRegularGrid(LPD3DXMESH* ppMesh, LPDIRECT3DDEVICE9 pDevice,

                            UINT iXCount, UINT iZCount, float fXWidth, float fZWidth,

                            D3DXVECTOR3 vCenter)

{

    HRESULT hr = S_OK; 

    struct MeshVertex

    {

        D3DXVECTOR3 Position;

        D3DXVECTOR3 Normal;

    };

    DWORD dwFVF = D3DFVF_XYZ | D3DFVF_NORMAL; 

    DWORD dwVertices = iXCount * iZCount;

    DWORD dwFaces = (iXCount - 1) * (iZCount - 1) * 2; 

    // 1. we don't read data from this mesh, so use WRITEONLY flag to increase performance

    // 2. using MANAGED pool for storing buffers is necessary to avoid recreating them on every device init

    DWORD dwOptions = D3DXMESH_WRITEONLY | D3DXMESH_MANAGED; 

    UINT i,j; 

    if (FAILED(hr = D3DXCreateMeshFVF(dwFaces, dwVertices, dwOptions, dwFVF, pDevice, ppMesh)))

        return hr; 

    MeshVertex* pVertices;

    WORD*       pIndices; 

    //заполняем буфер вершин

    if (FAILED(hr = (*ppMesh)->LockVertexBuffer(0,(VOID**)&pVertices)))

        return hr; 

    float fXStep = fXWidth / (iXCount - 1);

    float fZStep = fZWidth / (iZCount - 1); 

    for(i=0;i<iXCount;i++)

    {

        for(j=0;j<iZCount;j++)

        {

            pVertices[i*iZCount+j].Position = D3DXVECTOR3( - 0.5f * fXWidth + fXStep * i, 0.0f, - 0.5f * fZWidth + fZStep * j ) + vCenter;

            pVertices[i*iZCount+j].Normal   = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );

        }

    } 

    (*ppMesh)->UnlockVertexBuffer();

    // завершено 

    //заполняем буфер индексов

    if (FAILED(hr = (*ppMesh)->LockIndexBuffer(0,(VOID**)&pIndices)))

        return hr; 

    for(i=0;i<iXCount-1;i++)

    {

        for(j=0;j<iZCount-1;j++)

        {

            *pIndices++ = WORD(iZCount*i     + j + 1);

            *pIndices++ = WORD(iZCount*(i+1) + j);

            *pIndices++ = WORD(iZCount*i     + j); 

            *pIndices++ = WORD(iZCount*i     + j + 1);

            *pIndices++ = WORD(iZCount*(i+1) + j + 1);

            *pIndices++ = WORD(iZCount*(i+1) + j);

        }

    } 

    (*ppMesh)->UnlockIndexBuffer();

    // завершено 

    return hr;

}

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

D3DXMATRIX NXObliqueFrustumCulling(D3DXPLANE& plane, D3DXMATRIX& view, D3DXMATRIX& proj)

{

    D3DXMATRIX mClipProj;

    D3DXMatrixIdentity(&mClipProj); 

    D3DXMATRIX mWorldToProjection = view * proj;

    D3DXMatrixInverse(&mWorldToProjection, NULL, &mWorldToProjection);

    D3DXMatrixTranspose(&mWorldToProjection, &mWorldToProjection); 

    // plane definition (world space)

    D3DXPlaneNormalize(&plane, &plane); 

    D3DXVECTOR4 clipPlane(plane.a, plane.b, plane.c, plane.d);

    D3DXVECTOR4 projClipPlane; 

    // transform clip plane into projection space

    D3DXVec4Transform(&projClipPlane, &clipPlane, &mWorldToProjection);

    if (projClipPlane.w == 0) // or less than a really small value

        // plane is perpendicular to the near plane

        return proj;

    else if (projClipPlane.w > 0)

    {

        // flip plane to point away from eye

        D3DXVECTOR4 clipPlane(-plane.a, -plane.b, -plane.c, -plane.d);

        // transform clip plane into projection space

        D3DXVec4Transform(&projClipPlane, &clipPlane, &mWorldToProjection);

    }

        // put projection space clip plane in Z column

    mClipProj(0, 2) = projClipPlane.x;

    mClipProj(1, 2) = projClipPlane.y;

    mClipProj(2, 2) = projClipPlane.z;

    mClipProj(3, 2) = projClipPlane.w; 

    // multiply into projection matrix

    D3DXMATRIX mProjClip = proj * mClipProj;

    return mProjClip;

}

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

NXWaterCore:: NXWaterCore()

{

    m_fLevel = 0.0f;

    m_fShift = 0.0f;

    m_fFOV   = 0.0f; 

    D3DXMatrixIdentity(&m_mProj);

    D3DXMatrixIdentity(&m_mTex);

    m_mTex._11 =  0.5f;

    m_mTex._41 =  0.5f;