XNA水面效果

Technorati 标签: xna,water effect,C#,.net,hlsl

几乎所有的室外场景游戏都少不了水面效果的渲染，基中主要包括波浪效果、反射效果、折射效果等，在这之前我对它可是一无所知，现在总算是有了初步的了解，主要是归功于XNA的快速。当然，我的主要目的还是对算法进行学习。

原理我还是不说，Google一下，讲的很好的。我这里主要有1个Water类和一个VertexMultitextured结构体，还有一个Effect。

用它做法线

Water类是实现水面效果的主要类

public class Water:DrawableGameComponent
{
    #region 字段

    Camera camera;

    private VertexBuffer vb;
    private IndexBuffer ib;
    VertexMultitextured[] myVertices;
    private int myHeight = 128;
    private int myWidth = 128;

    private Vector3 myPosition;
    private Vector3 myScale;
    private Quaternion myRotation;

    Effect effect;

    private Vector3 basePosition;

    public Vector3 Position
    {
        get { return basePosition; }
        set { basePosition = value; }
    }

    private string EnvAsset;

    float bumpHeight = 0.5f;
    Vector2 textureScale = new Vector2(4, 4);
    Vector2 bumpSpeed = new Vector2(0, .05f);
    float fresnelBias = .025f;
    float fresnelPower = 1.0f;
    float hdrMultiplier = 1.0f;
    Color deepWaterColor = Color.Black;
    Color shallowWaterColor = Color.SkyBlue;
    Color reflectionColor = Color.White;
    float reflectionAmount = 0.5f;
    float waterAmount = 0f;
    float waveAmplitude = 0.5f;
    float waveFrequency = 0.1f;

    /// <summary>
    /// 水面凹凸纹理高度，最小0，最大2，默认0.5
    /// </summary>
    public float BumpHeight
    {
        get { return bumpHeight; }
        set { bumpHeight = value; }
    }
    /// <summary>
    /// 凹凸纹理缩放倍数
    /// </summary>
    public Vector2 TextureScale
    {
        get { return textureScale; }
        set { textureScale = value; }
    }
    /// <summary>
    /// 水流速度
    /// </summary>
    public Vector2 BumpSpeed
    {
        get { return bumpSpeed; }
        set { bumpSpeed = value; }
    }
    /// <summary>
    /// 0到1， 默认 0.025
    /// </summary>
    public float FresnelBias
    {
        get { return fresnelBias; }
        set { fresnelBias = value; }
    }
    /// <summary>
    ///0到10， 默认 1.0;
    /// </summary>
    public float FresnelPower
    {
        get { return FresnelPower; }
        set { fresnelPower = value; }
    }
    /// <summary>
    /// 0到100， 默认1.0
    /// </summary>
    public float HDRMultiplier
    {
        get { return hdrMultiplier; }
        set { hdrMultiplier = value; }
    }
    /// <summary>
    /// 深水处颜色;
    /// </summary>
    public Color DeepWaterColor
    {
        get { return deepWaterColor; }
        set { deepWaterColor = value; }
    }
    /// <summary>
    ///浅水处颜色
    /// </summary>
    public Color ShallowWaterColor
    {
        get { return shallowWaterColor; }
        set { shallowWaterColor = value; }
    }
    /// <summary>
    /// 反射默认颜色
    /// </summary>
    public Color ReflectionColor
    {
        get { return reflectionColor; }
        set { reflectionColor = value; }
    }
    /// <summary>
    /// 0.0 到2.0
    /// </summary>
    public float ReflectionAmount
    {
        get { return reflectionAmount; }
        set { reflectionAmount = value; }
    }

    public float WaterAmount
    {
        get { return waterAmount; }
        set { waterAmount = value; }
    }

    public float WaveAmplitude
    {
        get { return waveAmplitude; }
        set { waveAmplitude = value; }
    }

    public float WaveFrequency
    {
        get { return waveFrequency; }
        set { waveFrequency = value; }
    }

    public int Height
    {
        get { return myHeight; }
        set { myHeight = value; }
    }

    public int Width
    {
        get { return myWidth; }
        set { myWidth = value; }
    }

    #endregion

    public Water(Game game, string Environment,Camera camera): base(game)
    {
        myWidth = 256;
        myHeight = 256;

        myPosition = new Vector3(0, 0, 0);
        myScale = new Vector3(80,1,80);
        myRotation = new Quaternion(0, 0, 0, 1);

        EnvAsset = Environment;

        this.camera = camera;
    }

    protected override void LoadContent()
    {
        effect = Game.Content.Load<Effect>("Water");

        effect.Parameters["tEnvMap"].SetValue(Game.Content.Load<TextureCube>(EnvAsset));
        effect.Parameters["tNormalMap"].SetValue(Game.Content.Load<Texture2D>("waves"));

        myPosition = new Vector3(basePosition.X - (myWidth / 2), basePosition.Y, basePosition.Z - (myHeight / 2));

        // 顶点
        myVertices = new VertexMultitextured[myWidth * myHeight];

        for (int x = 0; x < myWidth; x++)
            for (int y = 0; y < myHeight; y++)
            {
                myVertices[x + y * myWidth].Position = new Vector3(y, 0, x);
                myVertices[x + y * myWidth].Normal = new Vector3(0, -1, 0);
                myVertices[x + y * myWidth].TextureCoordinate.X = (float)x / 30.0f;
                myVertices[x + y * myWidth].TextureCoordinate.Y = (float)y / 30.0f;
            }

        // 计算切线法线
        for (int x = 0; x < myWidth; x++)
            for (int y = 0; y < myHeight; y++)
            {
                // 切线数据.
                if (x != 0 && x < myWidth - 1)
                    myVertices[x + y * myWidth].Tangent = myVertices[x - 1 + y * myWidth].Position - myVertices[x + 1 + y * myWidth].Position;
                else
                    if (x == 0)
                        myVertices[x + y * myWidth].Tangent = myVertices[x + y * myWidth].Position - myVertices[x + 1 + y * myWidth].Position;
                    else
                        myVertices[x + y * myWidth].Tangent = myVertices[x - 1 + y * myWidth].Position - myVertices[x + y * myWidth].Position;

                // 法线数据.
                if (y != 0 && y < myHeight - 1)
                    myVertices[x + y * myWidth].BiNormal = myVertices[x + (y - 1) * myWidth].Position - myVertices[x + (y + 1) * myWidth].Position;
                else
                    if (y == 0)
                        myVertices[x + y * myWidth].BiNormal = myVertices[x + y * myWidth].Position - myVertices[x + (y + 1) * myWidth].Position;
                    else
                        myVertices[x + y * myWidth].BiNormal = myVertices[x + (y - 1) * myWidth].Position - myVertices[x + y * myWidth].Position;
            }

        vb = new VertexBuffer(Game.GraphicsDevice, VertexMultitextured.SizeInBytes * myWidth * myHeight, BufferUsage.WriteOnly);
        vb.SetData(myVertices);

        short[] terrainIndices = new short[(myWidth - 1) * (myHeight - 1) * 6];
        for (short x = 0; x < myWidth - 1; x++)
        {
            for (short y = 0; y < myHeight - 1; y++)
            {
                terrainIndices[(x + y * (myWidth - 1)) * 6] = (short)((x + 1) + (y + 1) * myWidth);
                terrainIndices[(x + y * (myWidth - 1)) * 6 + 1] = (short)((x + 1) + y * myWidth);
                terrainIndices[(x + y * (myWidth - 1)) * 6 + 2] = (short)(x + y * myWidth);

                terrainIndices[(x + y * (myWidth - 1)) * 6 + 3] = (short)((x + 1) + (y + 1) * myWidth);
                terrainIndices[(x + y * (myWidth - 1)) * 6 + 4] = (short)(x + y * myWidth);
                terrainIndices[(x + y * (myWidth - 1)) * 6 + 5] = (short)(x + (y + 1) * myWidth);
            }
        }

        ib = new IndexBuffer(Game.GraphicsDevice, typeof(short), (myWidth - 1) * (myHeight - 1) * 6, BufferUsage.WriteOnly);
        ib.SetData(terrainIndices);

        Game.GraphicsDevice.VertexDeclaration = new VertexDeclaration(Game.GraphicsDevice, VertexMultitextured.VertexElements);

        base.LoadContent();
    }

    public override void Update(GameTime gameTime)
    {
        effect.Parameters["fTime"].SetValue((float)gameTime.TotalRealTime.TotalSeconds);

        if (Keyboard.GetState().IsKeyDown(Keys.D1))
            WaterAmount = 0;

        if (Keyboard.GetState().IsKeyDown(Keys.D2))
        {
            WaterAmount = 1;
            ShallowWaterColor = Color.DarkSeaGreen;
            DeepWaterColor = Color.Navy;
            ReflectionColor = Color.DarkGray;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D3))
        {
            WaterAmount = 1;
            ShallowWaterColor = Color.Gold;
            DeepWaterColor = Color.Red;
            ReflectionColor = Color.White;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D4))
        {
            WaveFrequency = .5f;
            WaveAmplitude = .3f;
            BumpHeight = 1f;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D5))
        {
            WaveFrequency = .1f;
            WaveAmplitude = .1f;
            BumpHeight = .1f;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D6))
        {
            WaveFrequency = .1f;
            WaveAmplitude = .5f;
            BumpHeight = .1f;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D7))
        {
            WaveFrequency = .1f;
            WaveAmplitude = 2f;
            BumpHeight = 1f;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D8))
        {
            WaveFrequency = 0;
            WaveAmplitude = 0;
            BumpHeight = 0;
        }

        if (Keyboard.GetState().IsKeyDown(Keys.D9))
        {
            WaveFrequency = 0;
            WaveAmplitude = 0;
            BumpHeight = 1;
        }
        if (Keyboard.GetState().IsKeyDown(Keys.D0))
            SetDefault();

        base.Update(gameTime);
    }

    public override void Draw(GameTime gameTime)
    {
        Matrix World = Matrix.CreateScale(myScale) *
                        Matrix.CreateFromQuaternion(myRotation) *
                        Matrix.CreateTranslation(myPosition);

        Matrix WVP = World * camera.View * camera.Projection;
        Matrix WV = World * camera.View;
        Matrix viewI = Matrix.Invert(camera.View);

        effect.Parameters["matWorldViewProj"].SetValue(WVP);
        effect.Parameters["matWorld"].SetValue(World);
        effect.Parameters["matWorldView"].SetValue(WV);
        effect.Parameters["matViewI"].SetValue(viewI);

        effect.Parameters["fBumpHeight"].SetValue(bumpHeight);
        effect.Parameters["vTextureScale"].SetValue(textureScale);
        effect.Parameters["vBumpSpeed"].SetValue(bumpSpeed);
        effect.Parameters["fFresnelBias"].SetValue(fresnelBias);
        effect.Parameters["fFresnelPower"].SetValue(fresnelPower);
        effect.Parameters["fHDRMultiplier"].SetValue(hdrMultiplier);
        effect.Parameters["vDeepColor"].SetValue(deepWaterColor.ToVector4());
        effect.Parameters["vShallowColor"].SetValue(shallowWaterColor.ToVector4());
        effect.Parameters["vReflectionColor"].SetValue(reflectionColor.ToVector4());
        effect.Parameters["fReflectionAmount"].SetValue(reflectionAmount);
        effect.Parameters["fWaterAmount"].SetValue(waterAmount);
        effect.Parameters["fWaveAmp"].SetValue(waveAmplitude);
        effect.Parameters["fWaveFreq"].SetValue(waveFrequency);

        Game.GraphicsDevice.Vertices[0].SetSource(vb, 0, VertexMultitextured.SizeInBytes);
        Game.GraphicsDevice.Indices = ib;

        //Game.GraphicsDevice.RenderState.FillMode = FillMode.WireFrame;

        effect.Begin(SaveStateMode.SaveState);
        for (int p = 0; p < effect.CurrentTechnique.Passes.Count; p++)
        {
            effect.CurrentTechnique.Passes[p].Begin();

            Game.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, myWidth * myHeight, 0, (myWidth - 1) * (myHeight - 1) * 2);

            effect.CurrentTechnique.Passes[p].End();
        }
        effect.End();

        //Game.GraphicsDevice.RenderState.FillMode = FillMode.Solid;

        base.Draw(gameTime);
    }

    public void SetDefault()
    {
        bumpHeight = 0.5f;
        textureScale = new Vector2(4, 4);
        bumpSpeed = new Vector2(0, .05f);
        fresnelBias = .025f;
        fresnelPower = 1.0f;
        hdrMultiplier = 1.0f;
        deepWaterColor = Color.Black;
        shallowWaterColor = Color.SkyBlue;
        reflectionColor = Color.White;
        reflectionAmount = 0.5f;
        waterAmount = 0f;
        waveAmplitude = 0.5f;
        waveFrequency = 0.1f;
    }
}

而VertexMultitextured结构体主要是水面的数据

public struct VertexMultitextured
{
    public Vector3 Position;
    public Vector3 Normal;
    public Vector2 TextureCoordinate;
    public Vector3 Tangent;
    public Vector3 BiNormal;

    public static int SizeInBytes = (3 + 3 + 2 + 3 + 3) * 4;
    public static VertexElement[] VertexElements = new VertexElement[]
         {
             new VertexElement( 0, 0, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position, 0 ),
             new VertexElement( 0, sizeof(float) * 3, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Normal, 0 ),
             new VertexElement( 0, sizeof(float) * 6, VertexElementFormat.Vector2, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 0 ),
             new VertexElement( 0, sizeof(float) * 8, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Tangent, 0 ),
             new VertexElement( 0, sizeof(float) * 11, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Binormal, 0 ),
         };

}

最重要的是Shader

float fTime    : Time;

//--------------------------------------------------
// 全局变量
//--------------------------------------------------
float4x4 matWorldViewProj     : WorldViewProjection;
float4x4 matWorld             : World;
float4x4 matWorldView        : WorldView;
float4x4 matViewI             : ViewInverse;

float fBumpHeight
<
    string UIName     = "Bump Height";
    string UIWidget = "Slider";
    float  UIMin     = 0.0f;
    float  UIMax     = 2.0f;
    float  UIStep     = 0.1f;
> = 0.5f;

float2 vTextureScale
<
    string UIName     = "Texture Scale";
    string UIWidget = "Vector";
> = { 4.0f, 4.0f };

float2 vBumpSpeed
<
    string UIName     = "Bump Speed";
    string UIWidget = "Vector";
> = { -0.0f, 0.05f };

float fFresnelBias
<
    string UIName     = "Fresnel Bias";
    string UIWidget = "Slider";
    float  UIMin     = 0.0f;
    float  UIMax     = 1.0f;
    float  UIStep     = 0.1f;
> = 0.025f;

float fFresnelPower
<
    string UIName     = "Fresnel Exponent";
    string UIWidget = "Slider";
    float  UIMin     = 1.0f;
    float  UIMax     = 10.0f;
    float  UIStep     = 0.1f;
> = 1.0f;

float fHDRMultiplier
<
    string UIName     = "HDR Multiplier";
    string UIWidget = "Slider";
    float  UIMin     = 0.0f;
    float  UIMax     = 100.0f;
    float  UIStep     = 1.0f;
> = 1.0f;

float4 vDeepColor : Diffuse
<
    string UIName     = "Deep Water Color";
    string UIWidget = "Vector";
> = { 0.0f, 0.40f, 0.50f, 1.0f };

float4 vShallowColor : Diffuse
<
    string UIName     = "Shallow Water Color";
    string UIWidget = "Vector";
> = { 0.55f, 0.75f, 0.75f, 1.0f };

float4 vReflectionColor : Diffuse
<
    string UIName     = "Reflection Color";
    string UIWidget = "Vector";
> = { 1.0f, 1.0f, 1.0f, 1.0f };

float fReflectionAmount
<
    string UIName     = "Reflection Amount";
    string UIWidget = "Slider";   
    float  UIMin     = 0.0f;
    float  UIMax     = 2.0f;
    float  UIStep     = 0.1f;   
> = 0.5f;

float fWaterAmount
<
    string UIName     = "Water Color Amount";
    string UIWidget = "Slider";   
    float  UIMin     = 0.0f;
    float  UIMax     = 2.0f;
    float  UIStep     = 0.1f;   
> = 0.5f;

float fWaveAmp
<
    string UIName     = "Wave Amplitude";
    string UIWidget = "Slider";
    float  UIMin     = 0.0f;
    float  UIMax     = 10.0f;
    float  UIStep     = 0.1f;
> = 0.5f;

float fWaveFreq
<
    string UIName     = "Wave Frequency";
    string UIWidget = "Slider";
    float  UIMin     = 0.0f;
    float  UIMax     = 1.0f;
    float  UIStep     = 0.001f;
> = 0.1f;

texture tNormalMap : Normal
<
    string UIName        = "Normal Map";
    string ResourceName = "waves2.dds";
    string TextureType = "2D";
>;

texture tEnvMap : Environment
<
    string UIName        = "Environment Map";
    string ResourceName = "CloudyHillsCubemap2.dds";
    string TextureType     = "Cube";
>;

sampler2D s0 = sampler_state {
    Texture = (tNormalMap);
    MipFilter     = Linear;
    MinFilter     = Linear;
    MagFilter     = Linear;
};

samplerCUBE s1 = sampler_state {
    Texture = (tEnvMap);
    MinFilter     = Linear;
    MagFilter     = Linear;
    MipFilter     = Linear;
};

//--------------------------------------------------
// Vertex shader
//--------------------------------------------------
struct VSOUTPUT {
    float4 vPos                : POSITION;
    float2 vTex                : TEXCOORD0;
    float3 vTanToCube[3]    : TEXCOORD1;
    float2 vBump0            : TEXCOORD4;
    float2 vBump1            : TEXCOORD5;
    float2 vBump2            : TEXCOORD6;
    float3 vView            : TEXCOORD7;
};

// 水波
struct Wave {
    float    fFreq;    // 频率 (2PI / 波长)
    float    fAmp;    // 振幅
    float    fPhase;    // 相伴 (速度 * 2PI / 波长)
    float2    vDir;    // 方向
};

#define NUMWAVES    3
Wave Waves[NUMWAVES] = {
    { 1.0f, 1.00f, 0.50f, float2( -1.0f, 0.0f ) },
    { 2.0f, 0.50f, 1.30f, float2( -0.7f, 0.7f ) },
    { .50f, .50f, 0.250f, float2( 0.2f, 0.1f ) },
};

float EvaluateWave( Wave w, float2 vPos, float fTime ) {
    return w.fAmp * sin( dot( w.vDir, vPos ) * w.fFreq + fTime * w.fPhase );
}

float EvaluateWaveDifferential( Wave w, float2 vPos, float fTime ) {
    return w.fAmp * w.fFreq * cos( dot( w.vDir, vPos ) * w.fFreq + fTime * w.fPhase );
}

float EvaluateWaveSharp( Wave w, float2 vPos, float fTime, float fK )
{
  return w.fAmp * pow( sin( dot( w.vDir, vPos ) * w.fFreq + fTime * w.fPhase )* 0.5 + 0.5 , fK );
}

float EvaluateWaveSharpDifferential( Wave w, float2 vPos, float fTime, float fK )
{
  return fK * w.fFreq * w.fAmp * pow( sin( dot( w.vDir, vPos ) * w.fFreq + fTime * w.fPhase )* 0.5 + 0.5 , fK - 1 ) * cos( dot( w.vDir, vPos ) * w.fFreq + fTime * w.fPhase );
}

VSOUTPUT VS_Water( float4 inPos : POSITION, float3 inNor : NORMAL, float2 inTex : TEXCOORD0,
                   float3 inTan : TANGENT, float3 inBin : BINORMAL ) {
    VSOUTPUT OUT = (VSOUTPUT)0;
    // 产生水波
    Waves[0].fFreq     = fWaveFreq;
    Waves[0].fAmp     = fWaveAmp;

    Waves[1].fFreq     = fWaveFreq * 2.0f;
    Waves[1].fAmp     = fWaveAmp * 0.5f;
    Waves[2].fFreq     = fWaveFreq * 3.0f;
    Waves[2].fAmp     = fWaveAmp * 1.0f;

    // 水波总数
    inPos.y = 0.0f;
    float ddx = 0.0f, ddy = 0.0f;
    for( int i = 0; i < NUMWAVES; i++ ) {
        inPos.y += EvaluateWave( Waves[i], inPos.xz, fTime );
        float diff = EvaluateWaveDifferential( Waves[i], inPos.xz, fTime);
        ddx += diff * Waves[i].vDir.x;
        ddy += diff * Waves[i].vDir.y;
    }

    // 输出position
    OUT.vPos = mul( inPos, matWorldViewProj );
    // 门生法线图texture coordinates
    OUT.vTex = inTex * vTextureScale;

    fTime = fmod( fTime, 100.0 );
    OUT.vBump0 = inTex * vTextureScale + fTime * vBumpSpeed;
    OUT.vBump1 = inTex * vTextureScale * 2.0f + fTime * vBumpSpeed * 4.0;
    OUT.vBump2 = inTex * vTextureScale * 4.0f + fTime * vBumpSpeed * 8.0;

    // 计算切线
    float3 vB = float3( 1,  ddx, 0 );
    float3 vT = float3( 0,  ddy, 1 );
    float3 vN = float3( -ddx, 1, -ddy );

    // Compute the tangent space to object space matrix
    float3x3 matTangent = float3x3( fBumpHeight * normalize( vT ),
                                    fBumpHeight * normalize( vB ),
                                    normalize( vN ) );
    OUT.vTanToCube[0] = mul( matTangent, matWorld[0].xyz );
    OUT.vTanToCube[1] = mul( matTangent, matWorld[1].xyz );
    OUT.vTanToCube[2] = mul( matTangent, matWorld[2].xyz );

    // 计算世界空间向量
    float4 vWorldPos = mul( inPos, matWorld );
    OUT.vView = matViewI[3].xyz - vWorldPos;
    return OUT;
}

//--------------------------------------------------
// Pixel shader
//--------------------------------------------------
float3 Refract( float3 vI, float3 vN, float fRefIndex, out bool fail )
{
    float fIdotN = dot( vI, vN );
    float k = 1 - fRefIndex * fRefIndex * ( 1 - fIdotN * fIdotN );
    fail = k < 0;
    return fRefIndex * vI - ( fRefIndex * fIdotN + sqrt(k) )* vN;
}

float4 PS_Water( VSOUTPUT IN ) : COLOR0 {

    // Fetch the normal maps (with signed scaling)
    float4 t0 = tex2D( s0, IN.vBump0 ) * 2.0f - 1.0f;
    float4 t1 = tex2D( s0, IN.vBump1 ) * 2.0f - 1.0f;
    float4 t2 = tex2D( s0, IN.vBump2 ) * 2.0f - 1.0f;

    float3 vN = t0.xyz + t1.xyz + t2.xyz;  

    // Compute the tangent to world matrix
    float3x3 matTanToWorld;
    matTanToWorld[0] = IN.vTanToCube[0];
    matTanToWorld[1] = IN.vTanToCube[1];
    matTanToWorld[2] = IN.vTanToCube[2];
    float3 vWorldNormal = mul( matTanToWorld, vN );
    vWorldNormal = normalize( vWorldNormal );

    // 计算反射向量
    IN.vView = normalize( IN.vView );
    float3 vR = reflect( -IN.vView, vWorldNormal );
    // Sample the cube map
    float4 vReflect = texCUBE( s1, vR.zyx );   
    vReflect = texCUBE( s1, vR );
    // Exaggerate the HDR effect
    vReflect.rgb *= ( 1.0 + vReflect.a * fHDRMultiplier );

    // Compute the Fresnel term
    float fFacing  = 1.0 - max( dot( IN.vView, vWorldNormal ), 0 );
    float fFresnel = fFresnelBias + ( 1.0 - fFresnelBias ) * pow( fFacing, fFresnelPower);

    // 计算最终颜色
    float4 vWaterColor = lerp( vDeepColor, vShallowColor, fFacing );

    return vWaterColor * fWaterAmount + vReflect * vReflectionColor * fReflectionAmount * fFresnel;
}

//--------------------------------------------------
// Techniques
//--------------------------------------------------
technique techDefault {
    pass p0 {
        CullMode        = None;
        VertexShader    = compile vs_2_0 VS_Water();
        PixelShader        = compile ps_2_0 PS_Water();
    }
}  

好了，代码出来了，下面可以看下实现后的效果。

   

有波浪的水面

平静的水面

这里也只算是一个比较基本的水面效果，而且出不够真实。还可以去完善一下。