XNA中的HLSL简单应用

以前一直没搞明白HLSL，最近两天苦下功夫，终于算是学到了HLSL入门了。

这里我将通过对一个矩形模型以BassicEffect贴图和通过HLSL贴图作对比，从而掌握在XNA中使用.fx效果文件，和初步了解HLSL。

下面先分析一下没有使用贴图时的代码：

 

  1    public class Game1 : Game
  2    {
  3        GraphicsDeviceManager graphics;
  4        SpriteBatch spriteBatch;
  5
  6        //投影矩阵 
  7        Matrix projection;
  8        //观察矩阵 
  9        Matrix view;
 10        //矩形的世界矩阵 
 11        Matrix world;
 12        //矩形模型 
 13        Model cub;
 14
 15        //定义贴图纹理和效果（先声明，暂时不使用） 
 16
 17        Texture2D text;
 18        Effect effe;
 19
 20        //是否在暂停状态 
 21        bool isPause = false;
 22
 23        KeyboardState preks = Keyboard.GetState();
 24
 25        public Game1()
 26        {
 27            graphics = new GraphicsDeviceManager(this);
 28            Content.RootDirectory = "Content";
 29        }
 30
 31        protected override void Initialize()
 32        {
 33            //初始化投影矩阵 
 34            projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, GraphicsDevice.Viewport.AspectRatio, 1f, 100000f);
 35
 36            //初始化观察矩阵 
 37            view = Matrix.CreateLookAt(Vector3.Forward * 500, Vector3.Zero, Vector3.Up);
 38
 39            //初始化矩形的世界矩阵 
 40            world = Matrix.Identity;
 41
 42            base.Initialize();
 43        }
 44
 45        protected override void LoadContent()
 46        {
 47            // Create a new SpriteBatch, which can be used to draw textures. 
 48            spriteBatch = new SpriteBatch(GraphicsDevice);
 49
 50
 51            //载入矩形模型 
 52            cub = Content.Load<Model>("cub");
 53
 54            //载入贴图纹理（暂时不使用） 
 55            text = Content.Load<Texture2D>("rocks");
 56
 57            //载入效果（暂时不使用） 
 58            effe = Content.Load<Effect>("effe");
 59
 60            //设置效果的Technique 
 61            effe.CurrentTechnique = effe.Techniques["Technique1"];
 62
 63        }
 64
 65        protected override void Update(GameTime gameTime)
 66        {
 67
 68            //当前按键状态 
 69            KeyboardState ks = Keyboard.GetState();
 70
 71            //按S镜头拉远，W镜头拉近 
 72            if (ks.IsKeyDown(Keys.S))
 73            {
 74                view *= Matrix.CreateTranslation(-10 * Vector3.UnitZ);
 75            }
 76
 77            if (ks.IsKeyDown(Keys.W))
 78            {
 79                view *= Matrix.CreateTranslation(10 * Vector3.UnitZ);
 80
 81            }
 82
 83            //通过空格键控制是否暂停 
 84            if (ks.IsKeyDown(Keys.Space) && preks.IsKeyUp(Keys.Space))
 85            {
 86                if (isPause)
 87                {
 88                    isPause = false;
 89                }
 90                else
 91                {
 92                    isPause = true;
 93                }
 94            }
 95
 96            //控制FillMode 
 97            if (ks.IsKeyDown(Keys.A) && preks.IsKeyUp(Keys.A))
 98            {
 99                GraphicsDevice.RenderState.FillMode = FillMode.WireFrame;
            }

            if (ks.IsKeyDown(Keys.Q) && preks.IsKeyUp(Keys.Q))
            {
                GraphicsDevice.RenderState.FillMode = FillMode.Solid;
            }

            preks = ks;

            //如果不是暂停状态，自动旋转矩形的世界矩阵，实现旋转效果 
            if (!isPause)
            {
                world *= Matrix.CreateFromAxisAngle(new Vector3(1, 1, -1), gameTime.ElapsedGameTime.Ticks * 0.0000001f);
            }
            base.Update(gameTime);
        }

        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            foreach (ModelMesh mesh in cub.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.World = world;
                    effect.View = view;
                    effect.Projection = projection;
                    effect.EnableDefaultLighting();
                }
                mesh.Draw();
            }
            base.Draw(gameTime);
        }
    } 

 

可以看到程序的高度效果如下：

现在我们为例子加入贴图（即前面声名的Texture），因为是使用的Basiceffect类的方法，所以很简单，只需要在foreach (BasicEffect effect in mesh.Effects)的循环体中插入以下代码，

 

 

effect.TextureEnabled = true; 
effect.Texture = text; 

 

再来看一下效果：

上面就是XNA中最简单的纹理贴图的方法，下面就将进入主要的部分——HLSL渲染。

首先看一段很经典的HLSL代码：

 

 1//声明一个4x4的矩阵。传入的参数是世界、观察、投影矩阵的积 
 2Float4x4 mWorldViewProjection; 
 3
 4//定义一个VertexShader函数，作为入口，并返回值的语义为POSITION 
 5float4 vs_main(float4 position:POSITION):POSITION 
 6{ 
 7
 8    //将传入的坐标顶点与世界观察投影矩阵相乘，一交完成三个顶点的交换 
 9     return mul(position,mWorldViewProjection); 
} 

//定义一个PixelShader函数，作为入口，并定义返回语义为COLOR0 
Float4 ps_main():COLOR0 
{ 
    //固定返回白色作为显示颜色 
     Return float4(1,1,1,1); 
} 

//开始定义Technique 
technique technique1 
{ 
    //一个pass 
     pass pass0 
     { 
        //将VertexShader的版本设置为1.1，并将执行函数设置为vs_main 
        VertexShader=compile vs_1_1 vs_main(); 
        //将PixelShader的版本设置为1.1，并将执行函数设置为ps_main 
        PixelShader=compile ps_1_1 ps_main(); 
} 

} 

  

这段代码中包含了一个全局变量，两个全局函数。这两个全局函数分别用于VertexShader和PixelShader，也直接作为VertexShader和PixelShader的入口函数。而全局变量则用在了VertexShader的计算中。代码中定义了一个technique并且包含了一个pass，在这个pass中VertexShader和PixelShader的版本都是1.1。

使用这段代码去渲染任何一个模型，得到的都是一个白色的物体。

在XNA中使用HLSL的代码如下：

 

 1        protected override void Draw(GameTime gameTime)
 2        {
 3            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 4
 5            //设置HLSL参数 
 6            effe.Parameters["mWorldViewProjection"].SetValue(world * view * projection);
 7            effe.Begin();
 8            foreach (EffectPass pass in effe.CurrentTechnique.Passes)
 9            {
                pass.Begin();
                foreach (ModelMesh mesh in cub.Meshes)
                {
                    foreach (ModelMeshPart part in mesh.MeshParts)
                    {
                        GraphicsDevice.VertexDeclaration = part.VertexDeclaration;
                        GraphicsDevice.Indices = mesh.IndexBuffer;
                        GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, part.StartIndex, part.VertexStride);
                        GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, part.BaseVertex, 0, part.NumVertices, part.StartIndex, part.PrimitiveCount);
                    }
                }
                pass.End();
            }
            effe.End();

            base.Draw(gameTime);
        }

 

效果如下图：

让我们再近一步，用HLSL为我们的贴上纹理。

 

修改Draw方法如下：

 

 1        protected override void Draw(GameTime gameTime)
 2        {
 3            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 4            
 5            effe.Parameters["World"].SetValue(world);
 6            effe.Parameters["View"].SetValue(view);
 7            effe.Parameters["Projection"].SetValue(projection);
 8            
 9            //下面的参数text类型为Texture 
            effe.Parameters["diffuseTexture"].SetValue(text);

            effe.Begin();
            foreach (EffectPass pass in effe.CurrentTechnique.Passes)
            {
                pass.Begin();
                foreach (ModelMesh mesh in cub.Meshes)
                {
                    foreach (ModelMeshPart part in mesh.MeshParts)
                    {
                        GraphicsDevice.VertexDeclaration = part.VertexDeclaration;
                        GraphicsDevice.Indices = mesh.IndexBuffer;
                        GraphicsDevice.Vertices[0].SetSource(mesh.VertexBuffer, part.StartIndex, part.VertexStride);
                        GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, part.BaseVertex, 0, part.NumVertices, part.StartIndex, part.PrimitiveCount);
                    }
                }
                pass.End();
            }
            effe.End();

            base.Draw(gameTime);
        } 

 

HLSL代码如下：

 

 1float4x4 World; 
 2float4x4 View; 
 3float4x4 Projection; 
 4texture diffuseTexture:Diffuse; 
 5sampler DiffuseTextureSampler = sampler_state 
 6{ 
 7    Texture = <diffuseTexture>; 
 8    MinFilter=linear; 
 9    MagFilter=linear; 
    MipFilter=linear; 
}; 

struct VertexShaderInput 
{ 
    float4 Position : POSITION0; 
    float3 normal:NORMAL; 
    float2 uv:TEXCOORD0; 
}; 

struct VertexShaderOutput 
{ 
    float4 Position : POSITION0; 
    float2 uv:TEXCOORD0; 
}; 

VertexShaderOutput VertexShaderFunction(VertexShaderInput input) 
{ 
    VertexShaderOutput output; 

    float4 worldPosition = mul(input.Position, World); 
    float4 viewPosition = mul(worldPosition, View); 
    output.Position = mul(viewPosition, Projection); 
    output.uv=input.uv; 

    return output; 
} 

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0 
{ 
    return tex2D(DiffuseTextureSampler,input.uv); 
} 

technique Technique1 
{ 
    pass Pass1 
    { 
        VertexShader = compile vs_1_1 VertexShaderFunction(); 
        PixelShader = compile ps_1_1 PixelShaderFunction(); 
    } 
}         

 

渲染效果如下图所示：

就此，我也算对HLSL有了更近步的了解，以后在做的就是多多分析高手写好的HSLS代码。