Introduction to 3D Game Programming with DirectX.9.0 - F. D. Luna

274 Chapter 16

...

}

The parameters are inputs into the shader; in this example we are inputting three texture coordinates. The shader returns a single color as output, which is denoted by the : COLOR syntax following the function signature. This definition is equivalent to:

} A

The body of the entry point function is responsible for computing the

output vertex given the input vertex. The shader in this example simply transforms the input vertex to view space and projection space, sets the vertex color to blue, and returns the resulting vertex. First we instantiate a VS_OUTPUT instance and set all of its members to 0.

VS_OUTPUT output = (VS_OUTPUT)0; // zero out all members

Then our shader transforms the input vertex position by the ViewProjMatrix variable using the mul function, which is a built-in function that can do both vector-matrix multiplication and matrixmatrix multiplication. We save the resulting transformed vector in the position member of the output instance:

// transform and project

output.position = mul(input.position, ViewProjMatrix);

Next we set the diffuse color member of output to Blue:

// set vertex diffuse color to blue

output.diffuse = Blue;

Finally, we return our resulting vertex:

return output;

}

Team-Fly®

Introduction to the High-Level Shading Language 275

16.2 Compiling an HLSL Shader

16.2.1 The Constant Table

Every shader has a constant table that is used to store its variables. The D3DX library provides our application access to a shader’s constant table through the ID3DXConstantTable interface. Via this interface we can set variables in the shader source code from our application’s code.

We now describe an abridged list of the methods that ID3DXConstantTable implements. For a complete list, see the Direct3D documentation.

16.2.1.1 Getting a Handle to a Constant

In order to set a particular variable in a shader from our application code, we need a way to refer to it. We can refer to a variable in the shader from our application with a D3DXHANDLE. The following method returns a D3DXHANDLE to a variable in the shader when given its name:

276 Chapter 16

example, if the variable that we wish to set is a vector array, the method name would be SetVectorArray.

The general syntax of the ID3DXConstantTable::SetXXX methods is of the form:

HRESULT ID3DXConstantTable::SetXXX(

LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant,

XXX value

);

pDevice—Pointer to the device that is associated with the constant table

hConstant—A handle that refers to the variable that we are setting

value—The value that we are setting the variable to, where XXX is replaced with the variable type name we are setting. For some types (bool, int, float), we pass a copy of the value, and for other types (vectors, matrices, structures), we pass a pointer to the value.

When we set arrays, the SetXXX method takes an additional fourth parameter that specifies the number of elements in the array. For example, the method to set an array of 4D vectors is prototyped as:

HRESULT ID3DXConstantTable::SetVectorArray(

The following list describes the types that we can set with the ID3DXConstantTable interface. Assume that we have a valid device (Device) and a valid handle to the variable that we are setting (handle).

SetBool—Used to set a Boolean value. Sample call:

bool b = true;

ConstTable->SetBool(Device, handle, b);

SetBoolArray—Used to set a Boolean array. Sample call:

bool b[3] = {true, false, true};

ConstTable->SetBoolArray(Device, handle, b, 3);

SetFloat—Used to set a float. Sample call:

float f = 3.14f;

ConstTable->SetFloat(Device, handle, f);

Introduction to the High-Level Shading Language 277

ConstTable->SetMatrixTransposePointerArray(Device, handle, M, 4);

Introduction to the High-Level Shading Language 281

float—32-bit floating-point number

double—64-bit floating-point number

v = u.xyyw; // v = {1.0f, 2.0f, 2.0f, 4.0f}

282 Chapter 16

When copying vectors, we do not have to copy every component over. For example, we can copy over only the x- and y-components, as this code snippet illustrates:

vector u = {1.0f, 2.0f, 3.0f, 4.0f}; vector v = {0.0f, 0.0f, 5.0f, 6.0f};

v.xy = u; // v = {1.0f, 2.0f, 5.0f, 6.0f}

16.3.3 Matrix Types

HLSL has the following built-in matrix types:

matrix—A 4 4 matrix, where each entry is of type float

matrix<T, m, n>—An m n matrix, where each entry is of sca-

lar type T. The matrix dimensions m and n must be between 1 and 4. Here is an example of an 2 2 integer matrix:

matrix<int, 2, 2> m2x2;

Alternatively, we can define an m n matrix, where m and n are between 1 and 4, using the following syntax:

floatmxn matmxn;

Examples:

float2x2 mat2x2; float3x3 mat3x3;

float4x4 mat4x4; float2x4 mat2x4;

Note: The types need not be only float—we can use other types. For instance we can use integers and write:

int2x2 i2x2; int2x2 i3x3; int2x2 i2x4;

We can access an entry in a matrix using a double array subscript syntax. For example, to set the ijth entry of a matrix M, we would write:

M[i][j] = value;

In addition, we can refer to the entries of a matrix M as we would access the members of a structure. The following entry names are defined:

One-based:

M._11 = M._12 = M._13 = M._14 = 0.0f;

M._21 = M._22 = M._23 = M._24 = 0.0f;

M._31 = M._32 = M._33 = M._34 = 0.0f;

M._41 = M._42 = M._43 = M._44 = 0.0f;

Introduction to the High-Level Shading Language 283

Zero-based:

M._m00 = M._m01 = M._m02 = M._m03 = 0.0f;

M._m10 = M._m11 = M._m12 = M._m13 = 0.0f;

M._m20 = M._m21 = M._m22 = M._m23 = 0.0f;

M._m30 = M._m31 = M._m32 = M._m33 = 0.0f;

Sometimes we want to refer to a particular row vector in a matrix. We can do so using a single array subscript syntax. For example, to refer to the ith row vector in a matrix M, we would write: