Learning XNA 3.0 phần 7 pptx

The vertex shader function is listed in the file as: VertexShaderOutput VertexShaderFunctionVertexShaderInput input { VertexShaderOutput output; float4 worldPosition = mulinput.Positio

Don’t be too scared by this code It looks a bit different than what you’re used to inXNA, but we’ll explore each section of the code here so you can figure out what it’sdoing.

First, let’s look at the first three lines of the file:

Variables that are in this global space can be set from your XNAcode (You’ll seemore about how to do that later, when you apply this code to an actual project.)When using an HLSL file in XNA, one of the first things to do is look for what vari-ables need to be set from the XNA code

Look Familiar?

Remember where you’ve used theworld,view, andprojection variables in the past?You used them to set theWorld,View, andProjectionproperties of theBasicEffectclass The following code sets those variables, and it should be similar to what you have

in the Drawmethod of your BasicModelclass in the source code you completed inChapter 12:

foreach (BasicEffect be in mesh.Effects)

Now that you’re looking at branching out and using HLSL instead of theBasicEffectclass, it probably won’t surprise you to see some of the same properties you’ve used intheBasicEffect class show up in the HLSL file itself

Dissecting a Sample HLSL Effect File | 281

Just like when you’re programming in C or C++, in HLSL, variables and functionsneed to be defined before they are used This means that a typical flow for an HLSLfile will have variables at the top, followed by structs, functions, and finally theshader calls themselves

When reading an HLSL file, it typically makes sense to read it in the order in which itwill be executed So, let’s next skip to the bottom of the code in the sample file.Here’s the section of the file that uses thetechnique keyword:

technique Technique1

{

pass Pass1

{

VertexShader = compile vs_1_1 VertexShaderFunction( );

PixelShader = compile ps_1_1 PixelShaderFunction( );

}

}

Each HLSL effect file will have one or more techniques In your XNAcode, you’llspecify which technique to run when applying an HLSL file by referring to the name

of the technique, which in this case isTechnique1

Inside the technique section, notice that there is a subsection called a pass Eachtechnique has one or more passes When you draw in XNAusing a custom HLSLeffect file, you’ll set the technique as mentioned earlier and then loop through all thepasses to draw each of them This particular technique has only one pass (Pass1).Each pass can contain a vertex and/or pixel shader To implement a shader, yourHLSL file must set the value of theVertexShaderand/orPixelShaderobject(s) equal

to a compiled vertex or pixel shader function

Let’s look at those two lines in more depth:

VertexShader = compile vs_1_1 VertexShaderFunction( );

PixelShader = compile ps_1_1 PixelShaderFunction( );

TheVertexShaderand PixelShaderobjects are HLSL objects whose names must bespelled exactly that way and are case-sensitive The keyword compile tells XNAtocompile the method that follows using a certain version of vertex shader or pixelshader (in this case, you’re compiling using vertex shader version 1.1, as specified byvs_1_1, and pixel shader version 1.1, as specified by ps_1_1) The functions(VertexShaderFunction( )andPixelShaderFunction( )) were defined earlier in the file.The first of those to be called is the vertex shader, so next we’ll look at the vertexshader function

The vertex shader function is listed in the file as:

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)

{

VertexShaderOutput output;

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

return output;

}

The first thing you’ll probably notice is that as an input type the function accepts astructof typeVertexShaderInput (which was defined earlier in the file) The returntype is also astructand is of typeVertexShaderOutput(which was also defined ear-lier in the file) Let’s take another look at these twostructs:

There’s really nothing unusual about these structs, other than one thing that you

may not have seen before: an HLSL semantic ThePOSITION0code that appears aftereach of the variable definitions is an HLSL semantic

HLSL code uses semantics to link data from the XNAgame that is using the HLSLcode When a semantic is specified on a variable, HLSL will automatically assign avalue to that variable based on the semantic given This is essentially a way to con-nect variables in HLSL with certain data to which the XNA game has access

In this case, the vertex shader method accepts a parameter of typeVertexShaderInput, which contains a variable with a semantic ofPOSITION0 Specify-ing thePOSITION0semantic on thePositionvariable causes HLSL to automatically setthat variable to a position value that is provide by the XNA game

What position value will be automatically assigned? Remember that a vertex shaderruns once for every visible vertex, so the position given via thePOSITION0semantic in

a vertex shader is the position of the vertex

There are several other possible vertex shader input semantics, in addition toPOSITION0 These are listed in Table 13-1

Table 13-1 Valid input semantics for vertex shaders

Dissecting a Sample HLSL Effect File | 283

You probably noticed that the vertex shader returns astruct as well, and that thatstructalso has a semantic ofPOSITION0associated with it While the semantic is thesame, the meaning is different in this case because it is used as a vertex shader out-put rather than an input The meaning of different semantics varies depending onwhether the variable using a particular semantic is being used for a pixel shader or avertex shader and whether it is being specified as input or output in that shader.For example, the semantics that can be applied to vertex shader output are differentthan those that can be applied to vertex shader input Vertex shader output seman-tics are listed in Table 13-2

So, when the POSITION0 semantic is applied to an input parameter in the vertexshader, HLSL automatically assigns the vertex position to that parameter, but in con-trast, a semantic specified on an output parameter is used to flag a variable ascontaining specific data

Earlier, you read that the minimum job of any vertex shader is to set the positions ofall vertices in the scene, which is done by specifying an output parameter with thePOSITION[n] semantic Essentially, your vertex output needs to set the position ofeach vertex But how do you do this, given that there’s novertex.positionvariable

or anything like that to set? That’s where the output semantic comes in By returning

Table 13-2 Valid output semantics for vertex shaders

POSITION[n] Position of a vertex in homogenous space Compute position in

screen-space by dividing (x, y, z) by w Every vertex shader must write out a parameter with this semantic.

float4

Table 13-1 Valid input semantics for vertex shaders (continued)

a value in a variable that has a semantic ofPOSITION0, you’re specifying a return valuethat denotes a position.

Freaking out about this? Don’t worry Let’s take a look at the actual vertex shaderfunction For your convenience, the function and thestructs it uses are shown againhere:

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

return output;

}

The first thing this code does is create a variable of typeVertexShaderOutputso that itcan return that datatype at the end of the function Notice that thatstructhas a vari-able calledPositionthat has a semantic ofPOSITION0 Again, the basic responsibility

of a vertex shader is to set the position of each vertex You can set the position byreturning a value tied to a semantic ofPOSITION0 So, by returning an object of typeVertexShaderOutput, you’ll be setting the position of the vertex, assuming that youset thePosition member of thatVertexShaderOutput struct

Next, the vertex shader function creates a variable calledworldPositionand sets thevalue of that variable to the result of themulfunction What is themulfunction? This

is what’s called an intrinsic function in HLSL: it’s a function that HLSL provides for

developers to manipulate data Afull list of intrinsic functions will be provided later

in this chapter This particular function (mul) multiplies two matrices together.First, the vertex shader function multiplies the position of the vertex (input.Position)

by theWorldmatrix How do you know thatinput.Positionrepresents the position ofthe vertex? Well, once again, this comes back to semantics The input variable is oftypeVertexShaderInput, which is astructdefined prior to the definition of the ver-tex shader function TheVertexShaderInput structhas one member:Position ThePosition member of thatstruct has a semantic of POSITION0 When thePOSITION0

Dissecting a Sample HLSL Effect File | 285

semantic is tied to a variable used for vertex shader input, the position of the vertex

is automatically assigned to that variable

Next, the vertex shader function multiplies the resulting matrix by the camera view

It then multiplies that resulting matrix by the camera projection and assigns thatvalue to the output parameter, which it returns All of that matrix multiplication setsthe position of the vertex to the correct place, given the position and direction of thecamera

I know what you’re thinking: “Whoa hold on a second You’re

tell-ing me that if you multiply the position of a vertex by the object’s

world matrix, then multiply that by the camera’s view matrix, and

then multiply that by the camera’s projection matrix, it will magically

set the position of the vertex to the correct place?”

Well, yes And “magic” is really a good term for it You don’t really

need to understand how all of this works, and such a discussion would

go way deeper into matrix multiplication than we want to in this

book But yes, multiplying those matrices together in that order will

yield the correct position for the vertex That just goes to show how

fascinating and how powerful matrix multiplication can be.

You might also be wondering how the code sets the position of each vertex in thescene when only one position variable is returned from the function Remember thatthe vertex shader will be run for every vertex in the scene For example, if you drew atriangle and then ran this HLSL file to render that triangle, your vertex shader wouldrun once for each vertex (there are vertices in a triangle, so the vertex shader wouldrun three times)

The parameter passed into the vertex shader has a semantic ofPOSITION0, which willcause that variable to be automatically filled with the value representing the position

of the vertex So, if the vertices of the triangle you draw are (0, 1, 0), (1, 0, 0), and (–1,

0, 0), your vertex shader will run three times: the first time the input parameter valuewill be (0, 1, 0), the second time the input parameter value will be (1, 0, 0), and thethird time the value will be (–1, 0, 0)

This may seem like a lot of confusing code, semantics, shaders, and so forth Yourhead may be spinning But that’s OK Here are the key points to remember so far:

• Global variables that aren’t given semantics or initial values need to be set fromXNA code

• The name of the technique to run in your HLSL file needs to be set from XNAcode

• An input parameter with a semantic will automatically receive the data sented by that semantic when the HLSL effect is executed (for example, an inputparameter in a vertex shader with a semantic ofPOSITION0will automatically beset to a value representing the position of the vertex)

repre-• An output variable with a semantic flags that variable as having a specific type ofdata for processing in the effect This is how you “set” data in HLSL If you need

to “set” the position of a vertex in a vertex shader, you return a variable with asemantic ofPOSITION0

• A vertex shader has different semantics for input and output

• At a minimum, a vertex shader needs to specify aPOSITION[n] semantic for output.Once the vertex shader finishes, the pixel shader will run Let’s look at the pixelshader that was created in the effect file:

float4 PixelShaderFunction( ) : COLOR0

even-Finally, notice the strange semantic on the function itself:

float4 PixelShaderFunction( ) : COLOR0

This is another way of specifying a semantic for a return type You can also specify

an input semantic in the parameter list rather than using astruct For example, thefollowing method returns a color and accepts one as well:

float myShader(float COLOR0) : COLOR0

Valid output semantics for pixel shaders are shown in Table 13-4

Table 13-3 Valid input semantics for pixel shaders

VFACE Floating-point scalar that indicates a back-facing primitive A negative value

faces backward, while a positive value faces the camera.

float

Table 13-4 Valid output semantics for pixel shaders

Semantic Description Type

COLOR[n] Output color float4

DEPTH[n] Output depth float

Applying an HLSL Effect in C# | 287

As mentioned earlier, the minimum job of a pixel shader is to set the color for eachindividual pixel In this case, the pixel shader function is returning afloatwith theCOLOR0semantic to accomplish that The function contains only one line of code, andwith that line, returns the color red:

return float4(1, 0, 0, 1);

Because the function itself has a semantic ofCOLOR0, returning afloat4 (which canrepresent color) will “set” the color for that pixel You may be wondering how thisfunction sets the color of each pixel in the scene Remember that a pixel shader isrun for each pixel in the scene If you drew a triangle and then used this HLSL effectfile to render that triangle, this pixel shader would run for every pixel that are com-posing that part of the triangle Depending on the size of the triangle and the size ofthe screen, that could be 10 times, 100 times, 1,000 times, or more Each time thepixel shader returns a value, it returns that value with a semantic ofCOLOR0, indicat-ing that the value being returned represents the new color of that particular pixel Inthis example, the return value is always red (RGBA1, 0, 0, 1), so every pixel will becolored red You could change the color depending on the position of the pixel orbased on some texture file or whatever else you might want to do, and that would letyou color every pixel in the scene differently

After running the pixel shader, the pass is finished Because there was only one pass

in this code, the HLSL file is now finished, and the data will be sent to the screen.The vertex shader set the positions of all the vertices in the world and the pixelshader colored all the pixels red, so applying this effect file to a scene should result ineverything in the scene being colored red In the next section, we’ll apply the file tosome primitives to see if that is actually the case

Applying an HLSL Effect in C#

In this section, we’ll be using the source code for the textured rectangle project fromChapter 9 You might remember this project as the one that created the cool rectanglewith a tree image texture Running the project will result in the familiar tree rectan-gle that you saw back when you first started the 3D section (see Figure 13-2)

Currently, the rectangle is drawn using theBasicEffectclass You’re going to changethat so it uses an effect created from an HLSL file that you generate The first thing to

do is create a subfolder under the Content node in your project by right-clicking the Content node in Solution Explorer and selecting Add➝New Folder Name the new

folder Effects.

Next, right-click the Content\Effects folder in Solution Explorer and select Add ➝

New Item Select Effect File as the template on the right and name the file Red.fx,

as shown in Figure 13-3

Figure 13-2 Pretty, pretty rectangle ahhhhh

Figure 13-3 Creating a new effect file

float4 worldPosition = mul(input.Position, World);

float4 viewPosition = mul(worldPosition, View);

output.Position = mul(viewPosition, Projection);

VertexShader = compile vs_1_1 VertexShaderFunction( );

PixelShader = compile ps_1_1 PixelShaderFunction( );

}

}

You can verify that your effect code will compile by compiling your solution If youget no compilation errors, you know that your code is at least syntactically correct(that’s a good sign)

To use your effect in code, you need to create a variable of typeEffectto store theeffect in memory Create a class-levelEffect variable in yourGame1 class:

Effect effect;

Next, you’ll need to load the effect into yourEffectobject via the content pipeline.Add the following code to theLoadContent method of yourGame1 class:

effect = Content.Load<Effect>(@"effects\red");

Finally, you’ll need to remove the following code in your Drawmethod, which usestheBasicEffect class to draw:

BasicEffect effect = new BasicEffect(GraphicsDevice, null);

effect.World = worldRotation * worldTranslation * worldRotation;

The second line of the code in this listing may be different in your

project This was because at the end of Chapter 9, I encouraged you to

try different combinations of worldRotations and worldTranslations in

the setting of the effect.World variable Don’t worry about that; just

replace the preceding code section with the one listed next.

Replace that code with the following code, which uses your newEffectfile instead

of theBasicEffect class:

If you’ve been playing with your code from Chapter 9 or tweaking it by following theexercises in this book, your code may be somewhat different than what I have used

in this chapter thus far To clarify, here’s what your Game1class should look like atthis point:

Passing Data from XNA to HLSL

There are two different ways to get data from XNAto your HLSL effect file One way

is by using semantics As discussed earlier in this chapter, if you create a variable that

is used as an input variable to a vertex shader or a pixel shader and assign a semantic

to that variable, the appropriate data will automatically be set to that variable when thefunction is run

The other way to get data to HLSL from XNAis to manually set parameters As yousaw earlier, only certain types of data can be passed via semantics (things like posi-tions, colors, texture coordinates, and so on) However, you can pass anything youwant to an HLSL file via manual parameters To do this, you define a global variable

in your HLSL file and you set the parameter using theeffect.Parameters[].SetValuemethod shown in the preceding code

Matrix worldTranslation = Matrix.Identity;

Matrix worldRotation = Matrix.Identity;

verts = new VertexPositionTexture[4];

verts[0] = new VertexPositionTexture(

new Vector3(-1, 1, 0), new Vector2(0, 0));

verts[1] = new VertexPositionTexture(

new Vector3(1, 1, 0), new Vector2(1, 0));

verts[2] = new VertexPositionTexture(

new Vector3(-1, -1, 0), new Vector2(0, 1));

verts[3] = new VertexPositionTexture(

new Vector3(1, -1, 0), new Vector2(1, 1));

//Load effect

Figure 13-4 A red rectangle using a custom effect file!

Applying HLSL Using Textures | 295

Applying HLSL Using Textures

Coloring a rectangle red requires only the simplest HLSL shader, and it’s somethingyou’ll rarely find in the latest video games Typically, you’ll be applying a texture to

an object and then tweaking the way the texture appears by applying shininess or fog

or some other effect

In this section, you’ll apply a custom HLSL file to your rectangle while applyingcolor from the trees texture as well

Open your Red.fx file again and replace the code in the file with the code shown

magfilter = LINEAR; minfilter = LINEAR; mipfilter=LINEAR;

AddressU = mirror; AddressV = mirror;};

struct VertexIn

{

float4 position : POSITION;

float2 textureCoordinates : TEXCOORD0;

};

struct VertexOut

{

float4 Position : POSITION;

float2 textureCoordinates : TEXCOORD0;

};

VertexOut VertexShader(VertexIn input)

{

VertexOut Output = (VertexOut)0;

Output.Position =mul(input.position, xWorldViewProjection);

pass Pass0

{

VertexShader = compile vs_1_1 VertexShader( );

PixelShader = compile ps_1_1 PixelShader( );

}

}

While you’re still new to HLSL, this file isn’t incredibly complex, and for the most part

it should make sense to you Notice first that instead of using three variables to sent the world, view, and projection matrices, respectively, you have only one variable,called xWorldViewProjection In your XNAcode, you’ll need to multiply the world,view, and projection matrices together and assign the resulting value to this variable.Because they are all multiplied together to set the vertex position, it doesn’t matter ifyou do that in the HLSL file or in XNAcode The advantage of doing the multiplica-tion in XNAcode rather than in the HLSL file is that you do the multiplication onceper scene if you pass it into the HLSL code, whereas doing the multiplication withinHLSL will cause it to be done once for every vertex

repre-Also, notice the new variable calledxColoredTexture This variable represents a ture object, and you’ll need to assign it the value of yourTexture object from yourXNA code

tex-There’s also a ColoredTextureSamplerobject that allows you to sample data from atexture to determine the color of a particular part of that texture When the pixelshader runs, it will map each pixel on the object to the corresponding location in thetexture by using the sampler object and will return the color that the pixel shouldhave

Notice that the pixel shader uses atex2Dmethod to accomplish this.tex2Dis a tion that is built into HLSL, much likemul, which you used previously to multiplytogether two matrices.tex2Dlooks up a color at a particular point in a texture using asampler Essentially, you’ll be running your pixel shader for every pixel on thescreen, right? Each time the pixel shader runs, you’re going to receive a texture coor-dinate for that pixel (it’s passed into the pixel shader via the textureCoordinatesmember of theVertexOut struct) Thetex2Dfunction will take those texture coordi-nates, look up the corresponding pixel in the texture at each coordinate, and returnthe color of that pixel Using this method, the entire rectangle will be colored to lookjust like the texture you’re passing to the HLSL effect file

func-In addition to mul and tex2D, there are a number of other built-in functions (alsocalled intrinsic functions) in HLSL These functions are listed in Microsoft’s MSDNlibrary for help on DirectX and XNA For your convenience, they are also shown inTable 13-5

Applying HLSL Using Textures | 297

Table 13-5 Intrinsic functions in HLSL

abs(x) Returns the absolute value (per component)

acos(x) Returns the arccosine of each component of x

all(x) Tests if all components of x are nonzero

any(x) Tests if any component of x is nonzero

asfloat(x) Converts the input type to a float

asin(x) Returns the arcsine of each component of x

asint(x) Converts the input type to an integer

asuint(x) Converts the input type to an unsigned integer

atan2(x, y) Returns the arctangent of two values (x, y)

ceil(x) Returns the smallest integer that is greater than or equal to x

clamp(x, min, max) Clamps x to the range [min, max]

clip(x) Discards the current pixel, if any component of x is less than zero

cosh(x) Returns the hyperbolic cosine of x

cross(x, y) Returns the cross product of two 3D vectors

D3DCOLORtoUBYTE4(x) Swizzles and scales components of the 4D vector x to compensate

for the lack of UBYTE4 support in some hardware ddx(x) Returns the partial derivative of x with respect to the screen-space

X coordinate ddy(x) Returns the partial derivative of x with respect to the screen-space

Y coordinate degrees(x) Converts x from radians to degrees

determinant(m) Returns the determinant of the square matrix m

distance(x, y) Returns the distance between two points

dot(x, y) Returns the dot product of two vectors

exp2(x) Returns the base-2 exponent (per component)

faceforward(n, i, ng) Returns -n * <sign>(•(i, ng))

floor(x) Returns the greatest integer that is less than or equal to x

fmod(x, y) Returns the floating-point remainder of x/y

frac(x) Returns the fractional part of x

frexp(x, exp) Returns the mantissa and exponent of x

GetRenderTargetSampleCount( ) Returns the number of render-target samples

GetRenderTargetSamplePosition(x) Returns a sample position (x, y) for a given sample index

isfinite(x) Returns true if x is finite, and false otherwise isinf(x) Returns true if x is +INF or –INF, and false otherwise isnan(x) Returns true if x is NAN or QNAN, and false otherwise

length(v) Returns the length of the vector v

lit(n &#8226; l, n &#8226; h, m) Returns a lighting vector (ambient, diffuse, specular, 1)

log10(x) Returns the base-10 logarithm of x

log2(x) Returns the base-2 logarithm of x

max(x, y) Selects the greater of x and y

min(x, y) Selects the lesser of x and y

modf(x, out ip) Splits the value x into fractional and integer parts mul(x, y) Performs matrix multiplication using x and y

noise(x) Generates a random value using the Perlin-noise algorithm normalize(x) Returns a normalized vector

radians(x) Converts x from degrees to radians

reflect(i, n) Returns a reflection vector

refract(i, n, R) Returns the refraction vector

round(x) Rounds x to the nearest integer

saturate(x) Clamps x to the range [0, 1]

sincos(x, out s, out c) Returns the sine and cosine of x

sinh(x) Returns the hyperbolic sine of x

smoothstep(min, max, x) Returns a smooth Hermite interpolation between 0 and 1 sqrt(x) Returns the square root (per component)

step(a, x) Returns (x >= a) ? 1 : 0

tanh(x) Returns the hyperbolic tangent of x

tex1Dbias(s, t) 1D texture lookup with bias

tex1Dgrad(s, t, ddx, ddy) 1D texture lookup with a gradient

tex1Dlod(s, t) 1D texture lookup with LOD

Table 13-5 Intrinsic functions in HLSL (continued)

Applying HLSL Using Textures | 299

So essentially, the new effect file that you’ve just created is going to set the vertexpositions and then color the object by pulling pixel coordinates out of the associatedtexture using the sampler object In other words, it will map the texture to the rect-angle drawn on the screen

Next, you’ll need to change the code in yourDrawmethod to use your new customeffect rather than the red custom effect used previously Do you remember what datayou need to set in order to use an HLSL effect in XNA?

You’ll need to set the name of the effect to run, and you’ll need to set all global ables in the effect file Currently, you have the following code in theDrawmethod ofyourGame1 class to do that, but you’re setting data for the red.fx file:

vari-effect.CurrentTechnique = effect.Techniques["Technique1"];

effect.Parameters["World"].SetValue(Matrix.Identity);

effect.Parameters["View"].SetValue(camera.View);

effect.Parameters["Projection"].SetValue(camera.Projection);

The first thing you’ll need to change in order to use the new effect is the name of the

technique The technique in the red.fx file was called Technique1, while the neweffect uses a technique calledTextured

tex1Dproj(s, t) 1D texture lookup with projective divide

tex2Dbias(s, t) 2D texture lookup with bias

tex2Dgrad(s, t, ddx, ddy) 2D texture lookup with a gradient

tex2Dlod(s, t) 2D texture lookup with LOD

tex2Dproj(s, t) 2D texture lookup with projective divide

tex3Dbias(s, t) 3D texture lookup with bias

tex3Dgrad(s, t, ddx, ddy) 3D texture lookup with a gradient

tex3Dlod(s, t) 3D texture lookup with LOD

tex3Dproj(s, t) 3D texture lookup with projective divide

texCUBEbias(s, t) Cube texture lookup with bias

texCUBEgrad(s, t, ddx, ddy) Cube texture lookup with a gradient

tex3Dlod(s, t) Cube texture lookup with LOD

texCUBEproj(s, t) Cube texture lookup with projective divide

transpose(m) Returns the transpose of the matrix m

trunc(x) Truncates floating-point value(s) to integer value(s)

Table 13-5 Intrinsic functions in HLSL (continued)

Change the first line of the preceding code, which is in theDrawmethod of yourGame1class, to this:

effect.CurrentTechnique = effect.Techniques["Textured"];

Next, you may have noticed that the global variables are different Previously, youhad three global variables in your HLSL effect:World,View, andProjection

Your new effect has only two global variables:xWorldViewProjection(which should

be set to the world matrix multiplied by the view matrix multiplied by the projectionmatrix) andxColoredTexture(which should be set to theTexture2Dobject you want

to apply to the rectangle)

Remove the following three lines of code from theDraw method of yourGame1 class:effect.Parameters["World"].SetValue(Matrix.Identity);

it stands still Why is that? The answer lies in the world matrix Remember that anobject’s world matrix represents the position, rotation, scale, and so on for that par-ticular object Therefore, if the object isn’t rotating properly, isn’t scaled correctly, or

is in the wrong location, there’s probably a problem with the object’s world matrix

In this particular case, you’re supposed to set the xWorldViewProjectionHLSL able to the world matrix multiplied by the view matrix multiplied by the projectionmatrix The code you used to do that is listed here:

vari-effect.Parameters["xWorldViewProjection"].SetValue(

Matrix.Identity * camera.view * camera.projection);

Notice the value that you’re using for the world portion of that multiplication:Matrix.Identity Remember what the identity matrix does? When you multiplymatrix Aby the identity matrix, the product is matrix A So in this case, you’re multi-plying the identity matrix by the view and the projection That’s exactly the same as

Applying HLSL Using Textures | 301

just multiplying together the view and the projection—in other words, you’re reallynot specifying anything special (no movement, no rotations, nothing) for the object’sworld matrix That’s why the object isn’t rotating

So, how do you fix that? When you built this code in Chapter 9, you used two level matrix variables to rotate the rectangle: worldTranslation and worldRotation

class-To make the object rotate, build a world matrix from the worldTranslation andworldRotationmatrices, and use that world matrix instead ofMatrix.Identitywhensetting thexWorldViewProjection HLSL variable

That is, replace the following line in theDraw method of yourGame1 class:

world * camera.view * camera.projection);

Figure 13-5 Oh so pretty once again…

Now the rotation and translation code you wrote in Chapter 9 will be applied to therectangle Run the game at this point and you should see a spinning rectangle, asshown in Figure 13-6.

The rectangle will move when you press the left and right arrow keys, just as youcoded the original rectangle to do in Chapter 9 Again, feel free to play with the dif-ferent rotations and translations and apply them in different orders, as you did inChapter 9 Instead of setting theWorldproperty of theBasicEffectclass, you’re nowcreating a temporary world matrix variable and assigning that value to the variable in

an HLSL effect file, but the end result is exactly the same

Well maybe HLSL isn’t so amazing You just put in a lot of extra work to end upwith the exact same result that you had previously! That’s not the end of the possi-bilities, though—let’s look at some different things you can do with this texturedrectangle using HLSL

Figure 13-6 Wow! HLSL is amazing!!!

HLSL Effects: Creating a Negative | 303

HLSL Effects: Creating a Negative

Now that you have an effect file using a texture, there are any number of things youcan do to your HLSL file to get some really interesting and cool effects For instance,changing the code in the pixel shader to the following will result in a negative imagebeing drawn:

float4 PixelShader(VertexOut input) : COLOR0

{

float4 output = 1-tex2D(ColoredTextureSampler, input.textureCoordinates);

return output;

}

The effect is shown in Figure 13-7

Figure 13-7 Negative image drawn using HLSL

HLSL Effects: Blur

Another very simple effect is blurring the image To do this, you grab the color ofeach pixel in the texture and add to it the colors from the pixels adjacent to the tar-get pixel To try this, replace the pixel shader in your game with the following code:float4 PixelShader(VertexOut input) : COLOR0

{

float4 Color;

Color = tex2D(ColoredTextureSampler, input.textureCoordinates.xy);

Color += tex2D(ColoredTextureSampler, input.textureCoordinates.xy + (0.01)); Color += tex2D(ColoredTextureSampler, input.textureCoordinates.xy - (0.01)); Color = Color / 3;

return Color;

}

This effect will require pixel shader 1.4 or higher, so change the line in your nique that defines the pixel shader to:

tech-PixelShader = compile ps_1_4 tech-PixelShader( );

Wouldn’t you always want to use the latest and greatest pixel shader?

Why even bother with pixel shader 1.1?

In fact, you should always use the lowest-version pixel shader that you

can, depending on the functions that you are going to implement The

reason? Graphics cards only support certain pixel shader and vertex

shader versions If you don’t need to use version 1.4, but you tell

HLSL to use that version anyway, some users might not be able to run

your game because their graphics cards might only support pixel

shader 1.1 (even though they ought to be able to run your game

because you’re not actually using any of the functions in pixel shader

color = tex2D( ColoredTextureSampler, input.textureCoordinates.xy);

return dot(color, float3(0.3, 0.59, 0.11));

}