Double-click on CS470_Lab09.zip and extract the contents of the archive into a subdirectory called CS470_Lab09

Transcription

1 Lab 9: Blending CS 470 Labs Lab 9 In our application thus far, we have used effects such as timers, user interaction, lighting, and textures. In this lab, we will combine all of these and introduce the effect of blending as well. Blending deals with giving surfaces a degree of transparency. For this lab, we will create transparent water that travels through a terrain map. This lab can also be referenced in Frank Luna s book, starting at Chapter 5, and adds additional effects in the following chapters. 0. Getting Started Download CS470_Lab09.zip, saving it into the labs directory. Double-click on CS470_Lab09.zip and extract the contents of the archive into a subdirectory called CS470_Lab09 Navigate into the CS470_Lab09 directory and double-click on CS470_Lab09.sln (the file with the little Visual Studio icon with the 10 on it) which should immediately open Visual Studio with the project. If the Header Files, Resource Files and Source Files folders in the Solution Explorer pane are not expanded, expand each by double clicking on them and double-click on BlendingApp.cpp, fog.fx, 1. The Blending Equation Recalling from CS 370, Blending is used to create transparency effects. This is done by combining the pixels that we are currently rasterizing (source pixels) with the pixels that have already been rasterized to the back buffer (destination pixels). With this technique, it is possible to create objects such as water or glass (objects with semi-transparent surfaces). Direct3D uses the following equation to blend source and destination pixels. C src corresponds to the color of a pixel that we are currently rasterizing (source pixel). C dst is the color of the pixel already on the back buffer (destination pixel). If blending is turned off, C src would simply just overwrite C dst. The colors F src (source blend factor) and F dst (destination blend factor) may have a variety of values, based on the needs of the program. The source color is multiplied with its blend factor and performs and operation to the product of the destination color and its blend factor.

2 The blending equation is used for only the RGB components of the colors. The alpha component is actually taken care of with its own equation. These two equations are handled independently so that the RGB and alpha components can be processed differently if need be. The alpha blending equation is as follows: The operator used in the above blending equations may be one of the following: typedef enum D3D10_BLEND_OP D3D10_BLEND_OP_ADD = 1, // D3D10_BLEND_OP_SUBTRACT = 2, // D3D10_BLEND_OP_REV_SUBTRACT = 3, // D3D10_BLEND_OP_MIN = 4, // D3D10_BLEND_OP_MAX = 5, // } D3D10_BLEND_OP; Operations include addition, subtraction, reverse subtraction, min( ), and max( ). Please refer to the above commented code beside each operation to see what technique is used to blend the source and destination pixels. 2. Blend Factors and Blend State Dozens of blending effects can be achieved by selecting different blend factors for the source and destination colors. The following is a list of commonly used blend factors: Let C src = (r s, g s, b s ) F = (resulting blend factor) A src = a s C dst = (r d, g d, b d ) A dst = a d List of common Blend Factors: D3D10_BLEND_ZERO F = (0, 0, 0) D3D10_BLEND_ONE F = (1, 1, 1) D3D10_BLEND_SRC_COLOR F = (r s, g s, b s ) D3D10_BLEND_INV_SRC_COLOR F = (1 - r s, 1 - g s, 1 - b s ) D3D10_BLEND_SRC_ALPHA F = (a s, a s, a s ) D3D10_BLEND_INV_SRC_ALPHA F = (1 - a s, 1 - a s, 1 - a s )

3 D3D10_BLEND_DEST_ALPHA F = (a d, a d, a d ) D3D10_BLEND_INV_DEST_ALPHA F = (1 - a d, 1 - a d, 1 - a d ) D3D10_BLEND_DEST_COLOR F = (r d, g d, b d ) D3D10_BLEND_INV_DEST_COLOR F = (1 - r d, 1 - g d, 1 - b d ) D3D10_BLEND_SRC_ALPHA_SAT F = (a, a, a ) * D3D10_BLEND_BLEND_FACTOR F = (r, g, b) ** D3D10_BLEND_INV_BLEND_FACTOR F = (1 - r, 1 - g, 1 - b) ** * where a = clamp(a s, 0, 1). The clamp function is ** where the color (r, g, b, a) is supplied by the second parameter of the OMSetBlendState method. This allows you to directly specify the desired blend factor. However, it is constant until the blend state is changed. Now that we have looked at different blend operations and blend factors, we can now set them in Directx. The blend settings are managed by the ID3D10BlendState interface. To create this interface, a D3D10_BLEND_DESC structure must be filled out and the method ID3D10Device::CreateBlendState must be called. Add the following code to the initapp method in BlendingApp.cpp. /* Create new ID3D10BlendState interface*/ // Create blending description structure D3D10_BLEND_DESC blenddesc = 0 blenddesc.alphatocoverageenable = false; blenddesc.blendenable[0] = true; blenddesc.srcblend = D3D10_BLEND_SRC_ALPHA; blenddesc.destblend = D3D10_BLEND_INV_SRC_ALPHA; blenddesc.blendop = D3D10_BLEND_OP_ADD; blenddesc.srcblendalpha = D3D10_BLEND_ONE; blenddesc.destblendalpha = D3D10_BLEND_ZERO; blenddesc.blendopalpha = D3D10_BLEND_OP_ADD; blenddesc.rendertargetwritemask[0] = D3D10_COLOR_WRITE_ENABLE_ALL; // Create new blend state from description structure HR(md3dDevice->CreateBlendState(&blendDesc, &mtransparentbs)); The above code creates a blending description structure, which defines all the variables used in both blending equations. The following table describes the blending attributes that are set in the above code. Attribute Description

4 AlphaToCoverageEnable BlendEnable SrcBlend DestBlend BlendOp SrcBlendAlpha DestBlendAlpha BlendOpAlpha RenderTargetWriteMask Enables or disables a multisampling technique that is useful for rendering foliage or wire fence textures. Enables or disables blending. Specifies the source blend factor for RGB blending. Specifies the destination blend factor for RGB blending. Specifies the blending operation for RGB blending. Specifies the source blend factor for alpha blending. Specifies the destination blend factor for alpha blending. Specifies the blending operation for alpha blending. Sets certain flags that control which color channels in the back buffer are written to after blending. 3. Transparent Water If the application could be compiled and run as of now, the scene would be drawn with mountains, water (no semi-transparency), and a wire fence textured crate. To make the water semi-transparent, as it should be, add the following code segments to enable blending effects. Now we simply need to enable blending with the transparency blend factors before the water is drawn. Add the following code to BlendingApp.cpp in the drawscene function. Notice we set the blend state before we draw the water via the function OMSetBlendState. // // Set water specific constants. // mwvp = mwavesworld*mview*mproj; mfxwvpvar->setmatrix((float*)&mwvp); mfxworldvar->setmatrix((float*)&mwavesworld); mfxtexmtxvar->setmatrix((float*)&watertexmtx); mfxdiffusemapvar->setresource(mwatermaprv); mfxspecmapvar->setresource(mdefaultspecmaprv); pass->apply(0); md3ddevice->omsetblendstate(mtransparentbs, blendfactor, 0xffffffff); mwaves.draw(); Once we have everything we need in the application, let s create the shader. Add the following code to blending.fx. In this code, the texture of an object is sampled twice. That is once using the transformed texture coordinates to get the tiled RGB color and then again using the unmodified texture coordinates in the range [0,1] to get the alpha component. This creates the sense of water depth in the scene while maintaining a tiled texture that is transformed to create the sense of moving water. #include "lighthelper.fx" cbuffer cbperframe

5 Light glight; float3 geyeposw; cbuffer cbperobject float4x4 gworld; float4x4 gwvp; float4x4 gtexmtx; cbuffer cbfixed // Nonnumeric values cannot be added to a cbuffer. Texture2D gdiffusemap; Texture2D gspecmap; SamplerState gtrilinearsam Filter = MIN_MAG_MIP_LINEAR; AddressU = Wrap; AddressV = Wrap; struct VS_IN float3 posl : POSITION; float3 normall : NORMAL; float2 texc : TEXCOORD; struct VS_OUT float4 posh : SV_POSITION; float3 posw : POSITION; float3 normalw : NORMAL; float2 texc0 : TEXCOORD0; float2 texc1 : TEXCOORD1; VS_OUT VS(VS_IN vin) VS_OUT vout; // Transform to world space space.

6 vout.posw = mul(float4(vin.posl, 1.0f), gworld); vout.normalw = mul(float4(vin.normall, 0.0f), gworld); // Transform to homogeneous clip space. vout.posh = mul(float4(vin.posl, 1.0f), gwvp); // Output vertex attributes for interpolation across triangle. vout.texc0 = vin.texc; vout.texc1 = mul(float4(vin.texc, 0.0f, 1.0f), gtexmtx); } return vout; float4 PS(VS_OUT pin) : SV_Target // Get materials from texture maps. float alpha = gdiffusemap.sample( gtrilinearsam, pin.texc0 ).a; // Discard pixel if texture alpha < 0.1. Note that we do this // test as soon as possible so that we can potentially exit the shader // early, thereby skipping the rest of the shader code. clip(alpha - 0.1f); float4 diffuse = gdiffusemap.sample( gtrilinearsam, pin.texc1 ); float4 spec = gspecmap.sample( gtrilinearsam, pin.texc1 ); // Map [0,1] --> [0,256] spec.a *= 256.0f; // Interpolating normal can make it not be of unit length so normalize it. float3 normalw = normalize(pin.normalw); // Compute the lit color for this pixel. SurfaceInfo v = pin.posw, normalw, diffuse, spec float3 litcolor = ParallelLight(v, glight, geyeposw); } return float4(litcolor, alpha); technique10 BlendingTech pass P0 SetVertexShader( CompileShader( vs_4_0, VS() ) ); SetGeometryShader( NULL ); SetPixelShader( CompileShader( ps_4_0, PS() ) ); } }

7 4. Fog If the program could compile and run as of now, we would have transparent water. Another nice effect associated with blending is fog. Adding fog to a 3D world has two main large benefits: 1.) Fog prevents popping, which is when an object that is beyond the far clipping plane is drawn as it comes closer and enters. 2.) Fog simulates an atmosphere perspective. Even on a clear day, a small amount of fog will make mountains look less visible because they re farther away. To create fog, we must specify three variables. This includes a fog color, a fog start distance from the camera, and a fog range (the range that exists between the fog start distance to where an object is completely hidden by the fog). The final pixel is calculated using the following fog equation, where litcolor is the usual color of an object: Add the following code to blending.fx in the specified functions. These additions will allow the shader to incorporate a fog effect. Add the following code to cbuffer cbfixed structure in blending.fx. The three values discussed above for the creation of fog in a 3D world. float gfogstart = 5.0f; float gfogrange = 140.0f; float3 gfogcolor = 0.7f, 0.7f, 0.7f Add the following code to the VS_OUT structure in blending.fx. This attribute will hold the fog color for a given pixel. float foglerp : FOG; Add the following code to the VS_OUT VS(VS_IN vin) structure in blending.fx. This calculates the appearance and degree of fog at a given vertex. float d = distance(vout.posw, geyeposw); vout.foglerp = saturate( (d - gfogstart) / gfogrange );

8 Add the following code to float4 PS(VS_OUT pin) : SV_Target in blending.fx. the function lerp is a function in the d3dutil.h header file that simply combines the usual color (litcolor) and the calculated fog color (gfogcolor). // Blend the fog color and the lit color. float3 foggedcolor = lerp(litcolor, gfogcolor, pin.foglerp); return float4(foggedcolor, alpha); 5. Compiling and running the program Once you have completed typing in the code, you can build and run the program in one of two ways: Click the small green arrow in the middle of the top toolbar Hit F5 (or Ctrl-F5) The output should look similar to below