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

void NXWater::SaveReflectionTexture()

{

    IDirect3DSurface9* pSurface = NULL;

    m_pReflectTex->GetSurfaceLevel(0, &pSurface);

    m_pDevice->StretchRect(m_pBackBuffer, 0, pSurface, 0, D3DTEXF_LINEAR);

    SafeRelease(pSurface);

}

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

void NXWater::SaveRefractionTexture()

{

    IDirect3DSurface9* pSurface = NULL;

    HRESULT s= m_pRefractTex->GetSurfaceLevel(0, &pSurface);

    s=m_pDevice->StretchRect(m_pBackBuffer, 0, pSurface, 0, D3DTEXF_LINEAR);

    SafeRelease(pSurface);

}

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

void NXWater::SaveMaskTexture()

{

    IDirect3DSurface9* pSurface = NULL;

    m_pMaskTex->GetSurfaceLevel(0, &pSurface);

    m_pDevice->StretchRect(m_pBackBuffer, 0, pSurface, 0, D3DTEXF_LINEAR);

    SafeRelease(pSurface);

}

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

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

{

      struct vert

      {

                  float x, y, z;

                  float u, v;

      };

      vert v[4] = { { -1, 1, 0, 0, 0 }, { 1, 1, 0, 1, 0 }, { 1, -1, 0, 1, 1 }, { -1, -1, 0, 0, 1 } }; 

      m_pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_TEX1);  

      D3DXVECTOR4 vOffset(1.0f/640.0f, 1.0f/480.0f, 0, 0); 

  D3DXMATRIX mViewInv=mView;

  D3DXMatrixInverse(&mViewInv, 0, &mViewInv); 

      m_pEffect->SetMatrix("g_mViewInv", &mViewInv); 

      m_pEffect->SetMatrix("g_mProj", &mProj);

      m_pEffect->SetVector("g_vOffset", &vOffset); 

      float c=Core().GetLevel();

      m_pEffect->SetFloat("g_fWaterLevel", c); 

      UINT nPasses = 0;

      m_pEffect->Begin(&nPasses, 0);

      for(UINT i = 0; i < nPasses; i++)

      {

                   m_pEffect->BeginPass(i);

                   m_pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, v, sizeof(vert));

                   m_pEffect->EndPass();

      }

      m_pEffect->End();

}

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

Файл эффекта, реализующий численное решение  волнового уравнения physics.fx 

texture tex0; 

float h;

float p = 0.01f;

float mu;

float c; 
 

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

//Samplers

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

sampler TexSampler0 = sampler_state

{

    Texture  = <tex0>; 

    AddressU = WRAP;

    AddressV = WRAP; 

    MinFilter = LINEAR;

    MagFilter = LINEAR;

    MipFilter = LINEAR;

}; 

struct VS_OUTPUT

{

    float4 pos: POSITION0;

    float4 uv: TEXCOORD0;  

}; 

VS_OUTPUT PhysicsVS(float4 vpos:POSITION0, float4 vtex:TEXCOORD0 )

{

   VS_OUTPUT output;

   output.pos = vpos;

   output.uv = vtex;

   return output;

}

struct PS_OUTPUT

{

    float4 col1: COLOR0;

    float4 col2: COLOR1;

}; 

PS_OUTPUT PhysicsPS(float4 vtex: TEXCOORD0)

{   

    PS_OUTPUT output;

    float2 c1 = tex2D(TexSampler0, vtex);  //u_i_j      

    float  c2 = tex2D(TexSampler0, float2(vtex.x-h, vtex.y)); //u_i-1_j

    float  c3 = tex2D(TexSampler0, float2(vtex.x+h, vtex.y)); //u_i+1_j

    float  c4 = tex2D(TexSampler0, float2(vtex.x, vtex.y-h)); //u_i_j-1

    float  c5 = tex2D(TexSampler0, float2(vtex.x, vtex.y+h)); //u_i_j+1 

    float temp = c2 + c3 + c4 + c5 - 4.0 * c1.r;

    temp *= p * p * c / h / h;

    temp += 2.0 * c1.r + (mu * p / 2.0 - 1.0) * c1.g; 

    temp *= 2.0 / (2.0 + mu * p);

    float norm1 = 0.5*(c2 - c3) + 0.5;

    float norm2 = 0.5*(c4 - c5) + 0.5;    

    output.col1 = float4(temp,c1.r,0.0, 0.0);

    output.col2 = float4(norm1, norm2, 1.0, 0.0);

    return output;

} 
 

VS_OUTPUT PhysicsSplashVS(float4 vpos:POSITION0, float4 uv:TEXCOORD0)

{

   VS_OUTPUT res;

   res.pos = vpos;

   res.uv = uv;

   return res;

} 

float4 PhysicsSplashPS(float4 uv:TEXCOORD0):COLOR0

{

   

    float c1 = tex2D(TexSampler0, uv);  //u_i_j      

    return float4(c1 - 0.3f, 0.0f, 0.0f, 0.0f); 

} 

technique Physics

{

    pass P0

   {

        VertexShader = compile vs_2_0 PhysicsVS();

        PixelShader  = compile ps_2_0 PhysicsPS();

    }

 

}

technique Splash

{

    pass P0

    {

        VertexShader = compile vs_2_0 PhysicsSplashVS();

        PixelShader  = compile ps_2_0 PhysicsSplashPS();

    }

}