Part II in .NET

Maker QR Code 2d barcode in .NET Part II

Another way to say the same thing is that mul transforms the position data by the world-view-projection matrix. The vertex shader operates once for each vertex in the object. The shader literally returns the transformed vertices. When the vertex shader completes, the object is ready to draw. (See Color Plate 13.) As you can see, the output is not very complex because the vertex data represents one triangle. It s a solid color, white, because we did not supply a vertex color, so the pipeline assumed the default value. The purpose of this tutorial is to demonstrate an HLSL vertex shader that performs a world-viewprojection transform in one line of code. This tutorial calls D3DXCompileShader to compile the vertex shader. D3DXCompileShader is located in the RestoreDeviceObjects method, which is shown in the following code:

const char* strHLLVertexShader = "float4x4 WorldViewProj : WORLDVIEWPROJ;\n" "\n" "float4 VertexShader_Tutorial_1(float4 inPos : POSITION) : POSITION\n" "{\n" "\n" " return mul(inPos, WorldViewProj);\n" "}\n" ""; // Compile the vertex shader LPD3DXBUFFER pShader = NULL; hr = D3DXCompileShader( strHLLVertexShader, (UINT)strlen(strHLLVertexShader), NULL, NULL, "VertexShader_Tutorial_1", "vs_1_1", D3DXSHADER_DEBUG, &pShader, NULL, // error messages &m_pConstantTable ); if( FAILED(hr) ) { SAFE_RELEASE(pShader); SAFE_RELEASE(m_pConstantTable); return hr; } // Create the vertex shader hr = m_pd3dDevice->CreateVertexShader( (DWORD*)pShader->GetBufferPointer(), &m_pHLL_VS ); SAFE_RELEASE(pShader); if( FAILED(hr) )

{ SAFE_RELEASE(m_pHLL_VS); SAFE_RELEASE(m_pConstantTable); return hr; }

D3DXCompileShader takes a shader in the form of a string. After the shader is compiled, call IDirect3DDevice9::CreateVertexShader to create the vertex shader object. The Glow example in 8 goes into more detail regarding the arguments used by these two API calls. Also, the section called Building the Tutorials later in this chapter goes into more detail about all of these API calls.

To expand the vertex shader to accommodate additional vertex data, we could add a diffuse color to each vertex of the triangle. The vertex shader would need to perform the position transformation (as earlier) and apply the per-vertex diffuse color. The shader could be modified to look like this:

float4x4 WorldViewProj; struct VS_OUTPUT { float4 Pos : POSITION; float4 Diff : COLOR0; }; VS_OUTPUT VertexShader_Tutorial_1a(float4 inPos : POSITION, float4 inDiff : COLOR0) { VS_OUTPUT Out = (VS_OUTPUT)0; Out.Pos = mul(inPos, WorldViewProj); Out.Diff = inDiff; return Out; }

Now we have a polygon face with a little color in it. The top vertex was set to red, the lower-left vertex was set to white, and the lower-right vertex was set to blue. (See Color Plate 14.) Let s look behind the scenes to see what changes were needed. The first thing that s different with the shader is that it now returns a structure named VS_OUTPUT instead of a float4. As you can see, the structure contains two types of data: position and diffuse color.

struct VS_OUTPUT { float4 Pos : POSITION; float4 Diff : COLOR0; };

Both position and color data use a float4 type because each of them contains four components of data. The position contains (x,y,z,w) data, and the diffuse color contains (r,g,b,a) data. Both parameters have a semantic that identifies the original vertex data from the vertex buffer. Because the shader depends on the vertex data containing diffuse color (in addition to the position data), the vertex data needs to be modified to contain color data, as shown in the following code:

// Initialize three vertices for rendering a triangle CUSTOMVERTEX vertices[] = { {-1, -1, 0, D3DCOLOR_RGBA(255,255,255,255)}, // white lower left { 0, 1, 0, D3DCOLOR_RGBA(255,0,0,0)}, // red top { 1, -1, 0, D3DCOLOR_RGBA(0,0,255,0)} // blue lower right };

This initialization consists of three rows of data, one for each vertex in the triangle. Each row (vertex) contains a position (x,y,z) and a diffuse color (rgba) created with the D3DCOLOR_RGBA macro. As a result of the vertex data changes, the vertex declaration also needs to be updated by adding another line, as shown here:

// Create the vertex declaration D3DVERTEXELEMENT9 decl[] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, { 0, 3*sizeof(float), D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0 }, D3DDECL_END() };

This declaration contains two lines, one for each type of data in the vertex buffer. The first row identifies the position data; the second corresponds to the diffuse color. That completes Tutorial 1, which gives you a starting place for generating HLSL shaders. These examples demonstrate a vertex shader that uses a single function with semantics. As you can see, HLSL uses functions to build shader functionality. The next tutorial will add a pixel shader to the mix so that you can see how a vertex shader talks to a pixel shader. So how do you get this shader to work on your machine As you might know from looking at the DirectX SDK samples, all the samples run on the sample framework. This approach is continued here, for all the examples because the sample framework provides so much base Microsoft Windows functionality and allows you to focus on graphics issues. To learn more about the API calls