0% found this document useful (0 votes)

772 views

RasterTek: Direct3D Introduction

The document provides an overview of creating a basic framework and window for a DirectX 11 application. It discusses setting up the framework with a WinMain function, SystemClass that encapsulates the application, and InputClass and GraphicsClass. The SystemClass initializes and shuts down the framework, including creating the window, input, and graphics objects. It also contains the main message loop to process windows messages and call the Frame function to handle per-frame application logic and graphics rendering.

Uploaded by

dewddude

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

772 views

RasterTek: Direct3D Introduction

Uploaded by

dewddude

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 710

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

Tutorial 2: Creating a Framework and Window

Before starting to code with DirectX 11 I recommend building a simple code framework. This framework will handle the basic windows functionality and provide an easy way to expand the code in an organized and readable manner. As the intention of these tutorials is just to try different features of DirectX 11 we will purposely keep the framework as thin as possible.

The Framework
The frame work will begin with four items. It will have a WinMain function to handle the entry point of the application. It will also have a system class that encapsulates the entire application that will be called from within the WinMain function. Inside the system class we will have a input class for handling user input and a graphics class for handling the DirectX graphics code. Here is a diagram of the framework setup:

Now that we see how the framework will be setup lets start by looking at the WinMain function inside the main.cpp file.

WinMain
//////////////////////////////////////////////////////////////////////////////// // Filename: main.cpp //////////////////////////////////////////////////////////////////////////////// #include "systemclass.h"

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline, int iCmdshow) { SystemClass* System; bool result;

// Create the system object. System = new SystemClass; if(!System) { return 0; } // Initialize and run the system object. result = System->Initialize(); if(result) { System->Run(); } // Shutdown and release the system object. System->Shutdown(); delete System; System = 0; return 0; }

1 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

As you can see we kept the WinMain function fairly simple. We create the system class and then initialize it. If it initializes with no problems then we call the system class Run function. The Run function will run its own loop and do all the application code until it completes. After the Run function finishes we then shut down the system object and do the clean up of the system object. So we have kept it very simple and encapsulated the entire application inside the system class. Now lets take a look at the system class header file.

Systemclass.h
//////////////////////////////////////////////////////////////////////////////// // Filename: systemclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _SYSTEMCLASS_H_ #define _SYSTEMCLASS_H_ Here we define WIN32_LEAN_AND_MEAN. We do this to speed up the build process, it reduces the size of the Win32 header files by excluding some of the less used APIs. /////////////////////////////// // PRE-PROCESSING DIRECTIVES // /////////////////////////////// #define WIN32_LEAN_AND_MEAN Windows.h is included so that we can call the functions to create/destroy windows and be able to use the other useful win32 functions. ////////////// // INCLUDES // ////////////// #include <windows.h> We have included the headers to the other two classes in the frame work at this point so we can use them in the system class. /////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "inputclass.h" #include "graphicsclass.h" The definition of the class is fairly simple. We see the Initialize, Shutdown, and Run function that was called in WinMain defined here. There are also some private functions that will be called inside those functions. We have also put a MessageHandler function in the class to handle the windows system messages that will get sent to the application while it is running. And finally we have some private variables m_Input and m_Graphics which will be pointers to the two objects that will handle graphics and input. //////////////////////////////////////////////////////////////////////////////// // Class name: SystemClass //////////////////////////////////////////////////////////////////////////////// class SystemClass { public: SystemClass(); SystemClass(const SystemClass&); ~SystemClass(); bool Initialize(); void Shutdown(); void Run(); LRESULT CALLBACK MessageHandler(HWND, UINT, WPARAM, LPARAM); private: bool Frame(); void InitializeWindows(int&, int&); void ShutdownWindows(); private: LPCWSTR m_applicationName;

2 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

HINSTANCE m_hinstance; HWND m_hwnd; InputClass* m_Input; GraphicsClass* m_Graphics; };

///////////////////////// // FUNCTION PROTOTYPES // ///////////////////////// static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

///////////// // GLOBALS // ///////////// static SystemClass* ApplicationHandle = 0; #endif The WndProc function and ApplicationHandle pointer are also included in this class file so we can re-direct the windows system messaging into our MessageHandler function inside the system class. Now lets take a look at the system class source file:

Systemclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: systemclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "systemclass.h" In the class constructor I initialize the object pointers to null. This is important because if the initialization of these objects fail then the Shutdown function further on will attempt to clean up those objects. If the objects are not null then it assumes they were valid created objects and that they need to be cleaned up. It is also good practice to initialize all pointers and variables to null in your applications. Some release builds will fail if you do not do so. SystemClass::SystemClass() { m_Input = 0; m_Graphics = 0; } Here I create an empty copy constructor and empty class destructor. In this class I don't have need of them but if not defined some compilers will generate them for you, and in which case I'd rather they be empty. You will also notice I don't do any object clean up in the class destructor. I instead do all my object clean up in the Shutdown function you will see further down. The reason being is that I don't trust it to be called. Certain windows functions like ExitThread() are known for not calling your class destructors resulting in memory leaks. You can of course call safer versions of these functions now but I'm just being careful when programming on windows. SystemClass::SystemClass(const SystemClass& other) { }

SystemClass::~SystemClass() { } The following Initialize function does all the setup for the application. It first calls InitializeWindows which will create the window for our application to use. It also creates and initializes both the input and graphics objects that the application will use for handling user input and rendering graphics to the screen.

3 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

bool SystemClass::Initialize() { int screenWidth, screenHeight; bool result;

// Initialize the width and height of the screen to zero before sending the variables into the function. screenWidth = 0; screenHeight = 0; // Initialize the windows api. InitializeWindows(screenWidth, screenHeight); // Create the input object. This object will be used to handle reading the keyboard input from the user. m_Input = new InputClass; if(!m_Input) { return false; } // Initialize the input object. m_Input->Initialize(); // Create the graphics object. This object will handle rendering all the graphics for this application. m_Graphics = new GraphicsClass; if(!m_Graphics) { return false; } // Initialize the graphics object. result = m_Graphics->Initialize(screenWidth, screenHeight, m_hwnd); if(!result) { return false; } return true; } The Shutdown function does the clean up. It shuts down and releases everything associated with the graphics and input object. As well it also shuts down the window and cleans up the handles associated with it. void SystemClass::Shutdown() { // Release the graphics object. if(m_Graphics) { m_Graphics->Shutdown(); delete m_Graphics; m_Graphics = 0; } // Release the input object. if(m_Input) { delete m_Input; m_Input = 0; } // Shutdown the window. ShutdownWindows(); return; }

4 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

The Run function is where our application will loop and do all the application processing until we decide to quit. The application processing is done in the Frame function which is called each loop. This is an important concept to understand as now the rest of our application must be written with this in mind. The pseudo code looks like the following: while not done check for windows system messages process system messages process application loop check if user wanted to quit during the frame processing void SystemClass::Run() { MSG msg; bool done, result;

// Initialize the message structure. ZeroMemory(&msg, sizeof(MSG)); // Loop until there is a quit message from the window or the user. done = false; while(!done) { // Handle the windows messages. if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } // If windows signals to end the application then exit out. if(msg.message == WM_QUIT) { done = true; } else { // Otherwise do the frame processing. result = Frame(); if(!result) { done = true; } } } return; } The following Frame function is where all the processing for our application is done. So far it is fairly simple, we check the input object to see if the user has pressed escape and wants to quit. If they don't want to quit then we call the graphics object to do its frame processing which will render the graphics for that frame. As the application grows we'll place more code inside here. bool SystemClass::Frame() { bool result;

// Check if the user pressed escape and wants to exit the application. if(m_Input->IsKeyDown(VK_ESCAPE)) { return false; }

5 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

// Do the frame processing for the graphics object. result = m_Graphics->Frame(); if(!result) { return false; } return true; } The MessageHandler function is where we direct the windows system messages into. This way we can listen for certain information that we are interested in. Currently we will just read if a key is pressed or if a key is released and pass that information on to the input object. All other information we will pass back to the windows default message handler. LRESULT CALLBACK SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam) { switch(umsg) { // Check if a key has been pressed on the keyboard. case WM_KEYDOWN: { // If a key is pressed send it to the input object so it can record that state. m_Input->KeyDown((unsigned int)wparam); return 0; } // Check if a key has been released on the keyboard. case WM_KEYUP: { // If a key is released then send it to the input object so it can unset the state for that key. m_Input->KeyUp((unsigned int)wparam); return 0; } // Any other messages send to the default message handler as our application won't make use of them. default: { return DefWindowProc(hwnd, umsg, wparam, lparam); } } } The InitializeWindows function is where we put the code to build the window we will use to render to. It returns screenWidth and screenHeight back to the calling function so we can make use of them throughout the application. We create the window using some default settings to initialize a plain black window with no borders. The function will make either a small window or make a full screen window depending on a global variable called FULL_SCREEN. If this is set to true then we make the screen cover the entire users desktop window. If it is set to false we just make a 800x600 window in the middle of the screen. I placed the FULL_SCREEN global variable at the top of the graphicsclass.h file in case you want to modify it. It will make sense later why I placed the global in that file instead of the header for this file. void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight) { WNDCLASSEX wc; DEVMODE dmScreenSettings; int posX, posY;

// Get an external pointer to this object. ApplicationHandle = this; // Get the instance of this application. m_hinstance = GetModuleHandle(NULL); // Give the application a name. m_applicationName = L"Engine";

6 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

// Setup the windows class with default settings. wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; wc.lpfnWndProc = WndProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = m_hinstance; wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); wc.hIconSm = wc.hIcon; wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); wc.lpszMenuName = NULL; wc.lpszClassName = m_applicationName; wc.cbSize = sizeof(WNDCLASSEX); // Register the window class. RegisterClassEx(&wc); // Determine the resolution of the clients desktop screen. screenWidth = GetSystemMetrics(SM_CXSCREEN); screenHeight = GetSystemMetrics(SM_CYSCREEN); // Setup the screen settings depending on whether it is running in full screen or in windowed mode. if(FULL_SCREEN) { // If full screen set the screen to maximum size of the users desktop and 32bit. memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); dmScreenSettings.dmSize = sizeof(dmScreenSettings); dmScreenSettings.dmPelsWidth = (unsigned long)screenWidth; dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight; dmScreenSettings.dmBitsPerPel = 32; dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; // Change the display settings to full screen. ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN); // Set the position of the window to the top left corner. posX = posY = 0; } else { // If windowed then set it to 800x600 resolution. screenWidth = 800; screenHeight = 600; // Place the window in the middle of the screen. posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth) / 2; posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2; } // Create the window with the screen settings and get the handle to it. m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName, WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP, posX, posY, screenWidth, screenHeight, NULL, NULL, m_hinstance, NULL); // Bring the window up on the screen and set it as main focus. ShowWindow(m_hwnd, SW_SHOW); SetForegroundWindow(m_hwnd); SetFocus(m_hwnd); // Hide the mouse cursor. ShowCursor(false); return; } ShutdownWindows does just that. It returns the screen settings back to normal and releases the window and the handles associated

7 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

with it. void SystemClass::ShutdownWindows() { // Show the mouse cursor. ShowCursor(true); // Fix the display settings if leaving full screen mode. if(FULL_SCREEN) { ChangeDisplaySettings(NULL, 0); } // Remove the window. DestroyWindow(m_hwnd); m_hwnd = NULL; // Remove the application instance. UnregisterClass(m_applicationName, m_hinstance); m_hinstance = NULL; // Release the pointer to this class. ApplicationHandle = NULL; return; } The WndProc function is where windows sends its messages to. You'll notice we tell windows the name of it when we initialize the window class with wc.lpfnWndProc = WndProc in the InitializeWindows function above. I included it in this class file since we tie it directly into the system class by having it send all the messages to the MessageHandler function defined inside SystemClass. This allows us to hook the messaging functionality straight into our class and keep the code clean. LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam) { switch(umessage) { // Check if the window is being destroyed. case WM_DESTROY: { PostQuitMessage(0); return 0; } // Check if the window is being closed. case WM_CLOSE: { PostQuitMessage(0); return 0; } // All other messages pass to the message handler in the system class. default: { return ApplicationHandle->MessageHandler(hwnd, umessage, wparam, lparam); } } }

Inputclass.h
To keep the tutorials simple I used the windows input for the time being until I do a tutorial on DirectInput (which is far superior). The input class handles the user input from the keyboard. This class is given input from the SystemClass::MessageHandler function. The input object will store the state of each key in a keyboard array. When queried it will tell the calling functions if a certain key is pressed. Here is the header:

8 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

//////////////////////////////////////////////////////////////////////////////// // Filename: inputclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _INPUTCLASS_H_ #define _INPUTCLASS_H_

//////////////////////////////////////////////////////////////////////////////// // Class name: InputClass //////////////////////////////////////////////////////////////////////////////// class InputClass { public: InputClass(); InputClass(const InputClass&); ~InputClass(); void Initialize(); void KeyDown(unsigned int); void KeyUp(unsigned int); bool IsKeyDown(unsigned int); private: bool m_keys[256]; }; #endif

Inputclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: inputclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "inputclass.h"

InputClass::InputClass() { }

InputClass::InputClass(const InputClass& other) { }

InputClass::~InputClass() { }

void InputClass::Initialize() { int i;

// Initialize all the keys to being released and not pressed. for(i=0; i<256; i++) { m_keys[i] = false; }

9 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

return; }

void InputClass::KeyDown(unsigned int input) { // If a key is pressed then save that state in the key array. m_keys[input] = true; return; }

void InputClass::KeyUp(unsigned int input) { // If a key is released then clear that state in the key array. m_keys[input] = false; return; }

bool InputClass::IsKeyDown(unsigned int key) { // Return what state the key is in (pressed/not pressed). return m_keys[key]; }

Graphicsclass.h
The graphics class is the other object that is created by the system class. All the graphics functionality in this application will be encapsulated in this class. I will also use the header in this file for all the graphics related global settings that we may want to change such as full screen or windowed mode. Currently this class will be empty but in future tutorials will contain all the graphics objects.

//////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GRAPHICSCLASS_H_ #define _GRAPHICSCLASS_H_

////////////// // INCLUDES // ////////////// #include <windows.h>

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = false; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f; We'll need these four globals to start with. //////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass();

10 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(); private: }; #endif

Graphicsclass.cpp
I have kept this class entirely empty for now as we are just building the framework for this tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "graphicsclass.h"

GraphicsClass::GraphicsClass() { }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { return true; }

void GraphicsClass::Shutdown() { return; }

bool GraphicsClass::Frame() { return true; }

bool GraphicsClass::Render() {

11 of 12

3/8/2013 12:14 PM

Tutorial 2: Creating a Framework and Window

http://www.rastertek.com/dx11tut02.html

return true; }

Summary
So now we have a framework and a window that will pop up on the screen. This frame work will now be the base for all future tutorials so understanding this frame work is fairly important. Please try the To Do exercise to make sure the code compiles and is working for you before moving on to the next tutorial. If you don't understand this frame work you should still be fine to move onto the other tutorials and they may make more sense to you later once the frame work is filled out more.

To Do Exercises
1. Change the FULL_SCREEN parameter to true in the graphicsclass.h header then recompile and run the program. Press the escape key to quit after the window displays.

Source Code
Visual Studio 2010 Project: dx11tut02.zip Source Only: dx11src02.zip Executable Only: dx11exe02.zip

Back to Tutorial Index

12 of 12

3/8/2013 12:14 PM

Tutorial 3: Initializing DirectX 11

http://www.rastertek.com/dx11tut03.html

Tutorial 3: Initializing DirectX 11

This tutorial will be the first introduction to working with DirectX 11. We will address how to initialize and shut down Direct3D as well as how to render to a window.

Updated Framework
We are going to add another class to the framework which will handle all the Direct3D system functions. We will call the class D3DClass. I have updated the framework diagram below:

As you can see the D3DClass will be located inside the GraphicsClass. The previous tutorial mentioned that all new graphics related classes will be encapsulated in the GraphicsClass and that is why it is the best location for the new D3DClass. Now lets take a look at the changes made to the GraphicsClass:

Graphicsclass.h
//////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GRAPHICSCLASS_H_ #define _GRAPHICSCLASS_H_ Here is the first change. We have taken out the include for windows.h and instead included the new d3dclass.h. /////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" ///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = false; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

1 of 14

3/8/2013 12:13 PM

Tutorial 3: Initializing DirectX 11

http://www.rastertek.com/dx11tut03.html

bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(); private: And the second change is the new private pointer to the D3DClass which we have called m_D3D. In case you were wondering I use the prefix m_ on all class variables. That way when I'm coding I can remember quickly what variables are members of the class and which are not. D3DClass* m_D3D; }; #endif

Graphicsclass.cpp
If you'll remember from the previous tutorial this class was entirely empty with no code in it at all. Now that we have a D3DClass member we will start to fill out some code inside the GraphicsClass to initialize and shutdown the D3DClass object. We will also add calls to BeginScene and EndScene in the Render function so that we are now drawing to the window using Direct3D. So the very first change is in the class constructor. Here we initialize the pointer to null for safety reasons as we do with all class pointers. GraphicsClass::GraphicsClass() { m_D3D = 0; } The second change is in the Initialize function inside the GraphicsClass. Here we create the D3DClass object and then call the D3DClass Initialize function. We send this function the screen width, screen height, handle to the window, and the four global variables from the Graphicsclass.h file. The D3DClass will use all these variables to setup the Direct3D system. We'll go into more detail about that once we look at the d3dclass.cpp file. bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; } // Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NE if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D", L"Error", MB_OK); return false; } return true; } The next change is in the Shutdown function in the GraphicsClass. Shut down of all graphics objects occur here so we have placed the D3DClass shutdown in this function. Note that I check to see if the pointer was initialized or not. If it wasn't we can assume it was never set up and not try to shut it down. That is why it is important to set all the pointers to null in the class constructor. If it does find the pointer has been initialized then it will attempt to shut down the D3DClass and then clean up the pointer afterwards.

2 of 14

3/8/2013 12:13 PM

Tutorial 3: Initializing DirectX 11

http://www.rastertek.com/dx11tut03.html

void GraphicsClass::Shutdown() { if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; } The Frame function has been updated so that it now calls the Render function each frame. bool GraphicsClass::Frame() { bool result;

// Render the graphics scene. result = Render(); if(!result) { return false; } return true; } The final change to this class is in the Render function. We call the D3D object to clear the screen to a grey color. After that we call EndScene so that the grey color is presented to the window. bool GraphicsClass::Render() { // Clear the buffers to begin the scene. m_D3D->BeginScene(0.5f, 0.5f, 0.5f, 1.0f);

// Present the rendered scene to the screen. m_D3D->EndScene(); return true; } Now lets take a look at the new D3DClass header file:

D3dclass.h
//////////////////////////////////////////////////////////////////////////////// // Filename: d3dclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _D3DCLASS_H_ #define _D3DCLASS_H_ First thing in the header is to specify the libraries to link when using this object module. These libraries contain all the Direct3D functionality for setting up and drawing 3D graphics in DirectX as well as tools to interface with the hardware on the computer to obtain information about the refresh rate of the monitor, the video card being used, and so forth. You will notice that some DirectX 10 libraries are still used, this is because those libraries were never upgraded for DirectX 11 as their functionality did not need to change. ///////////// // LINKING // ///////////// #pragma comment(lib, "dxgi.lib") #pragma comment(lib, "d3d11.lib")

3 of 14

3/8/2013 12:13 PM

Tutorial 3: Initializing DirectX 11

http://www.rastertek.com/dx11tut03.html

#pragma comment(lib, "d3dx11.lib") #pragma comment(lib, "d3dx10.lib") The next thing we do is include the headers for those libraries that we are linking to this object module as well as headers for DirectX type definitions and such. ////////////// // INCLUDES // ////////////// #include <dxgi.h> #include <d3dcommon.h> #include <d3d11.h> #include <d3dx10math.h> The class definition for the D3DClass is kept as simple as possible here. It has the regular constructor, copy constructor, and destructor. Then more importantly it has the Initialize and Shutdown function. This will be what we are mainly focused on in this tutorial. Other than that I have a couple helper functions which aren't important to this tutorial and a number of private member variables that will be looked at when we examine the d3dclass.cpp file. For now just realize the Initialize and Shutdown functions are what concerns us. //////////////////////////////////////////////////////////////////////////////// // Class name: D3DClass //////////////////////////////////////////////////////////////////////////////// class D3DClass { public: D3DClass(); D3DClass(const D3DClass&); ~D3DClass(); bool Initialize(int, int, bool, HWND, bool, float, float); void Shutdown(); void BeginScene(float, float, float, float); void EndScene(); ID3D11Device* GetDevice(); ID3D11DeviceContext* GetDeviceContext(); void GetProjectionMatrix(D3DXMATRIX&); void GetWorldMatrix(D3DXMATRIX&); void GetOrthoMatrix(D3DXMATRIX&); void GetVideoCardInfo(char*, int&); private: bool m_vsync_enabled; int m_videoCardMemory; char m_videoCardDescription[128]; IDXGISwapChain* m_swapChain; ID3D11Device* m_device; ID3D11DeviceContext* m_deviceContext; ID3D11RenderTargetView* m_renderTargetView; ID3D11Texture2D* m_depthStencilBuffer; ID3D11DepthStencilState* m_depthStencilState; ID3D11DepthStencilView* m_depthStencilView; ID3D11RasterizerState* m_rasterState; D3DXMATRIX m_projectionMatrix; D3DXMATRIX m_worldMatrix; D3DXMATRIX m_orthoMatrix; }; #endif For those familiar with Direct3D already you may notice I don't have a view matrix variable in this class. The reason being is that I will be putting it in a camera class that we will be looking at in future tutorials.

4 of 14

3/8/2013 12:13 PM

Tutorial 3: Initializing DirectX 11

http://www.rastertek.com/dx11tut03.html

D3dclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: d3dclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "d3dclass.h" So like most classes we begin with initializing all the member pointers to null in the class constructor. All pointers from the header file have all been accounted for here. D3DClass::D3DClass() { m_swapChain = 0; m_device = 0; m_deviceContext = 0; m_renderTargetView = 0; m_depthStencilBuffer = 0; m_depthStencilState = 0; m_depthStencilView = 0; m_rasterState = 0; }

http://www.rastertek.com/dx11tut03.html

drawn to. The other function is Endscene, it tells the swap chain to display our 3D scene once all the drawing has completed at the end of each frame. void D3DClass::BeginScene(float red, float green, float blue, float alpha) { float color[4];

// Setup the color to clear the buffer to. color[0] = red; color[1] = green; color[2] = blue; color[3] = alpha; // Clear the back buffer. m_deviceContext->ClearRenderTargetView(m_renderTargetView, color); // Clear the depth buffer. m_deviceContext->ClearDepthStencilView(m_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0); return; }

void D3DClass::EndScene() { // Present the back buffer to the screen since rendering is complete. if(m_vsync_enabled) { // Lock to screen refresh rate. m_swapChain->Present(1, 0); } else { // Present as fast as possible. m_swapChain->Present(0, 0); } return; } These next functions simply get pointers to the Direct3D device and the Direct3D device context. These helper functions will be called by the framework often. ID3D11Device* D3DClass::GetDevice() { return m_device; }

ID3D11DeviceContext* D3DClass::GetDeviceContext() { return m_deviceContext; } The next three helper functions give copies of the projection, world, and orthographic matrices to calling functions. Most shaders will need these matrices for rendering so there needed to be an easy way for outside objects to get a copy of them. We won't call these functions in this tutorial but I'm just explaining why they are in the code. void D3DClass::GetProjectionMatrix(D3DXMATRIX& projectionMatrix) { projectionMatrix = m_projectionMatrix; return; }

13 of 14

3/8/2013 12:13 PM

Tutorial 3: Initializing DirectX 11

http://www.rastertek.com/dx11tut03.html

void D3DClass::GetWorldMatrix(D3DXMATRIX& worldMatrix) { worldMatrix = m_worldMatrix; return; }

void D3DClass::GetOrthoMatrix(D3DXMATRIX& orthoMatrix) { orthoMatrix = m_orthoMatrix; return; } The last helper function returns by reference the name of the video card and the amount of dedicated memory on the video card. Knowing the video card name and amount of video memory can help in debugging on different configurations. void D3DClass::GetVideoCardInfo(char* cardName, int& memory) { strcpy_s(cardName, 128, m_videoCardDescription); memory = m_videoCardMemory; return; }

Summary
So now we are finally able to initialize and shut down Direct3D as well as render a color to the window. Compiling and running the code will produce the same window as the last tutorial but Direct3D is initialized now and the window is cleared to grey. Compiling and running the code will also show if your compiler is set up properly and if it can see the headers and libraries files from the DirectX SDK.

To Do Exercises
1. Re-compile the code and run the program to ensure DirectX works, if not look at the steps from the first tutorial. Press the escape key to quit after the window displays. 2. Change the global in graphicsclass.h to full screen and re-compile/run. 3. Change the clear color in GraphicsClass::Render to yellow. 4. Write the video card name and memory out to a text file.

Source Code
Visual Studio 2010 Project: dx11tut03.zip Source Only: dx11src03.zip Executable Only: dx11exe03.zip

Back to Tutorial Index

14 of 14

3/8/2013 12:13 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

Tutorial 4: Buffers, Shaders, and HLSL

This tutorial will be the introduction to writing vertex and pixel shaders in DirectX 11. It will also be the introduction to using vertex and index buffers in DirectX 11. These are the most fundamental concepts that you need to understand and utilize to render 3D graphics.

Vertex Buffers
The first concept to understand is vertex buffers. To illustrate this concept let us take the example of a 3D model of a sphere:

The 3D sphere model is actually composed of hundreds of triangles:

Each of the triangles in the sphere model has three points to it, we call each point a vertex. So for us to render the sphere model we need to put all the vertices that form the sphere into a special data array that we call a vertex buffer. Once all the points of the sphere model are in the vertex buffer we can then send the vertex buffer to the GPU so that it can render the model.

Index Buffers
Index buffers are related to vertex buffers. Their purpose is to record the location of each vertex that is in the vertex buffer. The GPU then uses the index buffer to quickly find specific vertices in the vertex buffer. The concept of an index buffer is similar to the concept using an index in a book, it helps find the topic you are looking for at a much higher speed. The DirectX SDK documentation says that using index buffers can also increase the possibility of caching the vertex data in faster locations in video memory. So it is highly advised to use these for performance reasons as well.

1 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

Vertex Shaders
Vertex shaders are small programs that are written mainly for transforming the vertices from the vertex buffer into 3D space. There are other calculations that can be done such as calculating normals for each vertex. The vertex shader program will be called by the GPU for each vertex it needs to process. For example a 5,000 polygon model will run your vertex shader program 15,000 times each frame just to draw that single model. So if you lock your graphics program to 60 fps it will call your vertex shader 900,000 times a second to draw just 5,000 triangles. As you can tell writing efficient vertex shaders is important.

Pixel Shaders
Pixel shaders are small programs that are written for doing the coloring of the polygons that we draw. They are run by the GPU for every visible pixel that will be drawn to the screen. Coloring, texturing, lighting, and most other effects you plan to do to your polygon faces are handled by the pixel shader program. Pixel shaders must be efficiently written due to the number of times they will be called by the GPU.

HLSL
HLSL is the language we use in DirectX 11 to code these small vertex and pixel shader programs. The syntax is pretty much identical to the C language with some pre-defined types. HLSL program files are composed of global variables, type defines, vertex shaders, pixel shaders, and geometry shaders. As this is the first HLSL tutorial we will do a very simple HLSL program using DirectX 11 to get started.

Updated Framework

The framework has been updated for this tutorial. Under GraphicsClass we have added three new classes called CameraClass, ModelClass, and ColorShaderClass. CameraClass will take care of our view matrix we talked about previously. It will handle the location of the camera in the world and pass it to shaders when they need to draw and figure out where we are looking at the scene from. The ModelClass will handle the geometry of our 3D models, in this tutorial the 3D model will just be a single triangle for simplicity reasons. And finally ColorShaderClass will be responsible for rendering the model to the screen invoking our HLSL shader. We will begin the tutorial code by looking at the HLSL shader programs first.

Color.vs
These will be our first shader programs. Shaders are small programs that do the actual rendering of models. These shaders are written in HLSL and stored in source files called color.vs and color.ps. I placed the files with the .cpp and .h files in the engine for now. The purpose of this shader is just to draw colored triangles as I am keeping things simple as possible in this first HLSL tutorial. Here is the code for the vertex shader first: //////////////////////////////////////////////////////////////////////////////// // Filename: color.vs //////////////////////////////////////////////////////////////////////////////// In shader programs you begin with the global variables. These globals can be modified externally from your C++ code. You can use many types of variables such as int or float and then set them externally for the shader program to use. Generally you will put most

2 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

globals in buffer object types called "cbuffer" even if it is just a single global variable. Logically organizing these buffers is important for efficient execution of shaders as well as how the graphics card will store the buffers. In this example I've put three matrices in the same buffer since I will update them each frame at the same time. ///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; }; Similar to C we can create our own type definitions. We will use different types such as float4 that are available to HLSL which make programming shaders easier and readable. In this example we are creating types that have x, y, z, w position vectors and red, green, blue, alpha colors. The POSITION, COLOR, and SV_POSITION are semantics that convey to the GPU the use of the variable. I have to create two different structures here since the semantics are different for vertex and pixel shaders even though the structures are the same otherwise. POSITION works for vertex shaders and SV_POSITION works for pixel shaders while COLOR works for both. If you want more than one of the same type then you have to add a number to the end such as COLOR0, COLOR1, and so forth. ////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float4 color : COLOR; }; struct PixelInputType { float4 position : SV_POSITION; float4 color : COLOR; }; The vertex shader is called by the GPU when it is processing data from the vertex buffers that have been sent to it. This vertex shader which I named ColorVertexShader will be called for every single vertex in the vertex buffer. The input to the vertex shader must match the data format in the vertex buffer as well as the type definition in the shader source file which in this case is VertexInputType. The output of the vertex shader will be sent to the pixel shader. In this case the output type is called PixelInputType which is defined above as well. With that in mind you see that the vertex shader creates an output variable that is of the PixelInputType type. It then takes the position of the input vertex and multiplies it by the world, view, and then projection matrices. This will place the vertex in the correct location for rendering in 3D space according to our view and then onto the 2D screen. After that the output variable takes a copy of the input color and then returns the output which will be used as input to the pixel shader. Also note that I do set the W value of the input position to 1.0 otherwise it is undefined since we only read in a XYZ vector for position. //////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType ColorVertexShader(VertexInputType input) { PixelInputType output;

3 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

return output; }

Color.ps
The pixel shader draws each pixel on the polygons that will be rendered to the screen. In this pixel shader it uses PixelInputType as input and returns a float4 as output which represents the final pixel color. This pixel shader program is very simple as we just tell it to color the pixel the same as the input value of the color. Note that the pixel shader gets its input from the vertex shader output. //////////////////////////////////////////////////////////////////////////////// // Filename: color.ps ////////////////////////////////////////////////////////////////////////////////

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float4 color : COLOR; };

Modelclass.h
As stated previously the ModelClass is responsible for encapsulating the geometry for 3D models. In this tutorial we will manually setup the data for a single green triangle. We will also create a vertex and index buffer for the triangle so that it can be rendered. //////////////////////////////////////////////////////////////////////////////// // Filename: modelclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _MODELCLASS_H_ #define _MODELCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: ModelClass //////////////////////////////////////////////////////////////////////////////// class ModelClass { private: Here is the definition of our vertex type that will be used with the vertex buffer in this ModelClass. Also take note that this typedef must match the layout in the ColorShaderClass that will be looked at later in the tutorial.

4 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

struct VertexType { D3DXVECTOR3 position; D3DXVECTOR4 color; }; public: ModelClass(); ModelClass(const ModelClass&); ~ModelClass(); The functions here handle initializing and shutdown of the model's vertex and index buffers. The Render function puts the model geometry on the video card to prepare it for drawing by the color shader. bool Initialize(ID3D11Device*); void Shutdown(); void Render(ID3D11DeviceContext*); int GetIndexCount(); private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); void RenderBuffers(ID3D11DeviceContext*); The private variables in the ModelClass are the vertex and index buffer as well as two integers to keep track of the size of each buffer. Note that all DirectX 11 buffers generally use the generic ID3D11Buffer type and are more clearly identified by a buffer description when they are first created. private: ID3D11Buffer *m_vertexBuffer, *m_indexBuffer; int m_vertexCount, m_indexCount; }; #endif

ModelClass::ModelClass(const ModelClass& other) { }

ModelClass::~ModelClass() { } The Initialize function will call the initialization functions for the vertex and index buffers. bool ModelClass::Initialize(ID3D11Device* device)

5 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

{ bool result;

// Initialize the vertex and index buffer that hold the geometry for the triangle. result = InitializeBuffers(device); if(!result) { return false; } return true; } The Shutdown function will call the shutdown functions for the vertex and index buffers. void ModelClass::Shutdown() { // Release the vertex and index buffers. ShutdownBuffers(); return; } Render is called from the GraphicsClass::Render function. This function calls RenderBuffers to put the vertex and index buffers on the graphics pipeline so the color shader will be able to render them. void ModelClass::Render(ID3D11DeviceContext* deviceContext) { // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing. RenderBuffers(deviceContext); return; } GetIndexCount returns the number of indexes in the model. The color shader will need this information to draw this model. int ModelClass::GetIndexCount() { return m_indexCount; } The InitializeBuffers function is where we handle creating the vertex and index buffers. Usually you would read in a model and create the buffers from that data file. For this tutorial we will just set the points in the vertex and index buffer manually since it is only a single triangle. bool ModelClass::InitializeBuffers(ID3D11Device* device) { VertexType* vertices; unsigned long* indices; D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc; D3D11_SUBRESOURCE_DATA vertexData, indexData; HRESULT result; First create two temporary arrays to hold the vertex and index data that we will use later to populate the final buffers with. // Set the number of vertices in the vertex array. m_vertexCount = 3; // Set the number of indices in the index array. m_indexCount = 3; // Create the vertex array. vertices = new VertexType[m_vertexCount]; if(!vertices) {

6 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

return false; } // Create the index array. indices = new unsigned long[m_indexCount]; if(!indices) { return false; } Now fill both the vertex and index array with the three points of the triangle as well as the index to each of the points. Please note that I create the points in the clockwise order of drawing them. If you do this counter clockwise it will think the triangle is facing the opposite direction and not draw it due to back face culling. Always remember that the order in which you send your vertices to the GPU is very important. The color is set here as well since it is part of the vertex description. I set the color to green. // Load the vertex array with data. vertices[0].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f); // Bottom left. vertices[0].color = D3DXVECTOR4(0.0f, 1.0f, 0.0f, 1.0f); vertices[1].position = D3DXVECTOR3(0.0f, 1.0f, 0.0f); // Top middle. vertices[1].color = D3DXVECTOR4(0.0f, 1.0f, 0.0f, 1.0f); vertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f); // Bottom right. vertices[2].color = D3DXVECTOR4(0.0f, 1.0f, 0.0f, 1.0f); // Load the index array with data. indices[0] = 0; // Bottom left. indices[1] = 1; // Top middle. indices[2] = 2; // Bottom right. With the vertex array and index array filled out we can now use those to create the vertex buffer and index buffer. Creating both buffers is done in the same fashion. First fill out a description of the buffer. In the description the ByteWidth (size of the buffer) and the BindFlags (type of buffer) are what you need to ensure are filled out correctly. After the description is filled out you need to also fill out a subresource pointer which will point to either your vertex or index array you previously created. With the description and subresource pointer you can call CreateBuffer using the D3D device and it will return a pointer to your new buffer. // Set up the description of the static vertex buffer. vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT; vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.CPUAccessFlags = 0; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the vertex data. vertexData.pSysMem = vertices; vertexData.SysMemPitch = 0; vertexData.SysMemSlicePitch = 0; // Now create the vertex buffer. result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); if(FAILED(result)) { return false; } // Set up the description of the static index buffer. indexBufferDesc.Usage = D3D11_USAGE_DEFAULT; indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the index data. indexData.pSysMem = indices;

7 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

indexData.SysMemPitch = 0; indexData.SysMemSlicePitch = 0; // Create the index buffer. result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); if(FAILED(result)) { return false; } After the vertex buffer and index buffer have been created you can delete the vertex and index arrays as they are no longer needed since the data was copied into the buffers. // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices; indices = 0; return true; } The ShutdownBuffers function just releases the vertex buffer and index buffer that were created in the InitializeBuffers function. void ModelClass::ShutdownBuffers() { // Release the index buffer. if(m_indexBuffer) { m_indexBuffer->Release(); m_indexBuffer = 0; } // Release the vertex buffer. if(m_vertexBuffer) { m_vertexBuffer->Release(); m_vertexBuffer = 0; } return; } RenderBuffers is called from the Render function. The purpose of this function is to set the vertex buffer and index buffer as active on the input assembler in the GPU. Once the GPU has an active vertex buffer it can then use the shader to render that buffer. This function also defines how those buffers should be drawn such as triangles, lines, fans, and so forth. In this tutorial we set the vertex buffer and index buffer as active on the input assembler and tell the GPU that the buffers should be drawn as triangles using the IASetPrimitiveTopology DirectX function. void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext) { unsigned int stride; unsigned int offset;

8 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

// Set the type of primitive that should be rendered from this vertex buffer, in this case triangles. deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); return; }

Colorshaderclass.h
The ColorShaderClass is what we will use to invoke our HLSL shaders for drawing the 3D models that are on the GPU. //////////////////////////////////////////////////////////////////////////////// // Filename: colorshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _COLORSHADERCLASS_H_ #define _COLORSHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: ColorShaderClass //////////////////////////////////////////////////////////////////////////////// class ColorShaderClass { private: Here is the definition of the cBuffer type that will be used with the vertex shader. This typedef must be exactly the same as the one in the vertex shader as the model data needs to match the typedefs in the shader for proper rendering. struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; public: ColorShaderClass(); ColorShaderClass(const ColorShaderClass&); ~ColorShaderClass(); The functions here handle initializing and shutdown of the shader. The render function sets the shader parameters and then draws the prepared model vertices using the shader. bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX); void RenderShader(ID3D11DeviceContext*, int);

9 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; }; #endif

Colorshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: colorshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "colorshaderclass.h" As usual the class constructor initializes all the private pointers in the class to null. ColorShaderClass::ColorShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; }

ColorShaderClass::ColorShaderClass(const ColorShaderClass& other) { }

ColorShaderClass::~ColorShaderClass() { } The Initialize function will call the initialization function for the shaders. We pass in the name of the HLSL shader files, in this tutorial they are named color.vs and color.ps. bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result;

// Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/color.vs", L"../Engine/color.ps"); if(!result) { return false; } return true; } The Shutdown function will call the shutdown of the shader. void ColorShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; }

10 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

Render will first set the parameters inside the shader using the SetShaderParameters function. Once the parameters are set it then calls RenderShader to draw the green triangle using the HLSL shader. bool ColorShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; } Now we will start with one of the more important functions to this tutorial which is called InitializeShader. This function is what actually loads the shader files and makes it usable to DirectX and the GPU. You will also see the setup of the layout and how the vertex buffer data is going to look on the graphics pipeline in the GPU. The layout will need the match the VertexType in the modelclass.h file as well as the one defined in the color.vs file. bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; Here is where we compile the shader programs into buffers. We give it the name of the shader file, the name of the shader, the shader version (5.0 in DirectX 11), and the buffer to compile the shader into. If it fails compiling the shader it will put an error message inside the errorMessage string which we send to another function to write out the error. If it still fails and there is no errorMessage string then it means it could not find the shader file in which case we pop up a dialog box saying so. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ColorVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNE &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; }

11 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

// Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ColorPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNE &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } Once the vertex shader and pixel shader code has successfully compiled into buffers we then use those buffers to create the shader objects themselves. We will use these pointers to interface with the vertex and pixel shader from this point forward. // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vert if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelSha if(FAILED(result)) { return false; } The next step is to create the layout of the vertex data that will be processed by the shader. As this shader uses a position and color vector we need to create both in the layout specifying the size of both. The semantic name is the first thing to fill out in the layout, this allows the shader to determine the usage of this element of the layout. As we have two different elements we use POSITION for the first one and COLOR for the second. The next important part of the layout is the Format. For the position vector we use DXGI_FORMAT_R32G32B32_FLOAT and for the color we use DXGI_FORMAT_R32G32B32A32_FLOAT. The final thing you need to pay attention to is the AlignedByteOffset which indicates how the data is spaced in the buffer. For this layout we are telling it the first 12 bytes are position and the next 16 bytes will be color, AlignedByteOffset shows where each element begins. You can use D3D11_APPEND_ALIGNED_ELEMENT instead of placing your own values in AlignedByteOffset and it will figure out the spacing for you. The other settings I've made default for now as they are not needed in this tutorial. // Now setup the layout of the data that goes into the shader. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "COLOR"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; Once the layout description has been setup we can get the size of it and then create the input layout using the D3D device. Also release

12 of 22

3/8/2013 12:15 PM

http://www.rastertek.com/dx11tut04.html

//////////////////////////////////////////////////////////////////////////////// // Filename: cameraclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _CAMERACLASS_H_ #define _CAMERACLASS_H_

////////////// // INCLUDES // ////////////// #include <d3dx10math.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: CameraClass //////////////////////////////////////////////////////////////////////////////// class CameraClass { public: CameraClass(); CameraClass(const CameraClass&); ~CameraClass(); void SetPosition(float, float, float); void SetRotation(float, float, float); D3DXVECTOR3 GetPosition(); D3DXVECTOR3 GetRotation(); void Render(); void GetViewMatrix(D3DXMATRIX&); private: float m_positionX, m_positionY, m_positionZ; float m_rotationX, m_rotationY, m_rotationZ; D3DXMATRIX m_viewMatrix; }; #endif The CameraClass header is quite simple with just four functions that will be used. The SetPosition and SetRotation functions will be used to set the position and rotation of the camera object. Render will be used to create the view matrix based on the position and rotation of the camera. And finally GetViewMatrix will be used to retrieve the view matrix from the camera object so that the shaders can use it for rendering.

Cameraclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: cameraclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "cameraclass.h" The class constructor will initialize the position and rotation of the camera to be at the origin of the scene. CameraClass::CameraClass() { m_positionX = 0.0f; m_positionY = 0.0f; m_positionZ = 0.0f; m_rotationX = 0.0f; m_rotationY = 0.0f; m_rotationZ = 0.0f; }

16 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

CameraClass::CameraClass(const CameraClass& other) { }

CameraClass::~CameraClass() { } The SetPosition and SetRotation functions are used for setting up the position and rotation of the camera. void CameraClass::SetPosition(float x, float y, float z) { m_positionX = x; m_positionY = y; m_positionZ = z; return; }

void CameraClass::SetRotation(float x, float y, float z) { m_rotationX = x; m_rotationY = y; m_rotationZ = z; return; } The GetPosition and GetRotation functions return the location and rotation of the camera to calling functions. D3DXVECTOR3 CameraClass::GetPosition() { return D3DXVECTOR3(m_positionX, m_positionY, m_positionZ); }

D3DXVECTOR3 CameraClass::GetRotation() { return D3DXVECTOR3(m_rotationX, m_rotationY, m_rotationZ); } The Render function uses the position and rotation of the camera to build and update the view matrix. We first setup our variables for up, position, rotation, and so forth. Then at the origin of the scene we first rotate the camera based on the x, y, and z rotation of the camera. Once it is properly rotated when then translate the camera to the position in 3D space. With the correct values in the position, lookAt, and up we can then use the D3DXMatrixLookAtLH function to create the view matrix to represent the current camera rotation and translation. void CameraClass::Render() { D3DXVECTOR3 up, position, lookAt; float yaw, pitch, roll; D3DXMATRIX rotationMatrix;

// Setup the vector that points upwards. up.x = 0.0f; up.y = 1.0f; up.z = 0.0f; // Setup the position of the camera in the world. position.x = m_positionX; position.y = m_positionY; position.z = m_positionZ;

17 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

// Setup where the camera is looking by default. lookAt.x = 0.0f; lookAt.y = 0.0f; lookAt.z = 1.0f; // Set the yaw (Y axis), pitch (X axis), and roll (Z axis) rotations in radians. pitch = m_rotationX * 0.0174532925f; yaw = m_rotationY * 0.0174532925f; roll = m_rotationZ * 0.0174532925f; // Create the rotation matrix from the yaw, pitch, and roll values. D3DXMatrixRotationYawPitchRoll(&rotationMatrix, yaw, pitch, roll); // Transform the lookAt and up vector by the rotation matrix so the view is correctly rotated at the origin. D3DXVec3TransformCoord(&lookAt, &lookAt, &rotationMatrix); D3DXVec3TransformCoord(&up, &up, &rotationMatrix); // Translate the rotated camera position to the location of the viewer. lookAt = position + lookAt; // Finally create the view matrix from the three updated vectors. D3DXMatrixLookAtLH(&m_viewMatrix, &position, &lookAt, &up); return; } After the Render function has been called to create the view matrix we can provide the update view matrix to calling functions using this GetViewMatrix function. The view matrix will be one of the three main matrices used in the HLSL vertex shader. void CameraClass::GetViewMatrix(D3DXMATRIX& viewMatrix) { viewMatrix = m_viewMatrix; return; }

Graphicsclass.h
GraphicsClass now has the three new classes added to it. CameraClass, ModelClass, and ColorShaderClass have headers added here as well as private member variables. Remember that GraphicsClass is the main class that is used to render the scene by invoking all the needed class objects for the project. //////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GRAPHICSCLASS_H_ #define _GRAPHICSCLASS_H_

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "colorshaderclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

18 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; ColorShaderClass* m_ColorShader; }; #endif

Graphicsclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "graphicsclass.h" The first change to GraphicsClass is initializing the camera, model, and color shader objects in the class constructor to null. GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; m_ColorShader = 0; } The Initialize function has also been updated to create and initialize the three new objects. bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

19 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Set the initial position of the camera. m_Camera->SetPosition(0.0f, 0.0f, -10.0f); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice()); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } // Create the color shader object. m_ColorShader = new ColorShaderClass; if(!m_ColorShader) { return false; } // Initialize the color shader object. result = m_ColorShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the color shader object.", L"Error", MB_OK); return false; } return true; } Shutdown is also updated to shutdown and release the three new objects. void GraphicsClass::Shutdown() { // Release the color shader object. if(m_ColorShader) { m_ColorShader->Shutdown(); delete m_ColorShader; m_ColorShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; }

20 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

// Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the Direct3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; } The Frame function has remained the same as the previous tutorial. bool GraphicsClass::Frame() { bool result;

// Render the graphics scene. result = Render(); if(!result) { return false; } return true; } As you would expect the Render function had the most changes to it. It still begins with clearing the scene except that it is cleared to black. After that it calls the Render function for the camera object to create a view matrix based on the camera's location that was set in the Initialize function. Once the view matrix is created we get a copy of it from the camera class. We also get copies of the world and projection matrix from the D3DClass object. We then call the ModelClass::Render function to put the green triangle model geometry on the graphics pipeline. With the vertices now prepared we call the color shader to draw the vertices using the model information and the three matrices for positioning each vertex. The green triangle is now drawn to the back buffer. With that the scene is complete and we call EndScene to display it to the screen. bool GraphicsClass::Render() { D3DXMATRIX viewMatrix, projectionMatrix, worldMatrix; bool result;

21 of 22

3/8/2013 12:15 PM

Tutorial 4: Buffers, Shaders, and HLSL

http://www.rastertek.com/dx11tut04.html

{ return false; } // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
So in summary you should have learned the basics about how vertex and index buffers work. You should have also learned the basics of vertex and pixel shaders and how to write them using HLSL. And finally you should understand how we've incorporated these new concepts into our frame work to produce a green triangle that renders to the screen. I also want to mention that I realize the code is fairly long just to draw a single triangle and it could have all been stuck inside a single main() function. However I did it this way with a proper frame work so that the coming tutorials require very few changes in the code to do far more complex graphics.

To Do Exercises
1. Compile and run the tutorial. Ensure it draws a green triangle to the screen. Press escape to quit once it does. 2. Change the color of the triangle to red. 3. Change the triangle to a square. 4. Move the camera back 10 more units. 5. Change the pixel shader to ouput the color half as bright. (huge hint: multiply something in ColorPixelShader by 0.5f)

Source Code
Visual Studio 2010 Project: dx11tut04.zip Source Only: dx11src04.zip Executable Only: dx11exe04.zip

Back to Tutorial Index

22 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

Tutorial 5: Texturing
This tutorial will explain how to use texturing in DirectX 11. Texturing allows us to add photorealism to our scenes by applying photographs and other images onto polygon faces. For example in this tutorial we will take the following image:

And then apply it to the polygon from the previous tutorial to produce the following:

The format of the textures we will be using are .dds files. This is the Direct Draw Surface format that DirectX uses. The tool used to produce .dds files comes with the DirectX SDK. It is under DirectX Utilities and is called DirectX Texture Tool. You can create a new texture of any size and format and then cut and paste your image or other format texture onto it and save it as a .dds file. It is very simple to use. And before we get into the code we should discuss how texture mapping works. To map pixels from the .dds image onto the polygon we use what is called the Texel Coordinate System. This system converts the integer value of the pixel into a floating point value between 0.0f and 1.0f. For example if a texture width is 256 pixels wide then the first pixel will map to 0.0f, the 256th pixel will map to 1.0f, and a middle pixel of 128 would map to 0.5f. In the texel coordinate system the width value is named "U" and the height value is named "V". The width goes from 0.0 on the left to 1.0 on the right. The height goes from 0.0 on the top to 1.0 on the bottom. For example top left would be denoted as U 0.0, V 0.0 and bottom right would be denoted as U 1.0, V 1.0. I have made a diagram below to illustrate this system:

Now that we have a basic understanding of how to map textures onto polygons we can look at the updated frame work for this tutorial:

1 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

The changes to the frame work since the previous tutorial is the new TextureClass which is inside ModelClass and the new TextureShaderClass which replaces the ColorShaderClass. We'll start the code section by looking at the new HLSL texture shaders first.

Texture.vs
The texture vertex shader is similar to the previous color shader except that there have been some changes to accommodate texturing. //////////////////////////////////////////////////////////////////////////////// // Filename: texture.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; }; We are no longer using color in our vertex type and have instead moved to using texture coordinates. Since texture coordinates take a U and V float coordinate we use float2 as its type. The semantic for texture coordinates is TEXCOORD0 for vertex shaders and pixel shaders. You can change the zero to any number to indicate which set of coordinates you are working with as multiple texture coordinates are allowed. ////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType TextureVertexShader(VertexInputType input) { PixelInputType output;

2 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

Texture.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: texture.ps //////////////////////////////////////////////////////////////////////////////// The texture pixel shader has two global variables. The first is Texture2D shaderTexture which is the texture resource. This will be our texture resource that will be used for rendering the texture on the model. The second new variable is the SamplerState SampleType. The sampler state allows us to modify how the pixels are written to the polygon face when shaded. For example if the polygon is really far away and only makes up 8 pixels on the screen then we use the sample state to figure out which pixels or what combination of pixels will actually be drawn from the original texture. The original texture may be 256 pixels by 256 pixels so deciding which pixels get drawn is really important to ensure that the texture still looks decent on the really small polygon face. We will setup the sampler state in the TextureShaderClass also and then attach it to the resource pointer so this pixel shader can use it to determine which sample of pixels to draw. ///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType; The PixelInputType for the texture pixel shader is also modified using texture coordinates instead of the color values. ////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; }; The pixel shader has been modified so that it now uses the HLSL sample function. The sample function uses the sampler state we defined above and the texture coordinates for this pixel. It uses these two variables to determine and return the pixel value for this UV location on the polygon face. //////////////////////////////////////////////////////////////////////////////// // Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 TexturePixelShader(PixelInputType input) : SV_TARGET { float4 textureColor;

// Sample the pixel color from the texture using the sampler at this texture coordinate location. textureColor = shaderTexture.Sample(SampleType, input.tex);

3 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

return textureColor; }

Textureclass.h
The TextureClass encapsulates the loading, unloading, and accessing of a single texture resource. For each texture needed an object of this class must be instantiated. //////////////////////////////////////////////////////////////////////////////// // Filename: textureclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TEXTURECLASS_H_ #define _TEXTURECLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx11tex.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: TextureClass //////////////////////////////////////////////////////////////////////////////// class TextureClass { public: TextureClass(); TextureClass(const TextureClass&); ~TextureClass(); The first two functions will load a texture from a given file name and unload that texture when it is no longer needed. bool Initialize(ID3D11Device*, WCHAR*); void Shutdown(); The GetTexture function returns a pointer to the texture resource so that it can be used for rendering by shaders. ID3D11ShaderResourceView* GetTexture(); private: This is the private texture resource. ID3D11ShaderResourceView* m_texture; }; #endif

Textureclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: textureclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "textureclass.h" The class constructor will initialize the texture shader resource pointer to null. TextureClass::TextureClass() { m_texture = 0;

4 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

TextureClass::TextureClass(const TextureClass& other) { }

TextureClass::~TextureClass() { } Initialize takes in the Direct3D device and file name of the texture and then loads the texture file into the shader resource variable called m_texture. The texture can now be used to render with. bool TextureClass::Initialize(ID3D11Device* device, WCHAR* filename) { HRESULT result;

// Load the texture in. result = D3DX11CreateShaderResourceViewFromFile(device, filename, NULL, NULL, &m_texture, NULL); if(FAILED(result)) { return false; } return true; } The Shutdown function releases the texture resource if it has been loaded and then sets the pointer to null. void TextureClass::Shutdown() { // Release the texture resource. if(m_texture) { m_texture->Release(); m_texture = 0; } return; } GetTexture is the function that is called by other objects that need access to the texture shader resource so that they can use the texture for rendering. ID3D11ShaderResourceView* TextureClass::GetTexture() { return m_texture; }

Modelclass.h
The ModelClass has had changes since the previous tutorial so that it can now accommodate texturing. //////////////////////////////////////////////////////////////////////////////// // Filename: modelclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _MODELCLASS_H_ #define _MODELCLASS_H_

//////////////

5 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

// INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> The TextureClass header is now included in the ModelClass header. /////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "textureclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: ModelClass //////////////////////////////////////////////////////////////////////////////// class ModelClass { private: The VertexType has replaced the color component with a texture coordinate component. The texture coordinate is now replacing the green color that was used in the previous tutorial. struct VertexType { D3DXVECTOR3 position; D3DXVECTOR2 texture; }; public: ModelClass(); ModelClass(const ModelClass&); ~ModelClass(); bool Initialize(ID3D11Device*, WCHAR*); void Shutdown(); void Render(ID3D11DeviceContext*); int GetIndexCount(); The ModelClass also has a GetTexture function so it can pass its own texture resource to shaders that will draw this model. ID3D11ShaderResourceView* GetTexture(); private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); void RenderBuffers(ID3D11DeviceContext*); ModelClass has both a private LoadTexture and ReleaseTexture for loading and releasing the texture that will be used to render this model. bool LoadTexture(ID3D11Device*, WCHAR*); void ReleaseTexture(); private: ID3D11Buffer *m_vertexBuffer, *m_indexBuffer; int m_vertexCount, m_indexCount; The m_Texture variable is used for loading, releasing, and accessing the texture resource for this model. TextureClass* m_Texture; }; #endif

6 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

ModelClass::ModelClass() { m_vertexBuffer = 0; m_indexBuffer = 0; The class constructor now initializes the new texture object to null. m_Texture = 0; }

ModelClass::ModelClass(const ModelClass& other) { }

ModelClass::~ModelClass() { } Initialize now takes as input the file name of the .dds texture that the model will be using. bool ModelClass::Initialize(ID3D11Device* device, WCHAR* textureFilename) { bool result;

// Initialize the vertex and index buffer that hold the geometry for the triangle. result = InitializeBuffers(device); if(!result) { return false; } The Initialize function now calls a new private function that will load the texture. // Load the texture for this model. result = LoadTexture(device, textureFilename); if(!result) { return false; } return true; }

void ModelClass::Shutdown() { The Shutdown function now calls a new private function to release the texture object that was loaded during initialization. // Release the model texture. ReleaseTexture(); // Release the vertex and index buffers.

7 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

ShutdownBuffers(); return; }

void ModelClass::Render(ID3D11DeviceContext* deviceContext) { // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing. RenderBuffers(deviceContext); return; }

int ModelClass::GetIndexCount() { return m_indexCount; } GetTexture returns the model texture resource. The texture shader will need access to this texture to render the model. ID3D11ShaderResourceView* ModelClass::GetTexture() { return m_Texture->GetTexture(); }

// Set the number of vertices in the vertex array. m_vertexCount = 3; // Set the number of indices in the index array. m_indexCount = 3; // Create the vertex array. vertices = new VertexType[m_vertexCount]; if(!vertices) { return false; } // Create the index array. indices = new unsigned long[m_indexCount]; if(!indices) { return false; } The vertex array now has a texture component instead of a color component. The texture vector is always U first and V second. For example the first texture coordinate is bottom left of the triangle which corresponds to U 0.0, V 1.0. Use the diagram at the top of this page to figure out what your coordinates need to be. Note that you can change the coordinates to map any part of the texture to any part of the polygon face. In this tutorial I'm just doing a direct mapping for simplicity reasons. // Load the vertex array with data. vertices[0].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f); // Bottom left. vertices[0].texture = D3DXVECTOR2(0.0f, 1.0f);

8 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

vertices[1].position = D3DXVECTOR3(0.0f, 1.0f, 0.0f); // Top middle. vertices[1].texture = D3DXVECTOR2(0.5f, 0.0f); vertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f); // Bottom right. vertices[2].texture = D3DXVECTOR2(1.0f, 1.0f); // Load the index array with data. indices[0] = 0; // Bottom left. indices[1] = 1; // Top middle. indices[2] = 2; // Bottom right. // Set up the description of the vertex buffer. vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT; vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.CPUAccessFlags = 0; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the vertex data. vertexData.pSysMem = vertices; vertexData.SysMemPitch = 0; vertexData.SysMemSlicePitch = 0; // Now create the vertex buffer. result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); if(FAILED(result)) { return false; } // Set up the description of the static index buffer. indexBufferDesc.Usage = D3D11_USAGE_DEFAULT; indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the index data. indexData.pSysMem = indices; // Create the index buffer. result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); if(FAILED(result)) { return false; } // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices; indices = 0; return true; }

void ModelClass::ShutdownBuffers() { // Release the index buffer. if(m_indexBuffer) { m_indexBuffer->Release();

9 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

m_indexBuffer = 0; } // Release the vertex buffer. if(m_vertexBuffer) { m_vertexBuffer->Release(); m_vertexBuffer = 0; } return; }

void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext) { unsigned int stride; unsigned int offset;

// Set vertex buffer stride and offset. stride = sizeof(VertexType); offset = 0; // Set the vertex buffer to active in the input assembler so it can be rendered. deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset); // Set the index buffer to active in the input assembler so it can be rendered. deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0); // Set the type of primitive that should be rendered from this vertex buffer, in this case triangles. deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); return; } LoadTexture is a new private function that will create the texture object and then initialize it with the input file name provided. This function is called during initialization. bool ModelClass::LoadTexture(ID3D11Device* device, WCHAR* filename) { bool result;

// Create the texture object. m_Texture = new TextureClass; if(!m_Texture) { return false; } // Initialize the texture object. result = m_Texture->Initialize(device, filename); if(!result) { return false; } return true; } The ReleaseTexture function will release the texture object that was created and loaded during the LoadTexture function. void ModelClass::ReleaseTexture() { // Release the texture object.

10 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

if(m_Texture) { m_Texture->Shutdown(); delete m_Texture; m_Texture = 0; } return; }

Textureshaderclass.h
The TextureShaderClass is just an updated version of the ColorShaderClass from the previous tutorial. This class will be used to draw the 3D models using vertex and pixel shaders. //////////////////////////////////////////////////////////////////////////////// // Filename: textureshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TEXTURESHADERCLASS_H_ #define _TEXTURESHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: TextureShaderClass //////////////////////////////////////////////////////////////////////////////// class TextureShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; public: TextureShaderClass(); TextureShaderClass(const TextureShaderClass&); ~TextureShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader;

11 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; There is a new private variable for the sampler state pointer. This pointer will be used to interface with the texture shader. ID3D11SamplerState* m_sampleState; }; #endif

Textureshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: textureshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "textureshaderclass.h"

TextureShaderClass::TextureShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; The new sampler variable is set to null in the class constructor. m_sampleState = 0; }

TextureShaderClass::TextureShaderClass(const TextureShaderClass& other) { }

TextureShaderClass::~TextureShaderClass() { }

bool TextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; The new texture.vs and texture.ps HLSL files are loaded for this shader. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/texture.vs", L"../Engine/texture.ps"); if(!result) { return false; }

return true; } The Shutdown function calls the release of the shader variables. void TextureShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects.

12 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

ShutdownShader(); return; } The Render function now takes a new parameter called texture which is the pointer to the texture resource. This is then sent into the SetShaderParameters function so that the texture can be set in the shader and then used for rendering. bool TextureShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewM D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; } InitializeShader sets up the texture shader. bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc; We have a new variable to hold the description of the texture sampler that will be setup in this function. D3D11_SAMPLER_DESC samplerDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; Load in the new texture vertex and pixel shaders. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "TextureVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICT &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); }

13 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

return false; } // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "TexturePixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTN &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vert if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelSha if(FAILED(result)) { return false; } The input layout has changed as we now have a texture element instead of color. The first position element stays unchanged but the SemanticName and Format of the second element have been changed to TEXCOORD and DXGI_FORMAT_R32G32_FLOAT. These two changes will now align this layout with our new VertexType in both the ModelClass definition and the typedefs in the shader files. // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->Ge &m_layout); if(FAILED(result))

14 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

{ return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the dynamic matrix constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } The sampler state description is setup here and then can be passed to the pixel shader after. The most important element of the texture sampler description is Filter. Filter will determine how it decides which pixels will be used or combined to create the final look of the texture on the polygon face. In the example here I use D3D11_FILTER_MIN_MAG_MIP_LINEAR which is more expensive in terms of processing but gives the best visual result. It tells the sampler to use linear interpolation for minification, magnification, and mip-level sampling. AddressU and AddressV are set to Wrap which ensures that the coordinates stay between 0.0f and 1.0f. Anything outside of that wraps around and is placed between 0.0f and 1.0f. All other settings for the sampler state description are defaults. // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } return true; } The ShutdownShader function releases all the variables used in the TextureShaderClass. void TextureShaderClass::ShutdownShader() { The ShutdownShader function now releases the new sampler state that was created during initialization.

15 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

// Release the sampler state. if(m_sampleState) { m_sampleState->Release(); m_sampleState = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) { m_vertexShader->Release(); m_vertexShader = 0; } return; } OutputShaderErrorMessage writes out errors to a text file if the HLSL shader could not be loaded. void TextureShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) { char* compileErrors; unsigned long bufferSize, i; ofstream fout;

16 of 22

3/8/2013 12:15 PM

Tutorial 5: Texturing

http://www.rastertek.com/dx11tut05.html

errorMessage->Release(); errorMessage = 0; // Pop a message up on the screen to notify the user to check the text file for compile errors. MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK); return; } SetShaderParameters function now takes in a pointer to a texture resource and then assigns it to the shader using the new texture resource pointer. Note that the texture has to be set before rendering of the buffer occurs. bool TextureShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewM D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber;

// Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); The SetShaderParameters function has been modified from the previous tutorial to include setting the texture in the pixel shader now. // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); return true; } RenderShader calls the shader technique to render the polygons. void TextureShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle.

17 of 22

In this tutorial I will cover how to light 3D objects using diffuse lighting and DirectX 11. We will start with the code from the previous tutorial and modify it. The type of diffuse lighting we will be implementing is called directional lighting. Directional lighting is similar to how the Sun illuminates the Earth. It is a light source that is a great distance away and based on the direction it is sending light you can determine the amount of light on any object. However unlike ambient lighting (another lighting model we will cover soon) it will not light up surfaces it does not directly touch. I picked directional lighting to start with because it is very easy to debug visually. Also since it only requires a direction the formula is simpler than the other types of diffuse lighting such as spot lights and point lights. The implementation of diffuse lighting in DirectX 11 is done with both vertex and pixel shaders. Diffuse lighting requires just the direction and a normal vector for any polygons that we want to light. The direction is a single vector that you define, and you can calculate the normal for any polygon by using the three vertices that compose the polygon. In this tutorial we will also implement the color of the diffuse light in the lighting equation.

Framework
For this tutorial we will create a new class called LightClass which will represent the light sources in the scenes. LightClass won't actually do anything other than hold the direction and color of the light. We will also remove the TextureShaderClass and replace it with LightShaderClass which handles the light shading on the model. With the addition of the new classes the frame work now looks like the following:

We will start the code section by looking at the HLSL light shader. You will notice that the light shader is just an updated version of the texture shader from the previous tutorial.

1 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

Light.vs
//////////////////////////////////////////////////////////////////////////////// // Filename: light.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; }; Both structures now have a 3 float normal vector. The normal vector is used for calculating the amount of light by using the angle between the direction of the normal and the direction of the light. ////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType LightVertexShader(VertexInputType input) { PixelInputType output;

2 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

Lightshaderclass.cpp

6 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

// If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; One of the major changes to the shader initialization is here in the polygonLayout. We add a third element for the normal vector that will be used for lighting. The semantic name is NORMAL and the format is the regular DXGI_FORMAT_R32G32B32_FLOAT which handles 3 floats for the x, y, and z of the normal vector. The layout will now match the expected input to the HLSL vertex shader.

10 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

polygonLayout[2].SemanticName = "NORMAL"; polygonLayout[2].SemanticIndex = 0; polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[2].InputSlot = 0; polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[2].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) {

11 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

return false; } // Setup the description of the dynamic matrix constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } Here we setup the light constant buffer description which will handle the diffuse light color and light direction. Pay attention to the size of the constant buffers, if they are not multiples of 16 you need to pad extra space on to the end of them or the CreateBuffer function will fail. In this case the constant buffer is 28 bytes with 4 bytes padding to make it 32. // Setup the description of the light dynamic constant buffer that is in the pixel shader. // Note that ByteWidth always needs to be a multiple of 16 if using D3D11_BIND_CONSTANT_BUFFER or CreateBuffer will fail. lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC; lightBufferDesc.ByteWidth = sizeof(LightBufferType); lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; lightBufferDesc.MiscFlags = 0; lightBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer); if(FAILED(result)) { return false; } return true; }

void LightShaderClass::ShutdownShader() {

12 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

The new light constant buffer is released in the ShutdownShader function. // Release the light constant buffer. if(m_lightBuffer) { m_lightBuffer->Release(); m_lightBuffer = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; } // Release the sampler state. if(m_sampleState) { m_sampleState->Release(); m_sampleState = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) { m_vertexShader->Release(); m_vertexShader = 0; } return;

13 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

void LightShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) { char* compileErrors; unsigned long bufferSize, i; ofstream fout;

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h>

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "textureclass.h"

17 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

bool Initialize(ID3D11Device*, WCHAR*); void Shutdown(); void Render(ID3D11DeviceContext*); int GetIndexCount(); ID3D11ShaderResourceView* GetTexture();

private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); void RenderBuffers(ID3D11DeviceContext*); bool LoadTexture(ID3D11Device*, WCHAR*); void ReleaseTexture(); private: ID3D11Buffer *m_vertexBuffer, *m_indexBuffer; int m_vertexCount, m_indexCount; TextureClass* m_Texture; }; #endif

ModelClass::ModelClass() { m_vertexBuffer = 0; m_indexBuffer = 0; m_Texture = 0; }

ModelClass::ModelClass(const ModelClass& other)

18 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

{ }

ModelClass::~ModelClass() { }

bool ModelClass::Initialize(ID3D11Device* device, WCHAR* textureFilename) { bool result;

// Initialize the vertex and index buffers. result = InitializeBuffers(device); if(!result) { return false; } // Load the texture for this model. result = LoadTexture(device, textureFilename); if(!result) { return false; } return true; }

void ModelClass::Shutdown() { // Release the model texture. ReleaseTexture(); // Shutdown the vertex and index buffers. ShutdownBuffers(); return; }

void ModelClass::Render(ID3D11DeviceContext* deviceContext)

19 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

{ // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing. RenderBuffers(deviceContext); return; }

int ModelClass::GetIndexCount() { return m_indexCount; }

ID3D11ShaderResourceView* ModelClass::GetTexture() { return m_Texture->GetTexture(); }

20 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

{ return false; } The only change to the InitializeBuffers function is here in the vertex setup. Each vertex now has normals associated with it for lighting calculations. The normal is a line that is perpendicular to the face of the polygon so that the exact direction the face is pointing can be calculated. For simplicity purposes I set the normal for each vertex along the Z axis by setting each Z component to -1.0f which makes the normal point towards the viewer. // Load the vertex array with data. vertices[0].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f); // Bottom left. vertices[0].texture = D3DXVECTOR2(0.0f, 1.0f); vertices[0].normal = D3DXVECTOR3(0.0f, 0.0f, -1.0f); vertices[1].position = D3DXVECTOR3(0.0f, 1.0f, 0.0f); // Top middle. vertices[1].texture = D3DXVECTOR2(0.5f, 0.0f); vertices[1].normal = D3DXVECTOR3(0.0f, 0.0f, -1.0f); vertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f); // Bottom right. vertices[2].texture = D3DXVECTOR2(1.0f, 1.0f); vertices[2].normal = D3DXVECTOR3(0.0f, 0.0f, -1.0f); // Load the index array with data. indices[0] = 0; // Bottom left. indices[1] = 1; // Top middle. indices[2] = 2; // Bottom right. // Set up the description of the static vertex buffer. vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT; vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.CPUAccessFlags = 0; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the vertex data. vertexData.pSysMem = vertices; vertexData.SysMemPitch = 0; vertexData.SysMemSlicePitch = 0; // Now create the vertex buffer. result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); if(FAILED(result)) { return false; }

21 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

// Set up the description of the static index buffer. indexBufferDesc.Usage = D3D11_USAGE_DEFAULT; indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the index data. indexData.pSysMem = indices; indexData.SysMemPitch = 0; indexData.SysMemSlicePitch = 0; // Create the index buffer. result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); if(FAILED(result)) { return false; } // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices; indices = 0; return true; }

void ModelClass::ShutdownBuffers() { // Release the index buffer. if(m_indexBuffer) { m_indexBuffer->Release(); m_indexBuffer = 0; } // Release the vertex buffer. if(m_vertexBuffer) { m_vertexBuffer->Release();

22 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

m_vertexBuffer = 0; } return; }

void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext) { unsigned int stride; unsigned int offset;

bool ModelClass::LoadTexture(ID3D11Device* device, WCHAR* filename) { bool result;

// Create the texture object. m_Texture = new TextureClass; if(!m_Texture) { return false; } // Initialize the texture object. result = m_Texture->Initialize(device, filename); if(!result)

23 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

{ return false; } return true; }

void ModelClass::ReleaseTexture() { // Release the texture object. if(m_Texture) { m_Texture->Shutdown(); delete m_Texture; m_Texture = 0; } return; }

Lightclass.h
Now we will look at the new light class which is very simple. Its purpose is only to maintain the direction and color of lights. //////////////////////////////////////////////////////////////////////////////// // Filename: lightclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _LIGHTCLASS_H_ #define _LIGHTCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3dx10math.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: LightClass //////////////////////////////////////////////////////////////////////////////// class LightClass

24 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

{ public: LightClass(); LightClass(const LightClass&); ~LightClass(); void SetDiffuseColor(float, float, float, float); void SetDirection(float, float, float); D3DXVECTOR4 GetDiffuseColor(); D3DXVECTOR3 GetDirection(); private: D3DXVECTOR4 m_diffuseColor; D3DXVECTOR3 m_direction; }; #endif

Lightclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: lightclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "lightclass.h"

LightClass::LightClass() { }

LightClass::LightClass(const LightClass& other) { }

LightClass::~LightClass() { }

25 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

void LightClass::SetDiffuseColor(float red, float green, float blue, float alpha) { m_diffuseColor = D3DXVECTOR4(red, green, blue, alpha); return; }

void LightClass::SetDirection(float x, float y, float z) { m_direction = D3DXVECTOR3(x, y, z); return; }

D3DXVECTOR4 LightClass::GetDiffuseColor() { return m_diffuseColor; }

D3DXVECTOR3 LightClass::GetDirection() { return m_direction; }

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" The GraphicsClass now has two new includes for the LightShaderClass and the LightClass.

26 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

#include "lightshaderclass.h" #include "lightclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: Render now takes a float value as input. bool Render(float); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; There are two new private variables for the light shader and the light object. LightShaderClass* m_LightShader; LightClass* m_Light; }; #endif

27 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; The light shader and light object are set to null in the class constructor. m_LightShader = 0; m_Light = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; }

28 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

// Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR); if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK); return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Set the initial position of the camera. m_Camera->SetPosition(0.0f, 0.0f, -10.0f); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), L"../Engine/data/seafloor.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } The new light shader object is created and initialized here. // Create the light shader object. m_LightShader = new LightShaderClass; if(!m_LightShader) { return false; } // Initialize the light shader object. result = m_LightShader->Initialize(m_D3D->GetDevice(), hwnd);

29 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

if(!result) { MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK); return false; } The new light object is created here. // Create the light object. m_Light = new LightClass; if(!m_Light) { return false; } The color of the light is set to purple and the light direction is set to point down the positive Z axis. // Initialize the light object. m_Light->SetDiffuseColor(1.0f, 0.0f, 1.0f, 1.0f); m_Light->SetDirection(0.0f, 0.0f, 1.0f); return true; }

void GraphicsClass::Shutdown() { The Shutdown function releases the new light and light shader objects. // Release the light object. if(m_Light) { delete m_Light; m_Light = 0; } // Release the light shader object. if(m_LightShader) { m_LightShader->Shutdown(); delete m_LightShader; m_LightShader = 0; }

30 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

// Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

bool GraphicsClass::Frame() { bool result; We add a new static variable to hold an updated rotation value each frame that will be passed into the Render function. static float rotation = 0.0f;

// Update the rotation variable each frame. rotation += (float)D3DX_PI * 0.01f; if(rotation > 360.0f) { rotation -= 360.0f; } // Render the graphics scene. result = Render(rotation);

31 of 34

3/8/2013 12:27 PM

Tutorial 6: Diffuse Lighting

http://www.rastertek.com/dx11tut06.html

if(!result) { return false; } return true; }

bool GraphicsClass::Render(float rotation) { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix; bool result;

// Clear the buffers to begin the scene. m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f); // Generate the view matrix based on the camera's position. m_Camera->Render(); // Get the world, view, and projection matrices from the camera and d3d objects. m_Camera->GetViewMatrix(viewMatrix); m_D3D->GetWorldMatrix(worldMatrix); m_D3D->GetProjectionMatrix(projectionMatrix); Here we rotate the world matrix by the rotation value so that when we render the triangle using this updated world matrix it will spin the triangle by the rotation amount. // Rotate the world matrix by the rotation value so that the triangle will spin. D3DXMatrixRotationY(&worldMatrix, rotation); // Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing. m_Model->Render(m_D3D->GetDeviceContext()); The light shader is called here to render the triangle. The new light object is used to send the diffuse light color and light direction into the Render function so that the shader has access to those values. // Render the model using the light shader. result = m_LightShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(), m_Light->GetDirection(), m_Light->GetDiffuseColor()); if(!result) { return false; }

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

Tutorial 7: 3D Model Rendering

This tutorial will cover how to render 3D models in DirectX 11 using HLSL. The code in this tutorial is based on the code from the diffuse lighting tutorial. We have already been rendering 3D models in the previous tutorials, however they were composed of a single triangle and were fairly uninteresting. Now that the basics have been covered we'll move forward to render a more complex object. In this case the object will be a cube. Before we get into how to render more complex models we will first talk about model formats. There are many tools available that allow users to create 3D models. Maya and 3D Studio Max are two of the more popular 3D modeling programs. There are also many other tools with less features but still can do the basics for what we need. Regardless of which tool you choose to use they will all export their models into numerous different formats. My suggestion is that you create your own model format and write a parser to convert their export format into your own format. The reason for this is that the 3D modeling package that you use may change over time and their model format will also change. Also you may be using more than one 3D modeling package so you will have multiple different formats to deal with. So if you have your own format and convert their formats to your own then your code will never need to change. You will only need to change your parser program(s) for changing those formats to your own. As well most 3D modeling packages export a ton of junk that is only useful to that modeling program and you don't need any of it in your model format. The most important part to making your own format is that it covers everything you need it to do and that it is simple for you to use. You can also consider making a couple different formats for different objects as some may have animation data, some may be static, and so forth. The model format I'm going to present is very basic. It will contain a line for each vertex in the model. Each line will match the vertex format used in the code which will be position vector (x, y, z), texture coordinates (tu, tv), and the normal vector (nx, ny, nz). The format will also have the vertex count at the top so you can read the first line and build the memory structures needed before reading in the data. The format will also require that every three lines makes a triangle, and that the vertices in the model format are presented in clockwise order. Here is the model file for the cube we are going to render:

Cube.txt
Vertex Count: 36 Data: -1.0 1.0 -1.0 0.0 0.0 1.0 1.0 -1.0 1.0 0.0 -1.0 -1.0 -1.0 0.0 1.0 -1.0 -1.0 -1.0 0.0 1.0 1.0 1.0 -1.0 1.0 0.0 1.0 -1.0 -1.0 1.0 1.0 1.0 1.0 -1.0 0.0 0.0 1.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 1.0 0.0 -1.0 0.0 -1.0 0.0 -1.0 0.0 -1.0 0.0 -1.0 0.0 -1.0 0.0 0.0 0.0 0.0

1 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

1.0 -1.0 -1.0 0.0 1.0 1.0 0.0 1.0 -1.0 -1.0 0.0 1.0 1.0 0.0 1.0 1.0 1.0 1.0 0.0 1.0 0.0 1.0 -1.0 1.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 -1.0 1.0 1.0 1.0 0.0 0.0 0.0 1.0 -1.0 1.0 0.0 1.0 0.0 0.0 1.0 -1.0 1.0 0.0 1.0 0.0 0.0 -1.0 1.0 1.0 1.0 0.0 0.0 0.0 -1.0 -1.0 1.0 1.0 1.0 0.0 0.0 -1.0 1.0 1.0 0.0 0.0 -1.0 0.0 -1.0 1.0 -1.0 1.0 0.0 -1.0 0.0 -1.0 -1.0 1.0 0.0 1.0 -1.0 0.0 -1.0 -1.0 1.0 0.0 1.0 -1.0 0.0 -1.0 1.0 -1.0 1.0 0.0 -1.0 0.0 -1.0 -1.0 -1.0 1.0 1.0 -1.0 0.0 -1.0 1.0 1.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 1.0 -1.0 1.0 -1.0 0.0 1.0 0.0 1.0 -1.0 1.0 -1.0 0.0 1.0 0.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 1.0 1.0 1.0 -1.0 1.0 1.0 0.0 1.0 -1.0 -1.0 -1.0 0.0 0.0 0.0 -1.0 1.0 -1.0 -1.0 1.0 0.0 0.0 -1.0 -1.0 -1.0 1.0 0.0 1.0 0.0 -1.0 -1.0 -1.0 1.0 0.0 1.0 0.0 -1.0 1.0 -1.0 -1.0 1.0 0.0 0.0 -1.0 1.0 -1.0 1.0 1.0 1.0 0.0 -1.0

0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0

So as you can see there are 36 lines of x, y, z, tu, tv, nx, ny, nz data. Every three lines composes its own triangle giving us 12 triangles that will form a cube. The format is very straight forward and can be read directly into our vertex buffers and rendered without any modifications. Now one thing to watch out for is that some 3D modeling programs export the data in different orders such as left hand or right hand coordinate systems. Remember that by default DirectX 11 is a left-handed coordinate system by default and so the model data needs to match that. Keep an eye out for those differences and ensure your parsing program can handle converting data into the correct format/order.

Modelclass.h
For this tutorial all we needed to do was make some minor changes to the ModelClass for it to render 3D models from our text model files. //////////////////////////////////////////////////////////////////////////////// // Filename: modelclass.h

2 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

//////////////////////////////////////////////////////////////////////////////// #ifndef _MODELCLASS_H_ #define _MODELCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> The fstream library is now included to handle reading from the model text file. #include <fstream> using namespace std;

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "textureclass.h"

3 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

public: ModelClass(); ModelClass(const ModelClass&); ~ModelClass(); The Initialize function will now take as input the character string file name of the model to be loaded. bool Initialize(ID3D11Device*, char*, WCHAR*); void Shutdown(); void Render(ID3D11DeviceContext*); int GetIndexCount(); ID3D11ShaderResourceView* GetTexture();

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

return false; } // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices; indices = 0; return true; }

void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext) { unsigned int stride; unsigned int offset;

// Set vertex buffer stride and offset. stride = sizeof(VertexType); offset = 0; // Set the vertex buffer to active in the input assembler so it can be rendered.

9 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

http://www.rastertek.com/dx11tut07.html

#define _GRAPHICSCLASS_H_

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "lightshaderclass.h" #include "lightclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(float); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; LightShaderClass* m_LightShader; LightClass* m_Light;

13 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

}; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; m_LightShader = 0; m_Light = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

http://www.rastertek.com/dx11tut07.html

m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

bool GraphicsClass::Frame() { bool result; static float rotation = 0.0f;

// Update the rotation variable each frame. rotation += (float)D3DX_PI * 0.01f; if(rotation > 360.0f) { rotation -= 360.0f; } // Render the graphics scene. result = Render(rotation); if(!result) { return false; } return true;

17 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

bool GraphicsClass::Render(float rotation) { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix; bool result;

Summary

18 of 19

3/8/2013 12:28 PM

Tutorial 7: 3D Model Rendering

http://www.rastertek.com/dx11tut07.html

With the changes to the ModelClass we can now load in 3D models and render them. The format used here is just for basic static objects with lighting, however it is a good start to understanding how model formats work.

To Do Exercises
1. Recompile the code and run the program. You should get a rotating cube with the same seafloor.dds texture on it. Press escape to quit once done. 2. Find a decent 3D modeling package (hopefully something free) and create your own simple models and export them. Start looking at the format. 3. Write a simple parser program that takes the model exports and converts it to the format used here. Replace cube.txt with your model and run the program.

Source Code
Visual Studio 2010 Project: dx11tut07.zip Source Only: dx11src07.zip Executable Only: dx11exe07.zip

Back to Tutorial Index

19 of 19

3/8/2013 12:28 PM

Tutorial 8: Loading Maya 2011 Models

http://www.rastertek.com/dx11tut08.html

Tutorial 8: Loading Maya 2011 Models

This tutorial will cover how to import static 3D models from Maya 2011. Note that this tutorial will be focused on Maya but it also applies to pretty much any other 3D modeling software package with some slight changes. In the previous tutorials we have already created our own model format and rendered 3D models using that format. The goal now is to convert Maya 2011 models into our format and render them. I won't go into how to model 3D objects in Maya as there are hundreds of tutorials on the net already dedicated to that, we will instead start at the point where you have a textured and triangulated 3D model ready for export. For the Maya export format we will use the .OBJ format as it is easily readable and good for beginners to start with. To export your model in the .obj format you must first enable the .OBJ exporter in Maya. Click "Window", then "Settings/Preferences", then "Plug-in Manager". Scroll down to objExport.mll and select both "Loaded" and "Auto load". Now to export your model in this format click on "File", then "Export All". Now at the bottom select "Files of type:" and scroll down and select "OBJexport". Give it a file name and hit "Export All" and it will export it to a text file with a .obj extension. To look at the file you can right click and select Open With and choose WordPad to read the file. You will then see something that looks like the following:

Cube.obj
# This file uses centimeters as units for non-parametric coordinates. mtllib cube.mtl g default v -0.500000 -0.500000 0.500000 v 0.500000 -0.500000 0.500000 v -0.500000 0.500000 0.500000 v 0.500000 0.500000 0.500000 v -0.500000 0.500000 -0.500000 v 0.500000 0.500000 -0.500000 v -0.500000 -0.500000 -0.500000 v 0.500000 -0.500000 -0.500000 vt 0.001992 0.001992 vt 0.998008 0.001992 vt 0.001992 0.998008 vt 0.998008 0.998008 vt 0.001992 0.001992 vt 0.998008 0.001992 vt 0.001992 0.998008 vt 0.998008 0.998008 vt 0.001992 0.001992 vt 0.998008 0.001992

1 of 14

3/8/2013 12:29 PM

Tutorial 8: Loading Maya 2011 Models

http://www.rastertek.com/dx11tut08.html

vt 0.001992 0.998008 vt 0.998008 0.998008 vt 0.001992 0.001992 vt 0.998008 0.001992 vt 0.001992 0.998008 vt 0.998008 0.998008 vt 0.001992 0.001992 vt 0.998008 0.001992 vt 0.001992 0.998008 vt 0.998008 0.998008 vt 0.998008 0.998008 vt 0.001992 0.998008 vt 0.998008 0.001992 vt 0.001992 0.001992 vn 0.000000 0.000000 1.000000 vn 0.000000 0.000000 1.000000 vn 0.000000 0.000000 1.000000 vn 0.000000 0.000000 1.000000 vn 0.000000 1.000000 0.000000 vn 0.000000 1.000000 0.000000 vn 0.000000 1.000000 0.000000 vn 0.000000 1.000000 0.000000 vn 0.000000 0.000000 -1.000000 vn 0.000000 0.000000 -1.000000 vn 0.000000 0.000000 -1.000000 vn 0.000000 0.000000 -1.000000 vn 0.000000 -1.000000 0.000000 vn 0.000000 -1.000000 0.000000 vn 0.000000 -1.000000 0.000000 vn 0.000000 -1.000000 0.000000 vn 1.000000 0.000000 0.000000 vn 1.000000 0.000000 0.000000 vn 1.000000 0.000000 0.000000 vn 1.000000 0.000000 0.000000 vn -1.000000 0.000000 0.000000 vn -1.000000 0.000000 0.000000 vn -1.000000 0.000000 0.000000 vn -1.000000 0.000000 0.000000 s1 g pCube1 usemtl file1SG f 1/1/1 2/2/2 3/3/3 f 3/3/3 2/2/2 4/4/4 s2 f 3/13/5 4/14/6 5/15/7

2 of 14

3/8/2013 12:29 PM

Tutorial 8: Loading Maya 2011 Models

http://www.rastertek.com/dx11tut08.html

f 5/15/7 4/14/6 6/16/8 s3 f 5/21/9 6/22/10 7/23/11 f 7/23/11 6/22/10 8/24/12 s4 f 7/17/13 8/18/14 1/19/15 f 1/19/15 8/18/14 2/20/16 s5 f 2/5/17 8/6/18 4/7/19 f 4/7/19 8/6/18 6/8/20 s6 f 7/9/21 1/10/22 5/11/23 f 5/11/23 1/10/22 3/12/24 This particular .OBJ model file represents a 3D cube. It has 8 vertices, 24 texture coordinates and normal vectors, and 6 sides made up of 12 faces in total. When examining the file you can ignore every line unless it starts with a "V", "VT", "VN", or "F". The extra information in the file will not be needed for converting .obj to our file format. Lets look at what each of the important lines means: 1. The "V" lines are for the vertices. The cube is made up of 8 vertices for the eight corners of the cube. Each is listed in X, Y, Z float format. 2. The "VT" lines are for the texture coordinates. The cube is has 24 texture coordinates and most of them are duplicated since it records them for every vertex in every triangle in the cube model. They are listed in TU, TV float format. 3. The "VN" lines are for the normal vectors. The cube is has 24 normal vectors and most of them are duplicated again since it records them for every vertex in every triangle in the cube model. They are listed in NX, NY, NZ float format. 4. The "F" lines are for each triangle (face) in the cube model. The values listed are indexes into the vertices, texture coordinates, and normal vectors. The format of each face is: f Vertex1/Texture1/Normal1 Vertex2/Texture2/Normal2 Vertex3/Texture3/Normal3 So a line that says "f 3/13/5 4/14/6 5/15/7" then translates to "Vertex3/Texture13/Normal5 Vertex4/Texture14/Normal6 Vertex5/Texture15/Normal7". The order the data is listed in the .obj file is very important. For example the first vertex in the file corresponds to Vertex1 in the face list. This is the same for texture coordinates and normals as well. Looking at the face lines in the .obj file notice that the three index groups per line make an individual triangle. And in the case of this cube model the 12 total faces make up the 6 sides of the cube that has 2 triangles per side.

Right hand to Left hand conversion

By default Maya 2011 is a right handed coordinate system and exports the .obj file data in right hand coordinates. To convert that data into a left handed system

3 of 14

3/8/2013 12:29 PM

Tutorial 8: Loading Maya 2011 Models

http://www.rastertek.com/dx11tut08.html

which DirectX 11 is by default you have to do the following: 1. Invert the Z coordinate vertices. In the code you will see it do this: vertices[vertexIndex].z = vertices[vertexIndex].z * -1.0f; 2. Invert the TV texture coordinate. In the code you will see it do this: texcoords[texcoordIndex].y = 1.0f - texcoords[texcoordIndex].y; 3. Invert the NZ normal vertex. In the code you will see it do this: normals[normalIndex].z = normals[normalIndex].z * -1.0f; 4. Convert the drawing order from counter clockwise to clockwise. In the code I simply read in the indexes in reverse order instead of re-organizing it after the fact: fin >> faces[faceIndex].vIndex3 >> input2 >> faces[faceIndex].tIndex3 >> input2 >> faces[faceIndex].nIndex3; fin >> faces[faceIndex].vIndex2 >> input2 >> faces[faceIndex].tIndex2 >> input2 >> faces[faceIndex].nIndex2; fin >> faces[faceIndex].vIndex1 >> input2 >> faces[faceIndex].tIndex1 >> input2 >> faces[faceIndex].nIndex1; With those four steps complete the model data will be ready for DirectX 11 to render correctly.

Main.cpp
The program to convert the Maya 2011 .obj files into our DirectX 11 format is fairly simple and is a single program file called main.cpp. It opens a command prompt and asks for the name of the .obj file to convert. Once the user types in the name it will attempt to open the file and read in the data counts and build the structures required to read the data into. After that it reads the data into those structures and converts it to a left hand system. Once that is done it then writes the data out to a model.txt file. That file can then be renamed and used for rendering in DirectX 11 using the 3D model render project from the previous tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: main.cpp ////////////////////////////////////////////////////////////////////////////////

////////////// // INCLUDES // ////////////// #include <iostream> #include <fstream> using namespace std;

////////////// // TYPEDEFS // ////////////// typedef struct { float x, y, z;

4 of 14

3/8/2013 12:29 PM

Tutorial 8: Loading Maya 2011 Models

http://www.rastertek.com/dx11tut08.html

}VertexType; typedef struct { int vIndex1, vIndex2, vIndex3; int tIndex1, tIndex2, tIndex3; int nIndex1, nIndex2, nIndex3; }FaceType;

///////////////////////// // FUNCTION PROTOTYPES // ///////////////////////// void GetModelFilename(char*); bool ReadFileCounts(char*, int&, int&, int&, int&); bool LoadDataStructures(char*, int, int, int, int);

////////////////// // MAIN PROGRAM // ////////////////// int main() { bool result; char filename[256]; int vertexCount, textureCount, normalCount, faceCount; char garbage;

3/8/2013 12:29 PM

Tutorial 8: Loading Maya 2011 Models

http://www.rastertek.com/dx11tut08.html

// Read in the texture uv coordinates. if(input == 't') { fin >> texcoords[texcoordIndex].x >> texcoords[texcoordIndex].y; // Invert the V texture coordinates to left hand system. texcoords[texcoordIndex].y = 1.0f - texcoords[texcoordIndex].y; texcoordIndex++; } // Read in the normals. if(input == 'n') { fin >> normals[normalIndex].x >> normals[normalIndex].y >> normals[normalIndex].z; // Invert the Z normal to change to left hand system. normals[normalIndex].z = normals[normalIndex].z * -1.0f; normalIndex++; } } // Read in the faces. if(input == 'f') { fin.get(input); if(input == ' ') { // Read the face data in backwards to convert it to a left hand system from right hand system. fin >> faces[faceIndex].vIndex3 >> input2 >> faces[faceIndex].tIndex3 >> input2 >> faces[faceIndex].nIndex3 >> faces[faceIndex].vIndex2 >> input2 >> faces[faceIndex].tIndex2 >> input2 >> faces[faceIndex].nIndex2 >> faces[faceIndex].vIndex1 >> input2 >> faces[faceIndex].tIndex1 >> input2 >> faces[faceIndex].nIndex1; faceIndex++; } } // Read in the remainder of the line. while(input != '\n') { fin.get(input); } // Start reading the beginning of the next line. fin.get(input); }

10 of 14

3/8/2013 12:29 PM

http://www.rastertek.com/dx11tut09.html

This now gives us a more realistic lighting effect that we as humans are used to. We will now look at the changes to the code to implement ambient lighting. This tutorial is built on the previous tutorials that used diffuse lighting. We will now add the ambient component with just a few changes.

Light.vs
The light shader is just the diffuse light shader updated from the previous tutorials. The vertex shader has no code changes to it, only the pixel shader was modified. //////////////////////////////////////////////////////////////////////////////// // Filename: light.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

//////////////

2 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

// TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType LightVertexShader(VertexInputType input) { PixelInputType output;

3 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

Light.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: light.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType; The light constant buffer is updated with a new 4 float ambient color value. This will allow the ambient color to be set in this shader by outside classes. cbuffer LightBuffer { float4 ambientColor; float4 diffuseColor; float3 lightDirection; float padding; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; };

4 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

float lightIntensity; float4 color;

// Sample the pixel color from the texture using the sampler at this texture coordinate location. textureColor = shaderTexture.Sample(SampleType, input.tex); We set the output color value to the base ambient color. All pixels will now be illuminated by a minimum of the ambient color value. // Set the default output color to the ambient light value for all pixels. color = ambientColor; // Invert the light direction for calculations. lightDir = -lightDirection; // Calculate the amount of light on this pixel. lightIntensity = saturate(dot(input.normal, lightDir)); Check if the N dot L is greater than zero. If it is then add the diffuse color to the ambient color. If not then you need to be careful to not add the diffuse color. The reason being is that the diffuse color could be negative and it will subtract away some of the ambient color in the addition which is not correct. if(lightIntensity > 0.0f) { // Determine the final diffuse color based on the diffuse color and the amount of light intensity. color += (diffuseColor * lightIntensity); } Make sure to saturate the final output light color since the combination of ambient and diffuse could have been greater than 1. // Saturate the final light color. color = saturate(color); // Multiply the texture pixel and the final diffuse color to get the final pixel color result. color = color * textureColor; return color; }

Lightshaderclass.h
//////////////////////////////////////////////////////////////////////////////// // Filename: lightshaderclass.h

5 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

//////////////////////////////////////////////////////////////////////////////// #ifndef _LIGHTSHADERCLASS_H_ #define _LIGHTSHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

6 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR3, D3DXVECTOR4, D3DX private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR3, D3DXVECT void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11SamplerState* m_sampleState; ID3D11Buffer* m_matrixBuffer; ID3D11Buffer* m_lightBuffer; }; #endif

Lightshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: lightshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "lightshaderclass.h"

LightShaderClass::LightShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_sampleState = 0; m_matrixBuffer = 0; m_lightBuffer = 0; }

LightShaderClass::LightShaderClass(const LightShaderClass& other) {

7 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

LightShaderClass::~LightShaderClass() { }

bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result;

// Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/light.vs", L"../Engine/light.ps"); if(!result) { return false; } return true; }

void LightShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; } The Render function now takes in an ambient color value which is then sets in the shader before rendering. bool LightShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, D3DXVECTOR3 lightDirection, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor) { bool result;

8 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2;

// Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; }

15 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

http://www.rastertek.com/dx11tut09.html

D3DXVECTOR4 LightClass::GetAmbientColor() { return m_ambientColor; }

D3DXVECTOR4 LightClass::GetDiffuseColor() { return m_diffuseColor; }

D3DXVECTOR3 LightClass::GetDirection() { return m_direction; }

Graphicsclass.h
The header for the GraphicsClass hasn't changed for this tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GRAPHICSCLASS_H_ #define _GRAPHICSCLASS_H_

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "lightshaderclass.h" #include "lightclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true;

19 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(float); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; LightShaderClass* m_LightShader; LightClass* m_Light; }; #endif

GraphicsClass::GraphicsClass() {

20 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

m_D3D = 0; m_Camera = 0; m_Model = 0; m_LightShader = 0; m_Light = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

21 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

// Set the initial position of the camera. m_Camera->SetPosition(0.0f, 0.0f, -10.0f); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/seafloor.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } // Create the light shader object. m_LightShader = new LightShaderClass; if(!m_LightShader) { return false; } // Initialize the light shader object. result = m_LightShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK); return false; } // Create the light object. m_Light = new LightClass; if(!m_Light) { return false; } Set the intensity of the ambient light to 15% white color. Also set the direction of the light to point down the positive X axis so we can directly see the effect of ambient lighting on the cube. // Initialize the light object. m_Light->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f);

22 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetDirection(1.0f, 0.0f, 0.0f); return true; }

void GraphicsClass::Shutdown() { // Release the light object. if(m_Light) { delete m_Light; m_Light = 0; } // Release the light shader object. if(m_LightShader) { m_LightShader->Shutdown(); delete m_LightShader; m_LightShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0;

23 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

} return; }

bool GraphicsClass::Frame() { bool result; static float rotation = 0.0f; I have slowed down the rotation by half so the effect is easier to see. // Update the rotation variable each frame. rotation += (float)D3DX_PI * 0.005f; if(rotation > 360.0f) { rotation -= 360.0f; } // Render the graphics scene. result = Render(rotation); if(!result) { return false; } return true; }

bool GraphicsClass::Render(float rotation) { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix; bool result;

24 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

m_D3D->GetWorldMatrix(worldMatrix); m_D3D->GetProjectionMatrix(projectionMatrix); // Rotate the world matrix by the rotation value so that the triangle will spin. D3DXMatrixRotationY(&worldMatrix, rotation); // Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing. m_Model->Render(m_D3D->GetDeviceContext()); The light shader now takes in as input the ambient color of the light. // Render the model using the light shader. result = m_LightShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(), m_Light->GetDirection(), m_Light->GetAmbientColor(), m_Light->GetDiffuseColor()); if(!result) { return false; } // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
With the addition of ambient lighting all surfaces now illuminate to a minimum degree to produce a more realistic lighting effect.

25 of 26

3/8/2013 12:30 PM

Tutorial 9: Ambient Lighting

http://www.rastertek.com/dx11tut09.html

To Do Exercises
1. Recompile the code and ensure you get a spinning cube that is illuminated on the dark side now. 2. Change the ambient light value to (0.0f, 0.0f, 0.0f, 1.0f) to see just the diffuse component again. 3. Comment out the color = color * textureColor; line in the pixel shader to see just the lighting effect.

Source Code
Visual Studio 2010 Project: dx11tut09.zip Source Only: dx11src09.zip Executable Only: dx11exe09.zip

Back to Tutorial Index

26 of 26

Light.vs
//////////////////////////////////////////////////////////////////////////////// // Filename: light.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; }; We add a new constant buffer to hold camera information. In this shader we require the position of the camera to determine where this vertex is being viewed from for specular calculations. cbuffer CameraBuffer { float3 cameraPosition; float padding; };

2 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; }; The PixelInputType structure is modified as the viewing direction needs to be calculated in the vertex shader and then sent into the pixel shader for specular lighting calculations. struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; float3 viewDirection : TEXCOORD1; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType LightVertexShader(VertexInputType input) { PixelInputType output; float4 worldPosition;

3 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

// Normalize the normal vector. output.normal = normalize(output.normal); The viewing direction is calculated here in the vertex shader. We calculate the world position of the vertex and subtract that from the camera position to determine where we are viewing the scene from. The final value is normalized and sent into the pixel shader. // Calculate the position of the vertex in the world. worldPosition = mul(input.position, worldMatrix); // Determine the viewing direction based on the position of the camera and the position of the vertex in the world. output.viewDirection = cameraPosition.xyz - worldPosition.xyz; // Normalize the viewing direction vector. output.viewDirection = normalize(output.viewDirection); return output; }

Light.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: light.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType; The light buffer has been updated to hold specularColor and specularPower values for specular lighting calculations. cbuffer LightBuffer { float4 ambientColor; float4 diffuseColor; float3 lightDirection; float specularPower; float4 specularColor; };

4 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

////////////// // TYPEDEFS // ////////////// The PixelInputType structure is modified here as well to reflect the changes to it in the vertex shader. struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; float3 viewDirection : TEXCOORD1; };

// Sample the pixel color from the texture using the sampler at this texture coordinate location. textureColor = shaderTexture.Sample(SampleType, input.tex); // Set the default output color to the ambient light value for all pixels. color = ambientColor; // Initialize the specular color. specular = float4(0.0f, 0.0f, 0.0f, 0.0f); // Invert the light direction for calculations. lightDir = -lightDirection; // Calculate the amount of light on this pixel. lightIntensity = saturate(dot(input.normal, lightDir)); if(lightIntensity > 0.0f)

5 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

{ // Determine the final diffuse color based on the diffuse color and the amount of light intensity. color += (diffuseColor * lightIntensity); // Saturate the ambient and diffuse color. color = saturate(color); The reflection vector for specular lighting is calculated here in the pixel shader provided the light intensity is greater than zero. This is the same equation as listed at the beginning of the tutorial. // Calculate the reflection vector based on the light intensity, normal vector, and light direction. reflection = normalize(2 * lightIntensity * input.normal - lightDir); The amount of specular light is then calculated using the reflection vector and the viewing direction. The smaller the angle between the viewer and the light source the greater the specular light reflection will be. The result is taken to the power of the specularPower value. The lower the specularPower value the greater the final effect is. // Determine the amount of specular light based on the reflection vector, viewing direction, and specular power. specular = pow(saturate(dot(reflection, input.viewDirection)), specularPower); } // Multiply the texture pixel and the input color to get the textured result. color = color * textureColor; We don't add the specular effect until the end. It is a highlight and needs to be added to the final value or it will not show up properly. // Add the specular component last to the output color. color = saturate(color + specular); return color; }

Lightshaderclass.h
The LightShaderClass has been modified from the previous tutorial to handle specular lighting now. //////////////////////////////////////////////////////////////////////////////// // Filename: lightshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _LIGHTSHADERCLASS_H_ #define _LIGHTSHADERCLASS_H_

6 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: LightShaderClass //////////////////////////////////////////////////////////////////////////////// class LightShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; We add a new camera buffer structure to match the new camera constant buffer in the vertex shader. Note we add a padding to make the structure size a multiple of 16 to prevent CreateBuffer failing when using sizeof with this structure. struct CameraBufferType { D3DXVECTOR3 cameraPosition; float padding; }; The LightBufferType has been modified to hold a specular color and specular power to match the light constant buffer in the pixel shader. Pay attention to the fact that I placed the specular power by the light direction to form a 4 float slot instead of using padding so that the structure could be kept in multiples of 16 bytes. Also had specular power been placed last in the structure and no padding used beneath light direction then the shader would not have functioned correctly. This is because even though the structure was a multiple of 16 the individual slots themselves were not aligned logically to 16 bytes each. struct LightBufferType { D3DXVECTOR4 ambientColor; D3DXVECTOR4 diffuseColor; D3DXVECTOR3 lightDirection; float specularPower; D3DXVECTOR4 specularColor;

7 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

}; public: LightShaderClass(); LightShaderClass(const LightShaderClass&); ~LightShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR3, D3DXVECTOR4, D3DX D3DXVECTOR3, D3DXVECTOR4, float); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR3, D3DXVECT D3DXVECTOR3, D3DXVECTOR4, float); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11SamplerState* m_sampleState; ID3D11Buffer* m_matrixBuffer; We add a new camera constant buffer here which will be used for setting the camera position in the vertex shader. ID3D11Buffer* m_cameraBuffer; ID3D11Buffer* m_lightBuffer; }; #endif

8 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; polygonLayout[2].SemanticName = "NORMAL"; polygonLayout[2].SemanticIndex = 0; polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[2].InputSlot = 0; polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[2].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result))

12 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

{ return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } // Setup the description of the dynamic matrix constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) {

13 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, D3DXVECTOR3 lightDirection, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 cameraPosition, D3DXVECTOR4 specularColor, float specularPower) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2; CameraBufferType* dataPtr3;

17 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr3 = (CameraBufferType*)mappedResource.pData; // Copy the camera position into the constant buffer. dataPtr3->cameraPosition = cameraPosition; dataPtr3->padding = 0.0f; // Unlock the camera constant buffer. deviceContext->Unmap(m_cameraBuffer, 0); Note that we set the bufferNumber to 1 instead of 0 before setting the constant buffer. This is because it is the second buffer in the vertex shader (the first being the matrix buffer). // Set the position of the camera constant buffer in the vertex shader. bufferNumber = 1; // Now set the camera constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_cameraBuffer); // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the light constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; The light constant buffer now sets the specular color and specular power so that the pixel shader can perform specular lighting calculations. // Copy the lighting variables into the light constant buffer. dataPtr2->ambientColor = ambientColor; dataPtr2->diffuseColor = diffuseColor; dataPtr2->lightDirection = lightDirection; dataPtr2->specularColor = specularColor;

18 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

dataPtr2->specularPower = specularPower; // Unlock the light constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); return true; }

Lightclass.h
The LightClass has been modified for this tutorial to include specular components and specular related helper functions. //////////////////////////////////////////////////////////////////////////////// // Filename: lightclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _LIGHTCLASS_H_ #define _LIGHTCLASS_H_

19 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

////////////// // INCLUDES // ////////////// #include <d3dx10math.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: LightClass //////////////////////////////////////////////////////////////////////////////// class LightClass { public: LightClass(); LightClass(const LightClass&); ~LightClass(); void SetAmbientColor(float, float, float, float); void SetDiffuseColor(float, float, float, float); void SetDirection(float, float, float); void SetSpecularColor(float, float, float, float); void SetSpecularPower(float); D3DXVECTOR4 GetAmbientColor(); D3DXVECTOR4 GetDiffuseColor(); D3DXVECTOR3 GetDirection(); D3DXVECTOR4 GetSpecularColor(); float GetSpecularPower(); private: D3DXVECTOR4 m_ambientColor; D3DXVECTOR4 m_diffuseColor; D3DXVECTOR3 m_direction; D3DXVECTOR4 m_specularColor; float m_specularPower; }; #endif

Lightclass.cpp

20 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

//////////////////////////////////////////////////////////////////////////////// // Filename: lightclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "lightclass.h"

LightClass::LightClass() { }

LightClass::LightClass(const LightClass& other) { }

LightClass::~LightClass() { }

void LightClass::SetAmbientColor(float red, float green, float blue, float alpha) { m_ambientColor = D3DXVECTOR4(red, green, blue, alpha); return; }

void LightClass::SetDiffuseColor(float red, float green, float blue, float alpha) { m_diffuseColor = D3DXVECTOR4(red, green, blue, alpha); return; }

void LightClass::SetDirection(float x, float y, float z) { m_direction = D3DXVECTOR3(x, y, z); return; }

void LightClass::SetSpecularColor(float red, float green, float blue, float alpha) { m_specularColor = D3DXVECTOR4(red, green, blue, alpha);

21 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

return; }

void LightClass::SetSpecularPower(float power) { m_specularPower = power; return; }

D3DXVECTOR4 LightClass::GetAmbientColor() { return m_ambientColor; }

D3DXVECTOR4 LightClass::GetDiffuseColor() { return m_diffuseColor; }

D3DXVECTOR3 LightClass::GetDirection() { return m_direction; }

D3DXVECTOR4 LightClass::GetSpecularColor() { return m_specularColor; }

float LightClass::GetSpecularPower() { return m_specularPower; }

Graphicsclass.h

22 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

The header file for the GraphicsClass has not changed for this tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GRAPHICSCLASS_H_ #define _GRAPHICSCLASS_H_

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "lightshaderclass.h" #include "lightclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

23 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; LightShaderClass* m_LightShader; LightClass* m_Light; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; m_LightShader = 0; m_Light = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

24 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; } // Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR); if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK); return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Set the initial position of the camera. m_Camera->SetPosition(0.0f, 0.0f, -10.0f); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/seafloor.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } // Create the light shader object. m_LightShader = new LightShaderClass; if(!m_LightShader) {

25 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

return false; } // Initialize the light shader object. result = m_LightShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK); return false; } // Create the light object. m_Light = new LightClass; if(!m_Light) { return false; } In the light class object we now set the specular color and the specular power. For this tutorial we set the specular color to white and set the specular power to 32. Remember that the lower the specular power value the greater the specular effect will be. // Initialize the light object. m_Light->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f); m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetDirection(0.0f, 0.0f, 1.0f); m_Light->SetSpecularColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetSpecularPower(32.0f); return true; }

void GraphicsClass::Shutdown() { // Release the light object. if(m_Light) { delete m_Light; m_Light = 0; } // Release the light shader object. if(m_LightShader) { m_LightShader->Shutdown();

26 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

delete m_LightShader; m_LightShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

bool GraphicsClass::Frame() { bool result; static float rotation = 0.0f;

// Update the rotation variable each frame. rotation += (float)D3DX_PI * 0.005f; if(rotation > 360.0f) { rotation -= 360.0f; } // Render the graphics scene.

27 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

result = Render(rotation); if(!result) { return false; } return true; }

bool GraphicsClass::Render(float rotation) { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix; bool result;

// Clear the buffers to begin the scene. m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f); // Generate the view matrix based on the camera's position. m_Camera->Render(); // Get the world, view, and projection matrices from the camera and d3d objects. m_Camera->GetViewMatrix(viewMatrix); m_D3D->GetWorldMatrix(worldMatrix); m_D3D->GetProjectionMatrix(projectionMatrix); // Rotate the world matrix by the rotation value so that the triangle will spin. D3DXMatrixRotationY(&worldMatrix, rotation); // Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing. m_Model->Render(m_D3D->GetDeviceContext()); The light shader render function now takes in the camera position, the light specular color, and the light specular power. // Render the model using the light shader. result = m_LightShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(), m_Light->GetDirection(), m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Camera->GetPosition(), m_Light->GetSpecularColor(), m_Light->GetSpecularPower()); if(!result) { return false; } // Present the rendered scene to the screen.

28 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

m_D3D->EndScene(); return true; }

Summary
With the addition of specular lighting we now get a bright white flash each time the cube surface evenly faces the camera viewing direction.

To Do Exercises
1. Recompile and run the project and ensure you get a spinning cube that flashes a bright specular highlight each time if faces the camera. 2. Change the direction of the light such as m_Light->SetDirection(1.0f, 0.0f, 1.0f) to see the effect if the light source is from a different direction. 3. Create a 5000+ poly sphere model with a red texture to recreate the sphere images at the top of the tutorial.

Source Code
Visual Studio 2010 Project: dx11tut10.zip Source Only: dx11src10.zip

29 of 30

3/8/2013 12:30 PM

Tutorial 10: Specular Lighting

http://www.rastertek.com/dx11tut10.html

Executable Only: dx11exe10.zip

Back to Tutorial Index

30 of 30

http://www.rastertek.com/dx11tut11.html

#endif

Bitmapclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: bitmapclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "bitmapclass.h" The class constructor initializes all the private pointers in the class. BitmapClass::BitmapClass() { m_vertexBuffer = 0; m_indexBuffer = 0; m_Texture = 0; }

BitmapClass::BitmapClass(const BitmapClass& other) { }

BitmapClass::~BitmapClass() { }

bool BitmapClass::Initialize(ID3D11Device* device, int screenWidth, int screenHeight, WCHAR* textureFilename, int bitmapWidth, int bitmapHeight) { bool result; In the Initialize function both the screen size and image size are stored. These will be required for generating exact vertex locations during rendering. Note that the pixels of the image do not need to be exactly the same as the texture that is used, you can set this to any size and use any size texture you want also. // Store the screen size. m_screenWidth = screenWidth; m_screenHeight = screenHeight; // Store the size in pixels that this bitmap should be rendered at. m_bitmapWidth = bitmapWidth;

5 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

m_bitmapHeight = bitmapHeight; The previous rendering location is first initialized to negative one. This will be an important variable that will locate where it last drew this image. If the image location hasn't changed since last frame then it won't modify the dynamic vertex buffer which will save us some cycles. // Initialize the previous rendering position to negative one. m_previousPosX = -1; m_previousPosY = -1; The buffers are then created and the texture for this bitmap image is also loaded in. // Initialize the vertex and index buffers. result = InitializeBuffers(device); if(!result) { return false; } // Load the texture for this model. result = LoadTexture(device, textureFilename); if(!result) { return false; } return true; } The Shutdown function will release the vertex and index buffers as well as the texture that was used for the bitmap image. void BitmapClass::Shutdown() { // Release the model texture. ReleaseTexture(); // Shutdown the vertex and index buffers. ShutdownBuffers(); return; } Render puts the buffers of the 2D image on the video card. As input it takes the position of where to render the image on the screen. The UpdateBuffers function is called with the position parameters. If the position has changed since the last frame it will then update the location of the vertices in the dynamic vertex buffer to the new location. If not it will skip the UpdateBuffers function. After that the RenderBuffers function will prepare the final vertices/indices for rendering.

6 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

http://www.rastertek.com/dx11tut11.html

The following function loads the texture that will be used for drawing the 2D image. bool BitmapClass::LoadTexture(ID3D11Device* device, WCHAR* filename) { bool result;

// Create the texture object. m_Texture = new TextureClass; if(!m_Texture) { return false; } // Initialize the texture object. result = m_Texture->Initialize(device, filename); if(!result) { return false; } return true; } This ReleaseTexture function releases the texture that was loaded. void BitmapClass::ReleaseTexture() { // Release the texture object. if(m_Texture) { m_Texture->Shutdown(); delete m_Texture; m_Texture = 0; } return; }

http://www.rastertek.com/dx11tut11.html

D3DClass::D3DClass() { m_swapChain = 0; m_device = 0; m_deviceContext = 0; m_renderTargetView = 0; m_depthStencilBuffer = 0; m_depthStencilState = 0; m_depthStencilView = 0; m_rasterState = 0; Initialize the new depth stencil state to null in the class constructor. m_depthDisabledStencilState = 0; }

D3DClass::D3DClass(const D3DClass& other) { }

D3DClass::~D3DClass() { }

bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear) { HRESULT result; IDXGIFactory* factory; IDXGIAdapter* adapter; IDXGIOutput* adapterOutput; unsigned int numModes, i, numerator, denominator, stringLength; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; int error; DXGI_SWAP_CHAIN_DESC swapChainDesc; D3D_FEATURE_LEVEL featureLevel; ID3D11Texture2D* backBufferPtr; D3D11_TEXTURE2D_DESC depthBufferDesc; D3D11_DEPTH_STENCIL_DESC depthStencilDesc; D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; D3D11_RASTERIZER_DESC rasterDesc;

16 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

m_rasterState = 0; } if(m_depthStencilView) { m_depthStencilView->Release(); m_depthStencilView = 0; } if(m_depthStencilState) { m_depthStencilState->Release(); m_depthStencilState = 0; } if(m_depthStencilBuffer) { m_depthStencilBuffer->Release(); m_depthStencilBuffer = 0; } if(m_renderTargetView) { m_renderTargetView->Release(); m_renderTargetView = 0; } if(m_deviceContext) { m_deviceContext->Release(); m_deviceContext = 0; } if(m_device) { m_device->Release(); m_device = 0; } if(m_swapChain) { m_swapChain->Release(); m_swapChain = 0; }

25 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

return; }

void D3DClass::BeginScene(float red, float green, float blue, float alpha) { float color[4];

ID3D11Device* D3DClass::GetDevice() {

26 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

return m_device; }

ID3D11DeviceContext* D3DClass::GetDeviceContext() { return m_deviceContext; }

void D3DClass::GetProjectionMatrix(D3DXMATRIX& projectionMatrix) { projectionMatrix = m_projectionMatrix; return; }

void D3DClass::GetWorldMatrix(D3DXMATRIX& worldMatrix) { worldMatrix = m_worldMatrix; return; }

void D3DClass::GetOrthoMatrix(D3DXMATRIX& orthoMatrix) { orthoMatrix = m_orthoMatrix; return; }

void D3DClass::GetVideoCardInfo(char* cardName, int& memory) { strcpy_s(cardName, 128, m_videoCardDescription); memory = m_videoCardMemory; return; } These are the new functions for enabling and disabling the Z buffer. To turn Z buffering on we set the original depth stencil. To turn Z buffering off we set the new depth stencil that has depthEnable set to false. Generally the best way to use these functions is first do all your 3D rendering, then turn the Z buffer off and do your 2D rendering, and then turn the Z buffer on again. void D3DClass::TurnZBufferOn() { m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);

http://www.rastertek.com/dx11tut11.html

m_Bitmap = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

30 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

m_TextureShader = new TextureShaderClass; if(!m_TextureShader) { return false; } // Initialize the texture shader object. result = m_TextureShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK); return false; } Here is where we create and initialize the new BitmapClass object. It uses the seafloor.dds as the texture and I set the size to 256x256. You can change this size to whatever you like as it does not need to reflect the exact size of the texture. // Create the bitmap object. m_Bitmap = new BitmapClass; if(!m_Bitmap) { return false; } // Initialize the bitmap object. result = m_Bitmap->Initialize(m_D3D->GetDevice(), screenWidth, screenHeight, L"../Engine/data/seafloor.dds", 256, 256); if(!result) { MessageBox(hwnd, L"Could not initialize the bitmap object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { The BitmapClass object is released in the Shutdown function. // Release the bitmap object. if(m_Bitmap) { m_Bitmap->Shutdown();

31 of 35

3/8/2013 12:31 PM

Tutorial 11: 2D Rendering

http://www.rastertek.com/dx11tut11.html

http://www.rastertek.com/dx11tut11.html

To Do Exercises
1. Recompile the code and ensure you get a 2D image drawn to the 100, 100 location on your screen. 2. Change the location on the screen where the image is drawn to. 3. Change the size of the image in the m_Bitmap->Initialize function call in the GraphicsClass. 4. Change the texture that is used for the 2D image.

//////////////////////////////////////////////////////////////////////////////// // Class name: FrustumClass

2 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

//////////////////////////////////////////////////////////////////////////////// class FrustumClass { public: FrustumClass(); FrustumClass(const FrustumClass&); ~FrustumClass(); void ConstructFrustum(float, D3DXMATRIX, D3DXMATRIX); bool CheckPoint(float, float, float); bool CheckCube(float, float, float, float); bool CheckSphere(float, float, float, float); bool CheckRectangle(float, float, float, float, float, float); private: D3DXPLANE m_planes[6]; }; #endif

Frustumclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: frustumclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "frustumclass.h"

http://www.rastertek.com/dx11tut16.html

return false; } return true; } CheckSphere checks if the radius of the sphere from the center point is inside all six planes of the viewing frustum. If it is outside any of them then the sphere cannot be seen and the function will return false. If it is inside all six the function returns true that the sphere can be seen. bool FrustumClass::CheckSphere(float xCenter, float yCenter, float zCenter, float radius) { int i;

// Check if the radius of the sphere is inside the view frustum. for(i=0; i<6; i++) { if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3(xCenter, yCenter, zCenter)) < -radius) { return false; } } return true; } CheckRectangle works the same as CheckCube except that that it takes as input the x radius, y radius, and z radius of the rectangle instead of just a single radius of a cube. It can then calculate the 8 corner points of the rectangle and do the frustum checks similar to the CheckCube function. bool FrustumClass::CheckRectangle(float xCenter, float yCenter, float zCenter, float xSize, float ySize, float zSize) { int i;

// Check if any of the 6 planes of the rectangle are inside the view frustum. for(i=0; i<6; i++) { if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter - xSize), (yCenter - ySize), (zCenter - zSize))) >= 0.0f) { continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter + xSize), (yCenter - ySize), (zCenter - zSize))) >= 0.0f) {

7 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter - xSize), (yCenter + ySize), (zCenter - zSize))) >= 0.0f) { continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter - xSize), (yCenter - ySize), (zCenter + zSize))) >= 0.0f) { continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter + xSize), (yCenter + ySize), (zCenter - zSize))) >= 0.0f) { continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter + xSize), (yCenter - ySize), (zCenter + zSize))) >= 0.0f) { continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter - xSize), (yCenter + ySize), (zCenter + zSize))) >= 0.0f) { continue; } if(D3DXPlaneDotCoord(&m_planes[i], &D3DXVECTOR3((xCenter + xSize), (yCenter + ySize), (zCenter + zSize))) >= 0.0f) { continue; } return false; } return true; }

Modellistclass.h
ModelListClass is a new class for maintaining information about all the models in the scene. For this tutorial it only maintains the size and color of the sphere

8 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

models since we only have one model type. This class can be expanded to maintain all the different types of models in the scene and indexes to their ModelClass but I am keeping this tutorial simple for now. /////////////////////////////////////////////////////////////////////////////// // Filename: modellistclass.h /////////////////////////////////////////////////////////////////////////////// #ifndef _MODELLISTCLASS_H_ #define _MODELLISTCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3dx10math.h> #include <stdlib.h> #include <time.h>

/////////////////////////////////////////////////////////////////////////////// // Class name: ModelListClass /////////////////////////////////////////////////////////////////////////////// class ModelListClass { private: struct ModelInfoType { D3DXVECTOR4 color; float positionX, positionY, positionZ; }; public: ModelListClass(); ModelListClass(const ModelListClass&); ~ModelListClass(); bool Initialize(int); void Shutdown(); int GetModelCount(); void GetData(int, float&, float&, float&, D3DXVECTOR4&); private: int m_modelCount; ModelInfoType* m_ModelInfoList; };

9 of 32

3/8/2013 12:34 PM

http://www.rastertek.com/dx11tut16.html

return m_modelCount; } The GetData function extracts the position and color of a sphere at the given input index location. void ModelListClass::GetData(int index, float& positionX, float& positionY, float& positionZ, D3DXVECTOR4& color) { positionX = m_ModelInfoList[index].positionX; positionY = m_ModelInfoList[index].positionY; positionZ = m_ModelInfoList[index].positionZ; color = m_ModelInfoList[index].color; return; }

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f; The GraphicsClass for this tutorial includes a number of class we have used in the previous tutorials. It also includes the frustumclass.h and modellistclass.h header which are new. /////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "textclass.h"

12 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

#include "modelclass.h" #include "lightshaderclass.h" #include "lightclass.h" #include "modellistclass.h" #include "frustumclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(float); bool Render(); private: Two of the new private class objects are the m_Frustum and m_ModelList. D3DClass* m_D3D; CameraClass* m_Camera; TextClass* m_Text; ModelClass* m_Model; LightShaderClass* m_LightShader; LightClass* m_Light; ModelListClass* m_ModelList; FrustumClass* m_Frustum; }; #endif

Graphicsclass.cpp
I will just cover the functions that have changed since the previous tutorials.

13 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

//////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "graphicsclass.h" The class constructor initializes the private member variables to null. GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Text = 0; m_Model = 0; m_LightShader = 0; m_Light = 0; m_ModelList = 0; m_Frustum = 0; }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result; D3DXMATRIX baseViewMatrix;

14 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

return false; } // Initialize a base view matrix with the camera for 2D user interface rendering. m_Camera->SetPosition(0.0f, 0.0f, -1.0f); m_Camera->Render(); m_Camera->GetViewMatrix(baseViewMatrix); // Create the text object. m_Text = new TextClass; if(!m_Text) { return false; } // Initialize the text object. result = m_Text->Initialize(m_D3D->GetDevice(), m_D3D->GetDeviceContext(), hwnd, screenWidth, screenHeight, baseViewMatrix); if(!result) { MessageBox(hwnd, L"Could not initialize the text object.", L"Error", MB_OK); return false; } // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } We load a sphere model instead of a cube model for this tutorial. // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), L"../Engine/data/seafloor.dds", "../Engine/data/sphere.txt"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } // Create the light shader object. m_LightShader = new LightShaderClass; if(!m_LightShader) { return false;

15 of 32

3/8/2013 12:34 PM

http://www.rastertek.com/dx11tut16.html

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

// Update the rotation using the turning speed. m_rotationY -= m_leftTurnSpeed; if(m_rotationY < 0.0f) { m_rotationY += 360.0f; } return; }

void PositionClass::TurnRight(bool keydown) { // If the key is pressed increase the speed at which the camera turns right. If not slow down the turn speed. if(keydown) { m_rightTurnSpeed += m_frameTime * 0.01f; if(m_rightTurnSpeed > (m_frameTime * 0.15f)) { m_rightTurnSpeed = m_frameTime * 0.15f; } } else { m_rightTurnSpeed -= m_frameTime* 0.005f; if(m_rightTurnSpeed < 0.0f) { m_rightTurnSpeed = 0.0f; } } // Update the rotation using the turning speed. m_rotationY += m_rightTurnSpeed; if(m_rotationY > 360.0f) { m_rotationY -= 360.0f; } return; }

24 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

Systemclass.h
The SystemClass has been modified to use the new PostionClass. //////////////////////////////////////////////////////////////////////////////// // Filename: systemclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _SYSTEMCLASS_H_ #define _SYSTEMCLASS_H_

/////////////////////////////// // PRE-PROCESSING DIRECTIVES // /////////////////////////////// #define WIN32_LEAN_AND_MEAN

////////////// // INCLUDES // ////////////// #include <windows.h>

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "inputclass.h" #include "graphicsclass.h" #include "timerclass.h" #include "positionclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: SystemClass //////////////////////////////////////////////////////////////////////////////// class SystemClass { public: SystemClass(); SystemClass(const SystemClass&); ~SystemClass();

25 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

bool Initialize(); void Shutdown(); void Run(); LRESULT CALLBACK MessageHandler(HWND, UINT, WPARAM, LPARAM); private: bool Frame(); void InitializeWindows(int&, int&); void ShutdownWindows(); private: LPCWSTR m_applicationName; HINSTANCE m_hinstance; HWND m_hwnd; InputClass* m_Input; GraphicsClass* m_Graphics; TimerClass* m_Timer; PositionClass* m_Position; };

///////////////////////// // FUNCTION PROTOTYPES // ///////////////////////// static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

///////////// // GLOBALS // ///////////// static SystemClass* ApplicationHandle = 0;

#endif

Systemclass.cpp
I will cover just the functions that have changed in this class since the previous tutorials. ////////////////////////////////////////////////////////////////////////////////

26 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

// Filename: systemclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "systemclass.h"

SystemClass::SystemClass() { m_Input = 0; m_Graphics = 0; m_Timer = 0; The new PositionClass object is initialized to null in the class constructor. m_Position = 0; }

bool SystemClass::Initialize() { int screenWidth, screenHeight; bool result;

27 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

// Create the graphics object. This object will handle rendering all the graphics for this application. m_Graphics = new GraphicsClass; if(!m_Graphics) { return false; } // Initialize the graphics object. result = m_Graphics->Initialize(screenWidth, screenHeight, m_hwnd); if(!result) { return false; } // Create the timer object. m_Timer = new TimerClass; if(!m_Timer) { return false; } // Initialize the timer object. result = m_Timer->Initialize(); if(!result) { MessageBox(m_hwnd, L"Could not initialize the Timer object.", L"Error", MB_OK); return false; } Create the new PositionClass object here. It doesn't require any initialization. // Create the position object. m_Position = new PositionClass; if(!m_Position) { return false; } return true; }

void SystemClass::Shutdown() {

28 of 32

3/8/2013 12:34 PM

Tutorial 16: Frustum Culling

http://www.rastertek.com/dx11tut16.html

http://www.rastertek.com/dx11tut16.html

To Do Exercises
1. Recompile and run the program. Use the left and right arrow key to move the camera and update the render count in the upper left corner. 2. Load the cube model instead and change the cull check to CheckCube. 3. Create some different models and test which of the culling checks works best for them.

Source Code
Visual Studio 2008 Project: dx11tut16.zip Source Only: dx11src16.zip Executable Only: dx11exe16.zip

Back to Tutorial Index

32 of 32

3/8/2013 12:34 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

Tutorial 17: Multitexturing and Texture Arrays

This tutorial will cover how to do multitexturing in DirectX 11 as well as how to implement texture arrays in DirectX 11. Multitexturing is the process of blending two different textures to create a final texture. The equation you use to blend the two textures can differ depending on the result you are trying to achieve. In this tutorial we will look at just combining the average pixel color of the two textures to create an evenly blended final texture. Texture arrays is a new feature since DirectX 10 that allows you to have multiple textures active at once in the gpu. Past methods where only a single texture was ever active in the gpu caused a lot of extra processing to load and unload textures all the time. Most people got around this problem by using texture aliases (loading a bunch of textures onto one large texture) and just using different UV coordinates. However texture aliases are no longer needed with this new feature. The first texture used in this tutorial we will call the base texture which looks like the following:

The second texture we will use to combine with the first one will be called the color texture. It looks like the following:

1 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

These two textures will be combined in the pixel shader on a pixel by pixel basis. The blending equation we will use will be the following: blendColor = basePixel * colorPixel * gammaCorrection; Using that equation and the two textures we will get the following result:

Now you may be wondering why I didn't just add together the average of the pixels such as the following: blendColor = (basePixel * 0.5) + (colorPixel * 0.5); The reason being is that the pixel color presented to us has been corrected to the gamma of the monitor. This makes the pixel values from 0.0 to 1.0 follow a

2 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

non-linear curve. Therefore we need gamma correction when working in the pixel shader to deal with non-linear color values. If we don't correct for gamma and just do the average addition function we get a washed out result such as this:

Also note that most devices have different gamma values and most require a look up table or a gamma slider so the user can choose the gamma settings for their device. In this example I just choose 2.0 as my gamma value to make the tutorial simple. We'll start the code section by first looking at the new multitexture shader which was originally based on the texture shader file with some slight changes.

Multitexture.vs
The only change to the vertex shader is the name. //////////////////////////////////////////////////////////////////////////////// // Filename: multitexture.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix;

3 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

};

////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType MultiTextureVertexShader(VertexInputType input) { PixelInputType output;

Multitexture.ps

4 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

//////////////////////////////////////////////////////////////////////////////// // Filename: multitexture.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// We have added a two element texture array resource here for the two different textures that will be blended together. Texture arrays are more efficient that using single texture resources in terms of performance on the graphics card. Switching textures was very costly in earlier versions of DirectX forcing most engines to be written around texture and material switches. Texture arrays help reduce that performance cost. Texture2D shaderTextures[2]; SamplerState SampleType;

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; }; The pixel shader is where all the work of this tutorial is done. We take a sample of the pixel from both textures at this current texture coordinate. After that we combine them using multiplication since they are non-linear due to gamma correction. We also multiply by a gamma value, we have used 2.0 in this example as it is close to most monitor's gamma value. Once we have the blended pixel we saturate it and then return it as our final result. Notice also the indexing method used to access the two textures in the texture array. //////////////////////////////////////////////////////////////////////////////// // Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 MultiTexturePixelShader(PixelInputType input) : SV_TARGET { float4 color1; float4 color2; float4 blendColor;

// Get the pixel color from the first texture. color1 = shaderTextures[0].Sample(SampleType, input.tex); // Get the pixel color from the second texture.

5 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

color2 = shaderTextures[1].Sample(SampleType, input.tex); // Blend the two pixels together and multiply by the gamma value. blendColor = color1 * color2 * 2.0; // Saturate the final color. blendColor = saturate(blendColor); return blendColor; }

Multitextureshaderclass.h
The multitexture shader code is based on the TextureShaderClass with some slight modifications. //////////////////////////////////////////////////////////////////////////////// // Filename: multitextureshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _MULTITEXTURESHADERCLASS_H_ #define _MULTITEXTURESHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: MultiTextureShaderClass //////////////////////////////////////////////////////////////////////////////// class MultiTextureShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view;

6 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

D3DXMATRIX projection; }; public: MultiTextureShaderClass(); MultiTextureShaderClass(const MultiTextureShaderClass&); ~MultiTextureShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView**); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView**); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState; }; #endif

Multitextureshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: multitextureshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "multitextureshaderclass.h"

MultiTextureShaderClass::MultiTextureShaderClass() { m_vertexShader = 0; m_pixelShader = 0;

7 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; }

MultiTextureShaderClass::MultiTextureShaderClass(const MultiTextureShaderClass& other) { }

MultiTextureShaderClass::~MultiTextureShaderClass() { }

bool MultiTextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; The multitexture HLSL shader files are loaded here in the Initialize function. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/multitexture.vs", L"../Engine/multitexture.ps"); if(!result) { return false; } return true; } Shutdown calls the ShutdownShader function to release the shader related interfaces. void MultiTextureShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; } The Render function now takes as input a pointer to the texture array. This will give the shader access to the two textures for blending operations. bool MultiTextureShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix,

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

// Get the length of the message. bufferSize = errorMessage->GetBufferSize(); // Open a file to write the error message to. fout.open("shader-error.txt"); // Write out the error message. for(i=0; i<bufferSize; i++) { fout << compileErrors[i]; } // Close the file. fout.close(); // Release the error message. errorMessage->Release(); errorMessage = 0; // Pop a message up on the screen to notify the user to check the text file for compile errors. MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK); return; } SetShaderParameters sets the matrices and texture array in the shader before rendering. bool MultiTextureShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView** textureArray) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber;

14 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

{ return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the matrix constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the matrix constant buffer in the vertex shader. bufferNumber = 0; // Now set the matrix constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); Here is where the texture array is set before rendering. The PSSetShaderResources function is used to set the texture array. The first parameter is where to start in the array. The second parameter is how many textures are in the array that is being passed in. And the third parameter is a pointer to the texture array. // Set shader texture array resource in the pixel shader. deviceContext->PSSetShaderResources(0, 2, textureArray); return true; } The RenderShader function sets the layout, shaders, and sampler. It then draws the model using the shader. void MultiTextureShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0); deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Set the sampler state in the pixel shader. deviceContext->PSSetSamplers(0, 1, &m_sampleState); // Render the triangles.

15 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

deviceContext->DrawIndexed(indexCount, 0, 0); return; }

Texturearrayclass.h
The TextureArrayClass replaces the TextureClass that was used before. Instead of having just a single texture it can now have multiple textures and give calling objects access to those textures. For this tutorial it just handles two textures but it can easily be expanded. //////////////////////////////////////////////////////////////////////////////// // Filename: texturearrayclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TEXTUREARRAYCLASS_H_ #define _TEXTUREARRAYCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx11tex.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: TextureArrayClass //////////////////////////////////////////////////////////////////////////////// class TextureArrayClass { public: TextureArrayClass(); TextureArrayClass(const TextureArrayClass&); ~TextureArrayClass(); bool Initialize(ID3D11Device*, WCHAR*, WCHAR*); void Shutdown(); ID3D11ShaderResourceView** GetTextureArray(); private: This is the two element texture array private variable.

16 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

ID3D11ShaderResourceView* m_textures[2]; }; #endif

Texturearrayclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: texturearrayclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "texturearrayclass.h" The class constructor initializes the texture array elements to null. TextureArrayClass::TextureArrayClass() { m_textures[0] = 0; m_textures[1] = 0; }

TextureArrayClass::TextureArrayClass(const TextureArrayClass& other) { }

TextureArrayClass::~TextureArrayClass() { } Initialize takes in the two texture file names and creates two texture resources in the texture array from those files. bool TextureArrayClass::Initialize(ID3D11Device* device, WCHAR* filename1, WCHAR* filename2) { HRESULT result;

// Load the first texture in. result = D3DX11CreateShaderResourceViewFromFile(device, filename1, NULL, NULL, &m_textures[0], NULL); if(FAILED(result)) { return false;

17 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

} // Load the second texture in. result = D3DX11CreateShaderResourceViewFromFile(device, filename2, NULL, NULL, &m_textures[1], NULL); if(FAILED(result)) { return false; } return true; } The Shutdown function releases each element in the texture array. void TextureArrayClass::Shutdown() { // Release the texture resources. if(m_textures[0]) { m_textures[0]->Release(); m_textures[0] = 0; } if(m_textures[1]) { m_textures[1]->Release(); m_textures[1] = 0; } return; } GetTextureArray returns a pointer to the texture array so calling objects can have access to the textures in the texture array. ID3D11ShaderResourceView** TextureArrayClass::GetTextureArray() { return m_textures; }

bool ModelClass::Initialize(ID3D11Device* device, char* modelFilename, WCHAR* textureFilename1, WCHAR* textureFilename2) { bool result;

// Load in the model data, result = LoadModel(modelFilename); if(!result) { return false; } // Initialize the vertex and index buffers. result = InitializeBuffers(device); if(!result) { return false; } We call the LoadTextures function which takes in multiple file names for textures that will be loaded into the texture array and rendered as a blended result on this model. // Load the textures for this model. result = LoadTextures(device, textureFilename1, textureFilename2); if(!result) { return false; } return true; }

21 of 30

3/8/2013 12:37 PM

http://www.rastertek.com/dx11tut17.html

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; We initialize the new multitexture shader object to null in the class constructor. m_MultiTextureShader = 0; }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result; D3DXMATRIX baseViewMatrix;

25 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

// Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } The ModelClass object is now initialized differently. For this tutorial we load in the square.txt model as the effect we want to display works best on just a plain square. We also now load in two textures for the texture array instead of just a single texture like we did in previous tutorials. // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), "../Engine/data/square.txt", L"../Engine/data/stone01.dds", L"../Engine/data/dirt01.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } Here we create and initialize the new multitexture shader object. // Create the multitexture shader object. m_MultiTextureShader = new MultiTextureShaderClass; if(!m_MultiTextureShader) { return false; } // Initialize the multitexture shader object. result = m_MultiTextureShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the multitexture shader object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { We release the multitexture shader in the Shutdown function.

26 of 30

3/8/2013 12:37 PM

Tutorial 17: Multitexturing and Texture Arrays

http://www.rastertek.com/dx11tut17.html

// Release the multitexture shader object. if(m_MultiTextureShader) { m_MultiTextureShader->Shutdown(); delete m_MultiTextureShader; m_MultiTextureShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

http://www.rastertek.com/dx11tut18.html

Once we have our color texture and our light map we can combine them in the pixel shader to produce the light mapped texture. The shader is very simple as we just multiply the two pixels together which will produce the following output:

Lightmap.vs
The light map vertex shader is the same as the multitexture vertex shader from the previous tutorial. The only thing that has changed is the name. ////////////////////////////////////////////////////////////////////////////////

2 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

// Filename: lightmap.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType LightMapVertexShader(VertexInputType input) { PixelInputType output;

3 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

output.position = mul(output.position, projectionMatrix); // Store the texture coordinates for the pixel shader. output.tex = input.tex; return output; }

Lightmap.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: lightmap.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTextures[2]; SamplerState SampleType;

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; }; The light map pixel shader is very simple. It multiplies the color texture pixel and the light map texture value to get the desired output. This is not much different from just a regular multitexture blend other than there is no need to correct for gamma. //////////////////////////////////////////////////////////////////////////////// // Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 LightMapPixelShader(PixelInputType input) : SV_TARGET { float4 color; float4 lightColor; float4 finalColor;

4 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

8 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } The light map pixel shader is loaded here. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "LightMapPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; }

9 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

// Create the vertex shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the matrix dynamic constant buffer that is in the vertex shader.

10 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the matrix constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } return true; }

void LightMapShaderClass::ShutdownShader() { // Release the sampler state. if(m_sampleState) {

11 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

m_sampleState->Release(); m_sampleState = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) { m_vertexShader->Release(); m_vertexShader = 0; } return; }

http://www.rastertek.com/dx11tut18.html

return; }

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" The header for the LightMapShaderClass is now included in the GraphicsClass header file. #include "lightmapshaderclass.h"

15 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); bool Render(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; We have a new variable for the LightMapShaderClass object. LightMapShaderClass* m_LightMapShader; }; #endif

Graphicsclass.cpp
I will just cover the functions that have changed since the previous tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "graphicsclass.h"

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; The new LightMapShaderClass object is initialized in the class constructor. m_LightMapShader = 0; }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)

16 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

{ bool result; D3DXMATRIX baseViewMatrix;

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; } // Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR); if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D", L"Error", MB_OK); return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Initialize a base view matrix with the camera for 2D user interface rendering. m_Camera->SetPosition(0.0f, 0.0f, -1.0f); m_Camera->Render(); m_Camera->GetViewMatrix(baseViewMatrix); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } The ModelClass object takes as input the new light01.dds light map texture for the light map shading on this model. // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), "../Engine/data/square.txt", L"../Engine/data/stone01.dds", L"../Engine/data/light01.dds"); if(!result)

17 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

http://www.rastertek.com/dx11tut18.html

{ MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } The new LightMapShaderClass object is created and initialized here. // Create the light map shader object. m_LightMapShader = new LightMapShaderClass; if(!m_LightMapShader) { return false; } // Initialize the light map shader object. result = m_LightMapShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the light map shader object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { The LightMapShaderClass object is released here in the Shutdown function. // Release the light map shader object. if(m_LightMapShader) { m_LightMapShader->Shutdown(); delete m_LightMapShader; m_LightMapShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0;

18 of 21

3/8/2013 12:37 PM

Tutorial 18: Light Maps

Tutorial 19: Alpha Mapping

Alpha mapping in DirectX 11 is the process of using the alpha layer of a texture to determine the blending amount for each pixel when combining two textures. To start the process you first create an alpha layer for a texture such as follows:

Each pixel is just a 0.0 to 1.0 float range indicating how to combine two textures. For example if the alpha value at a certain pixel is 0.3 you would take 30% of the base texture pixel value and combine it with 70% of the color texture pixel. In this tutorial we will combine the following two textures based on the alpha map:

1 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

The final result will be the following:

In this tutorial I will be separating the alpha map onto its own individual texture. This gives us the ability to create several alpha maps and then combine the same two color and base textures in many different ways. The code in this tutorial is based on the previous tutorial.

////////////// // INCLUDES // //////////////

5 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

#include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: AlphaMapShaderClass //////////////////////////////////////////////////////////////////////////////// class AlphaMapShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; public: AlphaMapShaderClass(); AlphaMapShaderClass(const AlphaMapShaderClass&); ~AlphaMapShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView**); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView**); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState; };

6 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

#endif

Alphamapshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: alphamapshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "alphamapshaderclass.h"

AlphaMapShaderClass::AlphaMapShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; }

AlphaMapShaderClass::AlphaMapShaderClass(const AlphaMapShaderClass& other) { }

AlphaMapShaderClass::~AlphaMapShaderClass() { }

bool AlphaMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; The first change is that the alphamap.vs and alphamap.ps HLSL shader files are now loaded. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/alphamap.vs", L"../Engine/alphamap.ps"); if(!result) { return false; }

7 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

return true; }

void AlphaMapShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; }

bool AlphaMapShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView** textureArray) { bool result;

bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc; D3D11_SAMPLER_DESC samplerDesc;

8 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; The alpha map vertex shader is loaded here. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "AlphaMapVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } The alpha map pixel shader is loaded here. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "AlphaMapPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); }

9 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the vertex shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) {

10 of 28

3/8/2013 12:37 PM

http://www.rastertek.com/dx11tut19.html

unsigned int bufferNumber;

// Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the matrix constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the matrix constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the matrix constant buffer in the vertex shader. bufferNumber = 0; // Now set the matrix constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); The next major change is that we now set three textures in the shader instead of two like in the previous tutorials. // Set shader texture array resource in the pixel shader. deviceContext->PSSetShaderResources(0, 3, textureArray); return true; }

void AlphaMapShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout);

14 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

// Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0); deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Set the sampler state in the pixel shader. deviceContext->PSSetSamplers(0, 1, &m_sampleState); // Render the triangles. deviceContext->DrawIndexed(indexCount, 0, 0); return; }

Texturearrayclass.h
The TextureArrayClass has been changed to handle three textures instead of two. //////////////////////////////////////////////////////////////////////////////// // Filename: texturearrayclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TEXTUREARRAYCLASS_H_ #define _TEXTUREARRAYCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx11tex.h>

15 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

bool Initialize(ID3D11Device*, WCHAR*, WCHAR*, WCHAR*); void Shutdown(); ID3D11ShaderResourceView** GetTextureArray(); private: The number of elements in the texture array is changed to three. ID3D11ShaderResourceView* m_textures[3]; }; #endif

Texturearrayclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: texturearrayclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "texturearrayclass.h" The three textures are initialized to null in the class constructor. TextureArrayClass::TextureArrayClass() { m_textures[0] = 0; m_textures[1] = 0; m_textures[2] = 0; }

TextureArrayClass::TextureArrayClass(const TextureArrayClass& other) { }

TextureArrayClass::~TextureArrayClass() { } The Initialize function now loads three textures into the texture array.

16 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

bool TextureArrayClass::Initialize(ID3D11Device* device, WCHAR* filename1, WCHAR* filename2, WCHAR* filename3) { HRESULT result;

// Load the first texture in. result = D3DX11CreateShaderResourceViewFromFile(device, filename1, NULL, NULL, &m_textures[0], NULL); if(FAILED(result)) { return false; } // Load the second texture in. result = D3DX11CreateShaderResourceViewFromFile(device, filename2, NULL, NULL, &m_textures[1], NULL); if(FAILED(result)) { return false; } // Load the third texture in. result = D3DX11CreateShaderResourceViewFromFile(device, filename3, NULL, NULL, &m_textures[2], NULL); if(FAILED(result)) { return false; } return true; } Shutdown now releases three textures. void TextureArrayClass::Shutdown() { // Release the texture resources. if(m_textures[0]) { m_textures[0]->Release(); m_textures[0] = 0; } if(m_textures[1]) { m_textures[1]->Release(); m_textures[1] = 0; }

17 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

if(m_textures[2]) { m_textures[2]->Release(); m_textures[2] = 0; } return; }

ID3D11ShaderResourceView** TextureArrayClass::GetTextureArray() { return m_textures; }

Modelclass.h
The ModelClass has been modified just slightly to handle three textures instead of two. //////////////////////////////////////////////////////////////////////////////// // Filename: modelclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _MODELCLASS_H_ #define _MODELCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <fstream> using namespace std;

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "texturearrayclass.h"

18 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

void GraphicsClass::Shutdown() { The new AlphaMapShaderClass object is released here in the Shutdown function. // Release the alpha map shader object. if(m_AlphaMapShader) { m_AlphaMapShader->Shutdown(); delete m_AlphaMapShader; m_AlphaMapShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; }

25 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

return; }

bool GraphicsClass::Render() { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix;

Summary
Alpha mapping provides an easy way of controlling on a very fine level of how to combine textures. Many terrain based applications use this to provide smooth transitions between different textures over a very large landscape.

26 of 28

3/8/2013 12:37 PM

Tutorial 19: Alpha Mapping

http://www.rastertek.com/dx11tut19.html

To Do Exercises
1. Recompile and run the program to see the alpha mapped texture combination. Press escape to quit. 2. Make some of your own alpha maps and use them to combine the two textures in different ways.

Source Code
Visual Studio 2008 Project: dx11tut19.zip Source Only: dx11src19.zip Executable Only: dx11exe19.zip

http://www.rastertek.com/dx11tut20.html

Using the normal map with the current light direction for each pixel would then produce the following bump mapped texture:

As you can see the effect is very realistic and the cost of producing it using bump mapping is far less expensive then rendering a high polygon surface to get the same result. To create a normal map you usually need someone to produce a 3D model of the surface and then use a tool to convert that 3D model into a normal map. There are also certain tools that will work with 2D textures to produce a somewhat decent normal map but it is obviously not as accurate as the 3D model version would be. The tools that create normal maps take the x, y, z coordinates and translate them to red, green, blue pixels with the intensity of each color indicating the angle of the normal they represent. The normal of our polygon surface is still calculated the same way as before. However the two other normals we need to calculate require the vertex and texture coordinates for that polygon surface. These two normals are called the tangent and binormal. The diagram below shows the direction of each

2 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

normal:

The normal is still pointing straight out towards the viewer. The tangent and binormal however run across the surface of the polygon with the tangent going along the x-axis and the binormal going along the y-axis. These two normals then directly translate to the tu and tv texture coordinates of the normal map with the texture U coordinate mapping to the tangent and the texture V coordinate mapping to the binormal. We will need to do some precalculation to determine the binormal and tangent vector using the normal and texture coordinates. Also note that you should never do this inside the shader as it is fairly expensive with all the floating point math involved, I instead use a function in my C++ code that you will see to do this during the model loading. Also if you are looking to use this effect on a large number of high polygon models it may be best to precalculate these different normals and store them in your model format. Once we have precalculated the tangent and binormal we can use this equation to determine the bump normal at any pixel using the normal map: bumpNormal = normal + bumpMap.x * tangent + bumpMap.y * binormal; Once we have the normal for that pixel we can then calculate against the light direction and multiply by the color value of the pixel from the color texture to get our final result.

Framework
The frame work for this tutorial looks like the following. The only new class is the BumpMapShaderClass.

3 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

We will start the tutorial by looking at the bump map HLSL shader code:

Bumpmap.vs
//////////////////////////////////////////////////////////////////////////////// // Filename: bumpmap.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; }; Both the VertexInputType and PixelInputType now have a tangent and binormal vector for bump map calculations. ////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0;

4 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

float3 normal : NORMAL; float3 tangent : TANGENT; float3 binormal : BINORMAL; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; float3 tangent : TANGENT; float3 binormal : BINORMAL; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType BumpMapVertexShader(VertexInputType input) { PixelInputType output;

// Change the position vector to be 4 units for proper matrix calculations. input.position.w = 1.0f; // Calculate the position of the vertex against the world, view, and projection matrices. output.position = mul(input.position, worldMatrix); output.position = mul(output.position, viewMatrix); output.position = mul(output.position, projectionMatrix); // Store the texture coordinates for the pixel shader. output.tex = input.tex; // Calculate the normal vector against the world matrix only and then normalize the final value. output.normal = mul(input.normal, (float3x3)worldMatrix); output.normal = normalize(output.normal); Both the input tangent and binormal are calculated against the world matrix and then normalized the same as the input normal vector. // Calculate the tangent vector against the world matrix only and then normalize the final value. output.tangent = mul(input.tangent, (float3x3)worldMatrix); output.tangent = normalize(output.tangent); // Calculate the binormal vector against the world matrix only and then normalize the final value.

5 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

output.binormal = mul(input.binormal, (float3x3)worldMatrix); output.binormal = normalize(output.binormal); return output; }

Bumpmap.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: bumpmap.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// The bump map shader requires two textures. The first texture in the array is the color texture. The second texture is the normal map. Texture2D shaderTextures[2]; SamplerState SampleType; Just like most light shaders the direction and color of the light is required for lighting calculations. cbuffer LightBuffer { float4 diffuseColor; float3 lightDirection; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; float3 tangent : TANGENT; float3 binormal : BINORMAL; };

6 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

The pixel shader works as we described above with a couple additional lines of code. First we sample the pixel from the color texture and the normal map. We then multiply the normal map value by two and then subtract one to move it into the -1.0 to +1.0 float range. We have to do this because the sampled value that is presented to us in the 0.0 to +1.0 texture range which only covers half the range we need for bump map normal calculations. After that we then calculate the bump normal which uses the equation we described earlier. This bump normal is normalized and then used to determine the light intensity at this pixel by doing a dot product with the light direction. Once we have the light intensity at this pixel the bump mapping is now done. We use the light intensity with the light color and texture color to get the final pixel color. //////////////////////////////////////////////////////////////////////////////// // Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 BumpMapPixelShader(PixelInputType input) : SV_TARGET { float4 textureColor; float4 bumpMap; float3 bumpNormal; float3 lightDir; float lightIntensity; float4 color;

// Sample the texture pixel at this location. textureColor = shaderTextures[0].Sample(SampleType, input.tex); // Sample the pixel in the bump map. bumpMap = shaderTextures[1].Sample(SampleType, input.tex); // Expand the range of the normal value from (0, +1) to (-1, +1). bumpMap = (bumpMap * 2.0f) - 1.0f; // Calculate the normal from the data in the bump map. bumpNormal = input.normal + bumpMap.x * input.tangent + bumpMap.y * input.binormal; // Normalize the resulting bump normal. bumpNormal = normalize(bumpNormal); // Invert the light direction for calculations. lightDir = -lightDirection; // Calculate the amount of light on this pixel based on the bump map normal value. lightIntensity = saturate(dot(bumpNormal, lightDir)); // Determine the final diffuse color based on the diffuse color and the amount of light intensity. color = saturate(diffuseColor * lightIntensity); // Combine the final bump light color with the texture color.

7 of 37

BumpMapShaderClass::BumpMapShaderClass(const BumpMapShaderClass& other) { }

BumpMapShaderClass::~BumpMapShaderClass() { } The Initialize function will call the shader to load the bump map HLSL files. bool BumpMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result;

// Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/bumpmap.vs", L"../Engine/bumpmap.ps"); if(!result) { return false; } return true; } Shutdown releases the shader effect. void BumpMapShaderClass::Shutdown() {

10 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

The light buffer in the pixel shader is then set with the diffuse light color and light direction. // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->diffuseColor = diffuseColor; dataPtr2->lightDirection = lightDirection; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); return true; } RenderShader draws the model using the bump map shader. void BumpMapShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0); deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Set the sampler state in the pixel shader. deviceContext->PSSetSamplers(0, 1, &m_sampleState); // Render the triangles. deviceContext->DrawIndexed(indexCount, 0, 0);

19 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

return; }

Modelclass.h
//////////////////////////////////////////////////////////////////////////////// // Filename: modelclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _MODELCLASS_H_ #define _MODELCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <fstream> using namespace std;

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "texturearrayclass.h"

20 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

D3DXVECTOR3 binormal; }; The ModelType structure has also been changed to have a tangent and binormal vector. struct ModelType { float x, y, z; float tu, tv; float nx, ny, nz; float tx, ty, tz; float bx, by, bz; }; The following two structures will be used for calculating the tangent and binormal. struct TempVertexType { float x, y, z; float tu, tv; float nx, ny, nz; }; struct VectorType { float x, y, z; }; public: ModelClass(); ModelClass(const ModelClass&); ~ModelClass(); bool Initialize(ID3D11Device*, char*, WCHAR*, WCHAR*); void Shutdown(); void Render(ID3D11DeviceContext*); int GetIndexCount(); ID3D11ShaderResourceView** GetTextureArray(); private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); void RenderBuffers(ID3D11DeviceContext*);

21 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

bool LoadTextures(ID3D11Device*, WCHAR*, WCHAR*); void ReleaseTextures(); bool LoadModel(char*); void ReleaseModel(); We have three new functions for calculating the tangent and binormal vectors for the model. void CalculateModelVectors(); void CalculateTangentBinormal(TempVertexType, TempVertexType, TempVertexType, VectorType&, VectorType&); void CalculateNormal(VectorType, VectorType, VectorType&); private: ID3D11Buffer *m_vertexBuffer, *m_indexBuffer; int m_vertexCount, m_indexCount; ModelType* m_model; TextureArrayClass* m_TextureArray; }; #endif

Modelclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: modelclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "modelclass.h" The Initialize function now takes in two texture filenames. The first texture filename is for the color texture. The second texture filename is for the normal map that will be used to create the bump effect. bool ModelClass::Initialize(ID3D11Device* device, char* modelFilename, WCHAR* textureFilename1, WCHAR* textureFilename2) { bool result;

// Load in the model data, result = LoadModel(modelFilename); if(!result) { return false; }

22 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

After the model data has been loaded we now call the new CalculateModelVectors function to calculate the tangent and binormal. It also recalculates the normal vector. // Calculate the normal, tangent, and binormal vectors for the model. CalculateModelVectors(); // Initialize the vertex and index buffers. result = InitializeBuffers(device); if(!result) { return false; } The two textures for the model are loaded here. The first is the color texture and the second is the normal map. // Load the textures for this model. result = LoadTextures(device, textureFilename1, textureFilename2); if(!result) { return false; } return true; }

// Create the vertex array. vertices = new VertexType[m_vertexCount]; if(!vertices) { return false; } // Create the index array. indices = new unsigned long[m_indexCount];

23 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

if(!indices) { return false; } The InitializeBuffers function has changed at this point where the vertex array is loaded with data from the ModelType array. The ModelType array now has tangent and binormal values for the model so they need to be copied into the vertex array which will then be copied into the vertex buffer. // Load the vertex array and index array with data. for(i=0; i<m_vertexCount; i++) { vertices[i].position = D3DXVECTOR3(m_model[i].x, m_model[i].y, m_model[i].z); vertices[i].texture = D3DXVECTOR2(m_model[i].tu, m_model[i].tv); vertices[i].normal = D3DXVECTOR3(m_model[i].nx, m_model[i].ny, m_model[i].nz); vertices[i].tangent = D3DXVECTOR3(m_model[i].tx, m_model[i].ty, m_model[i].tz); vertices[i].binormal = D3DXVECTOR3(m_model[i].bx, m_model[i].by, m_model[i].bz); indices[i] = i; } // Set up the description of the static vertex buffer. vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT; vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.CPUAccessFlags = 0; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the vertex data. vertexData.pSysMem = vertices; vertexData.SysMemPitch = 0; vertexData.SysMemSlicePitch = 0; // Now create the vertex buffer. result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); if(FAILED(result)) { return false; } // Set up the description of the static index buffer. indexBufferDesc.Usage = D3D11_USAGE_DEFAULT; indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.CPUAccessFlags = 0;

24 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the index data. indexData.pSysMem = indices; indexData.SysMemPitch = 0; indexData.SysMemSlicePitch = 0; // Create the index buffer. result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); if(FAILED(result)) { return false; } // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices; indices = 0; return true; } LoadTextures now creates a vertex array and then loads the color texture and normal map into the two element texture array. bool ModelClass::LoadTextures(ID3D11Device* device, WCHAR* filename1, WCHAR* filename2) { bool result;

25 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

return true; } CalculateModelVectors generates the tangent and binormal for the model as well as a recalculated normal vector. To start it calculates how many faces (triangles) are in the model. Then for each of those triangles it gets the three vertices and uses that to calculate the tangent, binormal, and normal. After calculating those three normal vectors it then saves them back into the model structure. void ModelClass::CalculateModelVectors() { int faceCount, i, index; TempVertexType vertex1, vertex2, vertex3; VectorType tangent, binormal, normal;

// Calculate the number of faces in the model. faceCount = m_vertexCount / 3; // Initialize the index to the model data. index = 0; // Go through all the faces and calculate the the tangent, binormal, and normal vectors. for(i=0; i<faceCount; i++) { // Get the three vertices for this face from the model. vertex1.x = m_model[index].x; vertex1.y = m_model[index].y; vertex1.z = m_model[index].z; vertex1.tu = m_model[index].tu; vertex1.tv = m_model[index].tv; vertex1.nx = m_model[index].nx; vertex1.ny = m_model[index].ny; vertex1.nz = m_model[index].nz; index++; vertex2.x = m_model[index].x; vertex2.y = m_model[index].y; vertex2.z = m_model[index].z; vertex2.tu = m_model[index].tu; vertex2.tv = m_model[index].tv; vertex2.nx = m_model[index].nx; vertex2.ny = m_model[index].ny; vertex2.nz = m_model[index].nz; index++;

26 of 37

3/8/2013 12:39 PM

http://www.rastertek.com/dx11tut20.html

bool Render(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; The new BumpMapShaderClass object is created here. BumpMapShaderClass* m_BumpMapShader; LightClass* m_Light; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; We initialize the BumpMapShaderClass object to null in the class constructor. m_BumpMapShader = 0; m_Light = 0; }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result; D3DXMATRIX baseViewMatrix;

31 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; } // Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR); if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D", L"Error", MB_OK); return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Initialize a base view matrix with the camera for 2D user interface rendering. m_Camera->SetPosition(0.0f, 0.0f, -1.0f); m_Camera->Render(); m_Camera->GetViewMatrix(baseViewMatrix); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } The ModelClass object is initialized with the cube model, the stone01.dds color texture, and the bump01.dds normal map. // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/stone01.dds", L"../Engine/data/bump01.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; }

32 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

Here we create and initialize the BumpMapShaderClass object. // Create the bump map shader object. m_BumpMapShader = new BumpMapShaderClass; if(!m_BumpMapShader) { return false; } // Initialize the bump map shader object. result = m_BumpMapShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the bump map shader object.", L"Error", MB_OK); return false; } // Create the light object. m_Light = new LightClass; if(!m_Light) { return false; } The light color is set to white and the light direction is set down the positive Z axis. // Initialize the light object. m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetDirection(0.0f, 0.0f, 1.0f); return true; }

void GraphicsClass::Shutdown() { // Release the light object. if(m_Light) { delete m_Light; m_Light = 0; } The new BumpMapShaderClass is released here in the Shutdown function.

33 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

// Release the bump map shader object. if(m_BumpMapShader) { m_BumpMapShader->Shutdown(); delete m_BumpMapShader; m_BumpMapShader = 0; } // Release the model object. if(m_Model) { m_Model->Shutdown(); delete m_Model; m_Model = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

bool GraphicsClass::Render() { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix, orthoMatrix; static float rotation = 0.0f;

// Clear the buffers to begin the scene. m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f); // Generate the view matrix based on the camera's position.

34 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

m_Camera->Render(); // Get the world, view, projection, and ortho matrices from the camera and D3D objects. m_D3D->GetWorldMatrix(worldMatrix); m_Camera->GetViewMatrix(viewMatrix); m_D3D->GetProjectionMatrix(projectionMatrix); m_D3D->GetOrthoMatrix(orthoMatrix); Rotate the cube model each frame to show the effect. // Update the rotation variable each frame. rotation += (float)D3DX_PI * 0.0025f; if(rotation > 360.0f) { rotation -= 360.0f; } // Rotate the world matrix by the rotation value. D3DXMatrixRotationY(&worldMatrix, rotation); // Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing. m_Model->Render(m_D3D->GetDeviceContext()); Render the model using the bump map shader. // Render the model using the bump map shader. m_BumpMapShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTextureArray(), m_Light->GetDirection(), m_Light->GetDiffuseColor()); // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
With the bump map shader you can create very detailed scenes that look 3D with just two 2D textures.

35 of 37

3/8/2013 12:39 PM

Tutorial 20: Bump Mapping

http://www.rastertek.com/dx11tut20.html

To Do Exercises
1. Recompile and run the program. You should see a bump mapped rotating cube. Press escape to quit. 2. Change the bump map effect from 2.5 to something smaller (like 1.0) and larger (like 5.0) in the shader to see the change in the bump depth. 3. Comment out the color = color * textureColor; line in the pixel shader to see just the bump lighting effect. 4. Move the camera and light position around to see the effect from different angles.

http://www.rastertek.com/dx11tut25.html

Translate.vs
The vertex shader is the same as the texture vertex shader. //////////////////////////////////////////////////////////////////////////////// // Filename: translate.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; };

2 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType TranslateVertexShader(VertexInputType input) { PixelInputType output;

Translate.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: translate.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType;

3 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

We add a new buffer with a float variable called textureTranslation. This is set in the graphicsclass.cpp during the Render call to update the position of the texture translation. The value set here will be between 0 and 1. cbuffer TranslationBuffer { float textureTranslation; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; }; The pixel shader is where we do the work of translating the texture coordinate by the textureTranslation amount. We take the input texture coordinate and add the translation amount for each pixel shader call. This will uniformly translate the texture across the polygon face. //////////////////////////////////////////////////////////////////////////////// // Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 TranslatePixelShader(PixelInputType input) : SV_TARGET { // Translate the position where we sample the pixel from. input.tex.x += textureTranslation; return shaderTexture.Sample(SampleType, input.tex); }

Translateshaderclass.h
The TranslateShaderClass is just the TextureShaderClass with extra functionality for texture translation. //////////////////////////////////////////////////////////////////////////////// // Filename: translateshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TRANSLATESHADERCLASS_H_ #define _TRANSLATESHADERCLASS_H_

4 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: TranslateShaderClass //////////////////////////////////////////////////////////////////////////////// class TranslateShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; This is the new structure type for the texture translation buffer. We had padding to ensure it is a multiple of 16. struct TranslateBufferType { float translation; D3DXVECTOR3 padding; }; public: TranslateShaderClass(); TranslateShaderClass(const TranslateShaderClass&); ~TranslateShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, float); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } Load the texture translate pixel shader. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "TranslatePixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the vertex shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader.

9 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the dynamic constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result))

10 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

{ return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } Create the translate buffer so we have an interface to setting the texture translation value in the pixel shader. // Setup the description of the texture translation dynamic constant buffer that is in the pixel shader. translateBufferDesc.Usage = D3D11_USAGE_DYNAMIC; translateBufferDesc.ByteWidth = sizeof(TranslateBufferType); translateBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; translateBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; translateBufferDesc.MiscFlags = 0; translateBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class. result = device->CreateBuffer(&translateBufferDesc, NULL, &m_translateBuffer); if(FAILED(result)) { return false; } return true; }

11 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

void TranslateShaderClass::ShutdownShader() { Release the new translate buffer in the ShutdownShader function. // Release the texture translation constant buffer. if(m_translateBuffer) { m_translateBuffer->Release(); m_translateBuffer = 0; } // Release the sampler state. if(m_sampleState) { m_sampleState->Release(); m_sampleState = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) {

12 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

m_vertexShader->Release(); m_vertexShader = 0; } return; }

bool Frame(); bool Render(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; Create a new object for the new TranslateShaderClass. TranslateShaderClass* m_TranslateShader; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; Set the TranslateShaderClass object to null in the class constructor. m_TranslateShader = 0; }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

17 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; } // Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR); if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK); return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), L"../Engine/data/seafloor.dds", "../Engine/data/triangle.txt"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } Create and initialize the TranslateShaderClass object. // Create the texture translation shader object. m_TranslateShader = new TranslateShaderClass; if(!m_TranslateShader) { return false; }

18 of 22

3/8/2013 12:39 PM

Tutorial 25: Texture Translation

http://www.rastertek.com/dx11tut25.html

// Initialize the texture translation shader object. result = m_TranslateShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the texture translation shader object.", L"Error", MB_OK); return false; } return true; }

http://www.rastertek.com/dx11tut25.html

Source Only: dx11src25.zip Executable Only: dx11exe25.zip

3 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

//////////////////////////////////////////////////////////////////////////////// // Filename: transparent.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType TransparentVertexShader(VertexInputType input) { PixelInputType output;

4 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

output.position = mul(output.position, viewMatrix); output.position = mul(output.position, projectionMatrix); // Store the texture coordinates for the pixel shader. output.tex = input.tex; return output; }

Transparent.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: transparent.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType; We add a new constant buffer to hold the blendAmount variable. The blendAmount indicates was percentage to blend the texture. The acceptable value range is a float value from 0 to 1. In this tutorial it is set to 0.5 which means 50% transparency. cbuffer TransparentBuffer { float blendAmount; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

////////////////////////////////////////////////////////////////////////////////

5 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

// Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 TransparentPixelShader(PixelInputType input) : SV_TARGET { float4 color;

// Sample the texture pixel at this location. color = shaderTexture.Sample(SampleType, input.tex); Here we use the blendAmount variable to set the transparency of the texture. We set the alpha value of the pixel to the blend amount and when rendered it will use the alpha value with the blend state we setup to create the transparency effect. // Set the alpha value of this pixel to the blending amount to create the alpha blending effect. color.a = blendAmount; return color; }

Transparentshaderclass.h
The TransparentShaderClass is the same as the TextureShaderClass with some extra changes to accommodate transparency. //////////////////////////////////////////////////////////////////////////////// // Filename: transparentshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TRANSPARENTSHADERCLASS_H_ #define _TRANSPARENTSHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: TransparentShaderClass

6 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

//////////////////////////////////////////////////////////////////////////////// class TransparentShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; We have a new buffer type to match the constant buffer inside the pixel shader. We add 12 bytes of padding so the CreateBuffer function won't fail. struct TransparentBufferType { float blendAmount; D3DXVECTOR3 padding; }; public: TransparentShaderClass(); TransparentShaderClass(const TransparentShaderClass&); ~TransparentShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, float); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, float); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState; We have a new buffer variable to provide an interface to the blendAmount value inside the transparent HLSL pixel shader.

7 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

ID3D11Buffer* m_transparentBuffer; }; #endif

Transparentshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: transparentshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "transparentshaderclass.h"

TransparentShaderClass::TransparentShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; Initialize the new transparent constant buffer to null inside the class constructor. m_transparentBuffer = 0; }

TransparentShaderClass::TransparentShaderClass(const TransparentShaderClass& other) { }

TransparentShaderClass::~TransparentShaderClass() { }

bool TransparentShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; Load the transparent HLSL shader files.

8 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

// Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/transparent.vs", L"../Engine/transparent.ps"); if(!result) { return false; } return true; }

void TransparentShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; } The Render function now takes as input a blend float value which will set the amount of transparency to use in the shader. bool TransparentShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, float blend) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, blend); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; }

bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result;

9 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc; D3D11_SAMPLER_DESC samplerDesc; D3D11_BUFFER_DESC transparentBufferDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; Load the transparent vertex shader. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "TransparentVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } Load the transparent pixel shader. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "TransparentPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage)

10 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

{ OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the vertex shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0;

11 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

// Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the dynamic constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0;

12 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

void TransparentShaderClass::ShutdownShader() { Release the new transparent buffer in the ShutdownShader function. // Release the transparent constant buffer. if(m_transparentBuffer) { m_transparentBuffer->Release(); m_transparentBuffer = 0; } // Release the sampler state.

13 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

if(m_sampleState) { m_sampleState->Release(); m_sampleState = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) { m_vertexShader->Release(); m_vertexShader = 0; } return; }

void TransparentShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) { char* compileErrors; unsigned long bufferSize, i; ofstream fout;

14 of 25

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

bool TransparentShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, float blend) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber; TransparentBufferType* dataPtr2;

15 of 25

http://www.rastertek.com/dx11tut26.html

}; #endif

Graphicsclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "graphicsclass.h" Initialize the two models and the new TransparentShaderClass to null in the class constructor. GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model1 = 0; m_Model2 = 0; m_TextureShader = 0; m_TransparentShader = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

3/8/2013 12:41 PM

Tutorial 26: Transparency

http://www.rastertek.com/dx11tut26.html

To Do Exercises
1. Recompile the and run the program. Press escape to quit. 2. Change the value of the blendAmount in the GraphicsRender function to see different amounts of transparency.

Source Code
Visual Studio 2008 Project: dx11tut26.zip Source Only: dx11src26.zip Executable Only: dx11exe26.zip

Back to Tutorial Index

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

Now transform the input position into the projected reflection position. These transformed position coordinates will be used in the pixel shader to derive where to map our projected reflection texture to. // Calculate the input position against the reflectProjectWorld matrix. output.reflectionPosition = mul(input.position, reflectProjectWorld); return output; }

Reflection.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: reflection.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType; We add a new texture variable for the scene reflection render to texture. Texture2D reflectionTexture;

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float4 reflectionPosition : TEXCOORD1; };

//////////////////////////////////////////////////////////////////////////////// // Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 ReflectionPixelShader(PixelInputType input) : SV_TARGET

4 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

{ float4 textureColor; float2 reflectTexCoord; float4 reflectionColor; float4 color;

// Sample the texture pixel at this location. textureColor = shaderTexture.Sample(SampleType, input.tex); The input reflection position homogenous coordinates need to be converted to proper texture coordinates. To do so first divide by the W coordinate. This leaves us with tu and tv coordinates in the -1 to +1 range, to fix it to map to a 0 to +1 range just divide by 2 and add 0.5. // Calculate the projected reflection texture coordinates. reflectTexCoord.x = input.reflectionPosition.x / input.reflectionPosition.w / 2.0f + 0.5f; reflectTexCoord.y = -input.reflectionPosition.y / input.reflectionPosition.w / 2.0f + 0.5f; Now when we sample from the reflection texture we use the projected reflection coordinates that have been converted to get the right reflection pixel for this projected reflection position. // Sample the texture pixel from the reflection texture using the projected texture coordinates. reflectionColor = reflectionTexture.Sample(SampleType, reflectTexCoord); Finally we blend the texture from the floor with the reflection texture to create the effect of the reflected cube on the floor. Here we use a linear interpolation between the two textures with a factor of 0.15. You can change this to a different blend equation or change the factor amount for a different or stronger effect. // Do a linear interpolation between the two textures for a blend effect. color = lerp(textureColor, reflectionColor, 0.15f); return color; }

Reflectionshaderclass.h
The ReflectionShaderClass is the same as the TextureShaderClass except that it also handles a reflection view matrix buffer and a reflection texture. //////////////////////////////////////////////////////////////////////////////// // Filename: reflectionshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _REFLECTIONSHADERCLASS_H_ #define _REFLECTIONSHADERCLASS_H_

5 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: ReflectionShaderClass //////////////////////////////////////////////////////////////////////////////// class ReflectionShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; This is the structure for the reflection view matrix dynamic constant buffer. struct ReflectionBufferType { D3DXMATRIX reflectionMatrix; }; public: ReflectionShaderClass(); ReflectionShaderClass(const ReflectionShaderClass&); ~ReflectionShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, D3DXMATRIX); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);

6 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, D3DXMATRIX); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState; This is the new buffer for the reflection view matrix. ID3D11Buffer* m_reflectionBuffer; }; #endif

Reflectionshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: reflectionshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "reflectionshaderclass.h"

ReflectionShaderClass::ReflectionShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; Initialize the reflection constant buffer to null in the class constructor. m_reflectionBuffer = 0; }

ReflectionShaderClass::ReflectionShaderClass(const ReflectionShaderClass& other)

7 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

{ }

ReflectionShaderClass::~ReflectionShaderClass() { }

bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; Load the new reflection HLSL shader files. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/reflection.vs", L"../Engine/reflection.ps"); if(!result) { return false; } return true; }

void ReflectionShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; } The Render function now takes as input the new reflection texture and reflection matrix. These are then set in the shader before rendering. bool ReflectionShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, ID3D11ShaderResourceView* reflectionTexture, D3DXMATRIX reflectionMatrix) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, reflectionTexture,

8 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

reflectionMatrix); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; }

bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc; D3D11_SAMPLER_DESC samplerDesc; D3D11_BUFFER_DESC reflectionBufferDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; Load the new reflection vertex shader. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ReflectionVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else

9 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

{ MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } Load the new reflection pixel shader. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ReflectionPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the vertex shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description.

10 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

// This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the matrix dynamic constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);

11 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

if(FAILED(result)) { return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } Here we setup the new reflection matrix dynamic constant buffer. // Setup the description of the reflection dynamic constant buffer that is in the vertex shader. reflectionBufferDesc.Usage = D3D11_USAGE_DYNAMIC; reflectionBufferDesc.ByteWidth = sizeof(ReflectionBufferType); reflectionBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; reflectionBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; reflectionBufferDesc.MiscFlags = 0; reflectionBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&reflectionBufferDesc, NULL, &m_reflectionBuffer); if(FAILED(result)) { return false; } return true;

12 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

Cameraclass.h
The CameraClass has been slightly modified to handle planar reflections. //////////////////////////////////////////////////////////////////////////////// // Filename: cameraclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _CAMERACLASS_H_ #define _CAMERACLASS_H_

////////////// // INCLUDES // ////////////// #include <d3dx10math.h>

17 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

We add two new functions for reflection. One is to build the reflection matrix and the other is to retrieve the reflection matrix. void RenderReflection(float); D3DXMATRIX GetReflectionViewMatrix(); private: D3DXMATRIX m_viewMatrix; float m_positionX, m_positionY, m_positionZ; float m_rotationX, m_rotationY, m_rotationZ; Here is the new reflection matrix. D3DXMATRIX m_reflectionViewMatrix; }; #endif

Cameraclass.cpp
I will just cover the new functions since the older CameraClass functions have not changed. //////////////////////////////////////////////////////////////////////////////// // Filename: cameraclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "cameraclass.h" The new RenderReflection function builds a reflection view matrix the same way as the regular Render function builds a view matrix. The only difference is that we take as input the height of the object that will act as the Y axis plane and then we use that height to invert the position.y variable for reflection. This will build the reflection view matrix that we can then use in the shader. Note that this function only works for the Y axis plane. void CameraClass::RenderReflection(float height) { D3DXVECTOR3 up, position, lookAt; float radians;

// Setup the vector that points upwards. up.x = 0.0f; up.y = 1.0f; up.z = 0.0f; // Setup the position of the camera in the world.

18 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

// For planar reflection invert the Y position of the camera. position.x = m_positionX; position.y = -m_positionY + (height * 2.0f); position.z = m_positionZ; // Calculate the rotation in radians. radians = m_rotationY * 0.0174532925f; // Setup where the camera is looking. lookAt.x = sinf(radians) + m_positionX; lookAt.y = position.y; lookAt.z = cosf(radians) + m_positionZ; // Create the view matrix from the three vectors. D3DXMatrixLookAtLH(&m_reflectionViewMatrix, &position, &lookAt, &up); return; } GetReflectionViewMatrix returns the reflection view matrix to calling functions. D3DXMATRIX CameraClass::GetReflectionViewMatrix() { return m_reflectionViewMatrix; }

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

19 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "textureshaderclass.h" #include "rendertextureclass.h" We include the new ReflectionShaderClass header file. #include "reflectionshaderclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); bool Render(); private: bool RenderToTexture(); bool RenderScene(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; TextureShaderClass* m_TextureShader; We will be using a render to texture object in this tutorial. RenderTextureClass* m_RenderTexture;

20 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

We will create a second model object for the floor. ModelClass* m_FloorModel; Create the new reflection shader object. ReflectionShaderClass* m_ReflectionShader; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; m_TextureShader = 0; Initialize the render to texture, floor model, and reflection shader objects to null in the class constructor. m_RenderTexture = 0; m_FloorModel = 0; m_ReflectionShader = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

21 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

// Create the Direct3D object. m_D3D = new D3DClass; if(!m_D3D) { return false; } // Initialize the Direct3D object. result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR); if(!result) { MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK); return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), L"../Engine/data/seafloor.dds", "../Engine/data/cube.txt"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } // Create the texture shader object.

22 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

m_TextureShader = new TextureShaderClass; if(!m_TextureShader) { return false; } // Initialize the texture shader object. result = m_TextureShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK); return false; } Create and initialize the render to texture object. // Create the render to texture object. m_RenderTexture = new RenderTextureClass; if(!m_RenderTexture) { return false; } // Initialize the render to texture object. result = m_RenderTexture->Initialize(m_D3D->GetDevice(), screenWidth, screenHeight); if(!result) { return false; } Create and initialize the blue floor model object. // Create the floor model object. m_FloorModel = new ModelClass; if(!m_FloorModel) { return false; } // Initialize the floor model object. result = m_FloorModel->Initialize(m_D3D->GetDevice(), L"../Engine/data/blue01.dds", "../Engine/data/floor.txt"); if(!result) { MessageBox(hwnd, L"Could not initialize the floor model object.", L"Error", MB_OK); return false;

23 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

} Create and initialize the new reflection shader object. // Create the reflection shader object. m_ReflectionShader = new ReflectionShaderClass; if(!m_ReflectionShader) { return false; } // Initialize the reflection shader object. result = m_ReflectionShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the reflection shader object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { Release the render to texture, floor model, and reflection shader objects in the Shutdown function. // Release the reflection shader object. if(m_ReflectionShader) { m_ReflectionShader->Shutdown(); delete m_ReflectionShader; m_ReflectionShader = 0; } // Release the floor model object. if(m_FloorModel) { m_FloorModel->Shutdown(); delete m_FloorModel; m_FloorModel = 0; } // Release the render to texture object.

24 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

http://www.rastertek.com/dx11tut27.html

reflectionMatrix); // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
We now have a planar reflection effect that can be used to mirror objects and blend them as reflections into other objects.

To Do Exercises

29 of 30

3/8/2013 12:41 PM

Tutorial 27: Reflection

http://www.rastertek.com/dx11tut27.html

1. Recompile and run the program. You should get a spinning cube that is reflected by the blue floor object. 2. Change the blending factor and try a different blending equation to produce a different effect. 3. Change the planar reflection to the Z plane and move/rotate the floor object to create a upright mirror effect.

Source Code
Visual Studio 2008 Project: dx11tut27.zip Source Only: dx11src27.zip Executable Only: dx11exe27.zip

Back to Tutorial Index

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

Fade.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: fade.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType; We add a new buffer called FadeBuffer to control the color level of the texture by using the fadeAmount variable. This value will be incremented each frame to make the image brighter and brighter creating the fade in effect. The value range is between 0.0 (0%) and 1.0 (100%). The padding variable is just to ensure the buffer is a multiple of 16. cbuffer FadeBuffer { float fadeAmount; float3 padding; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0;

3 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

};

// Sample the texture pixel at this location. color = shaderTexture.Sample(SampleType, input.tex); Here is where we use the fadeAmount to control the output color of all pixels from the texture to be set to a certain brightness. // Reduce the color brightness to the current fade percentage. color = color * fadeAmount; return color; }

Fadeshaderclass.h
The FadeShaderClass is just the TextureShaderClass modified to accommodate texture fading. //////////////////////////////////////////////////////////////////////////////// // Filename: fadeshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _FADESHADERCLASS_H_ #define _FADESHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

4 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

//////////////////////////////////////////////////////////////////////////////// // Class name: FadeShaderClass //////////////////////////////////////////////////////////////////////////////// class FadeShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; This is the new structure to match the fade constant buffer in the pixel shader. struct FadeBufferType { float fadeAmount; D3DXVECTOR3 padding; }; public: FadeShaderClass(); FadeShaderClass(const FadeShaderClass&); ~FadeShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, float); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, float); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState;

5 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

This is the new fade amount buffer that is used to control the brightness of all the pixels from the texture. ID3D11Buffer* m_fadeBuffer; }; #endif

Fadeshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: fadeshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "fadeshaderclass.h"

FadeShaderClass::FadeShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; Initialize the new buffer to null in the class constructor. m_fadeBuffer = 0; }

FadeShaderClass::FadeShaderClass(const FadeShaderClass& other) { }

FadeShaderClass::~FadeShaderClass() { }

bool FadeShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result;

6 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

Load in the new fade.vs and fade.ps HLSL shader code. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/fade.vs", L"../Engine/fade.ps"); if(!result) { return false; } return true; }

void FadeShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; } The Render function now takes in a new float variable called fadeAmount. This variable contains the current percentage of brightness the texture should be drawn at. It will be set in the shader first before rendering the texture. bool FadeShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, float fadeAmount) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, fadeAmount); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; }

bool FadeShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)

7 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

{ HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc; D3D11_SAMPLER_DESC samplerDesc; D3D11_BUFFER_DESC fadeBufferDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; Load the new fade vertex shader. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "FadeVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } Load the new fade pixel shader. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "FadePixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) {

8 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

// If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the vertex shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;

9 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the matrix dynamic constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0;

10 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } Setup a buffer that will hold the fadeAmount variable so we can interface with the pixel shader fade buffer. // Setup the description of the fade dynamic constant buffer that is in the vertex shader. fadeBufferDesc.Usage = D3D11_USAGE_DYNAMIC; fadeBufferDesc.ByteWidth = sizeof(FadeBufferType); fadeBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; fadeBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; fadeBufferDesc.MiscFlags = 0; fadeBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class. result = device->CreateBuffer(&fadeBufferDesc, NULL, &m_fadeBuffer); if(FAILED(result)) { return false; } return true; }

void FadeShaderClass::ShutdownShader() { Release the new fade buffer in the ShutdownShader function. // Release the fade constant buffer. if(m_fadeBuffer) { m_fadeBuffer->Release(); m_fadeBuffer = 0; }

11 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

void FadeShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) { char* compileErrors; unsigned long bufferSize, i; ofstream fout;

12 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

bool FadeShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, float fadeAmount) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber; FadeBufferType* dataPtr2;

13 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

// Lock the matrix constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the matrix constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the matrix constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the matrix constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the matrix constant buffer in the vertex shader. bufferNumber = 0; // Now set the matrix constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); This is where we set the fadeAmount value inside the pixel shader. We first lock the fade buffer and then copy the updated fadeAmount value into it. After that we unlock the fade buffer and then set it in the pixel shader using the PSSetConstantBuffers function. // Lock the fade constant buffer so it can be written to. result = deviceContext->Map(m_fadeBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the fade constant buffer. dataPtr2 = (FadeBufferType*)mappedResource.pData; // Copy the fade amount into the fade constant buffer. dataPtr2->fadeAmount = fadeAmount; dataPtr2->padding = D3DXVECTOR3(0.0f, 0.0f, 0.0f);

14 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

// Unlock the fade constant buffer. deviceContext->Unmap(m_fadeBuffer, 0); // Set the position of the fade constant buffer in the pixel shader. bufferNumber = 0; // Now set the fade constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_fadeBuffer); return true; }

void FadeShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0); deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Set the sampler state in the pixel shader. deviceContext->PSSetSamplers(0, 1, &m_sampleState); // Render the triangle. deviceContext->DrawIndexed(indexCount, 0, 0); return; }

Bitmapclass.h
The BitmapClass is the exact same as before except that it has been modified to not have any texture information. The FadeShaderClass will be supplied with a texture from the RenderTextureClass object instead of using the BitmapClass to supply the texture. However since we want to treat the render to texture like a bitmap and draw it 2D on the screen we use this modified BitmapClass to build the buffers and render the geometry before calling the fade shader. //////////////////////////////////////////////////////////////////////////////// // Filename: bitmapclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _BITMAPCLASS_H_ #define _BITMAPCLASS_H_

15 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: BitmapClass //////////////////////////////////////////////////////////////////////////////// class BitmapClass { private: struct VertexType { D3DXVECTOR3 position; D3DXVECTOR2 texture; }; public: BitmapClass(); BitmapClass(const BitmapClass&); ~BitmapClass(); bool Initialize(ID3D11Device*, int, int, int, int); void Shutdown(); bool Render(ID3D11DeviceContext*, int, int); int GetIndexCount(); private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); bool UpdateBuffers(ID3D11DeviceContext*, int, int); void RenderBuffers(ID3D11DeviceContext*); bool LoadTexture(ID3D11Device*, WCHAR*); void ReleaseTexture(); private: ID3D11Buffer *m_vertexBuffer, *m_indexBuffer; int m_vertexCount, m_indexCount; int m_screenWidth, m_screenHeight;

16 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

int m_bitmapWidth, m_bitmapHeight; int m_previousPosX, m_previousPosY; }; #endif

BitmapClass::BitmapClass() { m_vertexBuffer = 0; m_indexBuffer = 0; }

BitmapClass::BitmapClass(const BitmapClass& other) { }

BitmapClass::~BitmapClass() { }

bool BitmapClass::Initialize(ID3D11Device* device, int screenWidth, int screenHeight, int bitmapWidth, int bitmapHeight) { bool result;

// Store the screen size. m_screenWidth = screenWidth; m_screenHeight = screenHeight; // Store the size in pixels that this bitmap should be rendered at. m_bitmapWidth = bitmapWidth;

17 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

m_bitmapHeight = bitmapHeight; // Initialize the previous rendering position to -1. m_previousPosX = -1; m_previousPosY = -1; // Initialize the vertex and index buffers. result = InitializeBuffers(device); if(!result) { return false; } return true; }

void BitmapClass::Shutdown() { // Shutdown the vertex and index buffers. ShutdownBuffers(); return; }

bool BitmapClass::Render(ID3D11DeviceContext* deviceContext, int positionX, int positionY) { bool result;

18 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

int BitmapClass::GetIndexCount() { return m_indexCount; }

bool BitmapClass::InitializeBuffers(ID3D11Device* device) { VertexType* vertices; unsigned long* indices; D3D11_BUFFER_DESC vertexBufferDesc, indexBufferDesc; D3D11_SUBRESOURCE_DATA vertexData, indexData; HRESULT result; int i;

19 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

// Set up the description of the static vertex buffer. vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC; vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the vertex data. vertexData.pSysMem = vertices; vertexData.SysMemPitch = 0; vertexData.SysMemSlicePitch = 0; // Now create the vertex buffer. result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); if(FAILED(result)) { return false; } // Set up the description of the static index buffer. indexBufferDesc.Usage = D3D11_USAGE_DEFAULT; indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the index data. indexData.pSysMem = indices; indexData.SysMemPitch = 0; indexData.SysMemSlicePitch = 0; // Create the index buffer. result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); if(FAILED(result)) { return false; } // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices;

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "textureshaderclass.h" #include "rendertextureclass.h" #include "bitmapclass.h" We include the new FadeShaderClass header file here. #include "fadeshaderclass.h"

24 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

void Shutdown(); bool Frame(float); bool Render(); private: bool RenderToTexture(float); bool RenderFadingScene(); bool RenderNormalScene(float); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; TextureShaderClass* m_TextureShader; RenderTextureClass* m_RenderTexture; BitmapClass* m_Bitmap; We have new variables to maintain information about the fade in effect. float m_fadeInTime, m_accumulatedTime, m_fadePercentage; bool m_fadeDone; We create a new FadeShaderClass object here. FadeShaderClass* m_FadeShader; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0;

25 of 36

http://www.rastertek.com/dx11tut28.html

if(!result) { MessageBox(hwnd, L"Could not initialize the fade shader object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { Release the new FadeShaderClass object in the Shutdown function. // Release the fade shader object. if(m_FadeShader) { m_FadeShader->Shutdown(); delete m_FadeShader; m_FadeShader = 0; } // Release the bitmap object. if(m_Bitmap) { m_Bitmap->Shutdown(); delete m_Bitmap; m_Bitmap = 0; } // Release the render to texture object. if(m_RenderTexture) { m_RenderTexture->Shutdown(); delete m_RenderTexture; m_RenderTexture = 0; } // Release the texture shader object. if(m_TextureShader) { m_TextureShader->Shutdown(); delete m_TextureShader; m_TextureShader = 0;

29 of 36

3/8/2013 12:42 PM

http://www.rastertek.com/dx11tut28.html

// Reset the render target back to the original back buffer and not the render to texture anymore. m_D3D->SetBackBufferRenderTarget(); return true; } The RenderFadingScene function uses the render to texture of the 3D rotating cube scene and draws it as a 2D bitmap to the screen using the FadeShaderClass object. The FadeShaderClass object takes in the m_fadePercentage value to determine what percentage of brightness the texture should be at this frame which creates the fade in effect. bool GraphicsClass::RenderFadingScene() { D3DXMATRIX worldMatrix, viewMatrix, orthoMatrix; bool result;

33 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

// Turn the Z buffer back on now that all 2D rendering has completed. m_D3D->TurnZBufferOn(); // Present the rendered scene to the screen. m_D3D->EndScene(); return true; } If we are no longer fading in the scene then we switch to using this function to draw the scene normally and remove the cost of using render to texture. bool GraphicsClass::RenderNormalScene(float rotation) { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix; bool result;

34 of 36

3/8/2013 12:42 PM

Tutorial 28: Screen Fades

http://www.rastertek.com/dx11tut28.html

return true; }

Summary
Using render to texture we can now fade in and fade out our 3D scenes. This effect can be extended to render the new and old scene at the same time to create more interesting transition effects.

To Do Exercises
1. Recompile and run the program. The cube show slowly fade in over a 5 second period and then start rendering normally. Press escape to quit. 2. Change the speed at which the scene fades in. 3. Change the color the back buffer is cleared to in the render to texture so you can see the exact moment the application switches to rendering normally. 4. Change the code to fade the scene out after fading it in.

http://www.rastertek.com/dx11tut32.html

rendering the scene to texture and then projecting it onto the glass model produces the following refraction result:

If the scene were more complex your window would actually become invisible and everything would look the same. The reason being is that if the texture is perfectly projected it would just cover the same 3D scene section with a 2D texture of the same scene making the resulting glass model a perfectly clear see through glass with no way to differentiate it from the 3D scene itself. To even determine what is your glass model and what is the scene you will need to dim or brighten the glass texture to see that it actually is still there for debugging purposes. Now that the scene is projected onto a texture you need a normal map so you can eventually perturb the refraction texture to make it look like it is behind glass. We will use the following normal map which will give a stripped faceted look to the glass:

Now that we have a normal map we can use each individual pixel in the normal map as a look up for how to modify what pixel in the refraction texture is sampled.

2 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

This allows us to sample the refraction texture slightly above, beside, and below to simulate light not traveling straight through but instead being bent slightly such as it is in glass. The scale of light being bent is controlled by the refractionScale variable which we set fairly low for glass, in this example it was set to 0.01. Note that this is entirely dependent on the normal map used as the normals can vary little or greatly in the normal map which prevents us from really having a scale value that will always work. So now if we sample the refraction texture using the normal map texture as a lookup with the scale being 0.01 we get the following image:

The basic effect is mostly complete now. However most glass has a tint or color associated with it and sometimes other markings. For the glass in this example we will use the following color texture:

We take the color texture and the perturbed refraction and combine them to get the final glass effect:

3 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

Ice
Ice works exactly the same as glass with just different inputs into the shader. To start with we have the same scene of the textured square projected onto the ice surface model:

However with ice we want a different look to the final surface so we will use a different color texture:

4 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

Also the normal map will need to be different to simulate all the tiny bumps all over the surface with ice. Fortunately the color texture has just the right amount of noise in it to be used to make a ice normal map. Simply take the color texture above and use the Nivida normal map filter in Photoshop with a Scale of 5 and it creates the following normal map:

Now if we use that normal map and a stronger refractionScale such as 0.1 for ice (instead of how we used 0.01 for glass) we get the following heavily perturbed refraction image:

5 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

Finally if we combine the perturbed refraction texture with the ice color texture the resulting image is very realistic:

One final comment before we get into the code is that when you see these shaders working on surfaces that have motion behind them (such as a spinning cube behind the glass or ice) they look incredibly real. Make sure you at least run the executable for this tutorial to see what I'm talking about.

Framework
The frame work for this tutorial is similar to the previous tutorials. The only new class added is the GlassShaderClass which handles the glass and ice shading. The

http://www.rastertek.com/dx11tut32.html

struct GlassBufferType { float refractionScale; D3DXVECTOR3 padding; };

public: GlassShaderClass(); GlassShaderClass(const GlassShaderClass&); ~GlassShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11SamplerState* m_sampleState; ID3D11Buffer* m_matrixBuffer; The glass shader needs a refraction scale value which the m_glassBuffer pointer provides an interface to. ID3D11Buffer* m_glassBuffer; }; #endif

Glassshaderclass.cpp

12 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

if(FAILED(result)) { return false; } Setup the description and create the glass buffer which will be used to set the refraction scale in the pixel shader. // Setup the description of the glass dynamic constant buffer that is in the pixel shader. glassBufferDesc.Usage = D3D11_USAGE_DYNAMIC; glassBufferDesc.ByteWidth = sizeof(GlassBufferType); glassBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; glassBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; glassBufferDesc.MiscFlags = 0; glassBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class. result = device->CreateBuffer(&glassBufferDesc, NULL, &m_glassBuffer); if(FAILED(result)) { return false; } return true; }

void GlassShaderClass::ShutdownShader() { Release the new glass buffer in the ShutdownShader function. // Release the glass constant buffer. if(m_glassBuffer) { m_glassBuffer->Release(); m_glassBuffer = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; }

18 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

// Release the sampler state. if(m_sampleState) { m_sampleState->Release(); m_sampleState = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) { m_vertexShader->Release(); m_vertexShader = 0; } return; }

void GlassShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) { char* compileErrors; unsigned long bufferSize, i; ofstream fout;

// Get a pointer to the error message text buffer. compileErrors = (char*)(errorMessage->GetBufferPointer()); // Get the length of the message. bufferSize = errorMessage->GetBufferSize();

19 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

// Open a file to write the error message to. fout.open("shader-error.txt"); // Write out the error message. for(i=0; i<bufferSize; i++) { fout << compileErrors[i]; } // Close the file. fout.close(); // Release the error message. errorMessage->Release(); errorMessage = 0; // Pop a message up on the screen to notify the user to check the text file for compile errors. MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK); return; }

bool GlassShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* colorTexture, ID3D11ShaderResourceView* normalTexture, ID3D11ShaderResourceView* refractionTexture, float refractionScale) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; GlassBufferType* dataPtr2; unsigned int bufferNumber;

20 of 34

http://www.rastertek.com/dx11tut32.html

We need a render to texture object to render the spinning cube part of the scene. RenderTextureClass* m_RenderTexture; The texture shader is used to render the normal scene. The glass shader is used to render the glass window model. TextureShaderClass* m_TextureShader; GlassShaderClass* m_GlassShader; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0; m_WindowModel = 0; m_RenderTexture = 0; m_TextureShader = 0; The new GlassShaderClass object is initialized to null in the class constructor. m_GlassShader = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

http://www.rastertek.com/dx11tut32.html

m_WindowModel->GetTexture(), m_WindowModel->GetNormalMap(), m_RenderTexture->GetShaderResourceView(), refractionScale); if(!result) { return false; } // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
We can now render both glass and ice effects through the use of refraction and a normal map for perturbation.

32 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

33 of 34

3/8/2013 12:43 PM

Tutorial 32: Glass and Ice

http://www.rastertek.com/dx11tut32.html

To Do Exercises
1. Recompile and run the program. You should get a spinning cube behind green perturbed glass. Press escape to quit. 2. To see the ice effect change the following function in GraphicsClass::Initialize from: result = m_WindowModel->Initialize(m_D3D->GetDevice(), "../Engine/data/square.txt", L"../Engine/data/glass01.dds", L"../Engine/data/bump03.dds"); To: result = m_WindowModel->Initialize(m_D3D->GetDevice(), "../Engine/data/square.txt", L"../Engine/data/ice01.dds", L"../Engine/data/icebump01.dds"); And change the refractionScale to 0.1f and move the camera closer: m_Camera->SetPosition(0.0f, 0.0f, -5.0f); refractionScale = 0.1f; Now recompile and run the program with those three changes to see the ice effect. 3. Change the value of the refractionScale to see how it affects the perturbation. 4. Modify the combination of the color texture and the perturbed refraction texture in the pixel shader to get different output results. 5. Make your own glass color texture and normal map and get your own personal glass shader effect to work (also modify the refractionScale so it looks right for your normal map).

Source Code
Visual Studio 2008 Project: dx11tut32.zip Source Only: dx11src32.zip Executable Only: dx11exe32.zip

Back to Tutorial Index

The next step is to convert the three noise textures from the (0, 1) range into the (-1, +1) range. This has the effect of removing some of the noise and creating noise that looks closer to fire. For example the first noise texture now looks like the following:

With all three noise textures in the (-1, +1) range we can now add distortion to each texture along the x and y coordinates. The distortion modifies the noise textures by scaling down the noise similar to how the refraction scale in the water, glass, and ice shaders did so. Once each noise texture is distorted we can then combine all three noise textures to produce a final noise texture. Note that the distortion here is only applied to the x and y coordinates since we will be using them as a look up table for the x and y texture sampling just like we do with normal maps. The z coordinate is ignored as it has no use when sampling textures in 2D. Remember also that each frame the three noise textures are scrolling upwards at different rates so combining them creates an almost organized flowing noise that looks like fire. Now the next very important step is to perturb the original fire color texture. In other shaders such as water, glass, and ice we usually use a normal map at this point to perturb the texture sampling coordinates. However in fire we use the noise as our perturbed texture sampling coordinates. But before we do that we want to also perturb the noise itself. We will use a distortion scale and bias to distort the noise higher at the top of the texture and less at the bottom of the texture to create a solid flame at the base and flame licks at the top. In other words we perturb the noise along the Y axis using an increased amount of distortion as we go up the noise texture from the bottom. We now use the perturbed final noise texture as our look up table for texture sampling coordinates that will be used to sample the fire color texture. Note that we use Clamp instead of Wrap for the fire color texture or we will get flame licks wrapping around to the bottom which would ruin the look. The fire color texture sampled using the perturbed noise now looks like the following:

Now that we have an animated burning square that looks fairly realistic we need a way of shaping it into more of a flame. To do so we turn on blending and use the alpha texture we created earlier. The trick is to sample the alpha texture using the same perturbed noise to make the alpha look like a burning flame. We also need to use Clamp instead of Wrap for sampling to prevent the flames from wrapping around to the bottom. When we do so we get the following result from the sampled perturbed alpha:

3 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

To complete the effect we set the perturbed alpha value to be the alpha channel of the perturbed fire color texture and the blending takes care of the rest:

When you see this animated it looks very realistic.

Framework
The frame work has one new class called FireShaderClass which is just the TextureShaderClass updated for the fire effect.

4 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

We will start the code section by examining the HLSL fire shader.

Fire.vs
//////////////////////////////////////////////////////////////////////////////// // Filename: fire.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; }; For the vertex shader we create a new constant buffer that will contain the values needed for calculations each frame. The first variable called frameTime is updated each frame so the shader has access to an incremental time that is used for scrolling the different noise textures. The second variable scrollSpeeds is a 3 float array that contains three different scrolling speeds. The x value is the scroll speed for the first noise texture. The y value is the scroll speed for the second noise texture. And the z value is the scroll speed for the third noise texture. The third variable scales is a 3 float array that contains three different scales (or octaves) for the three different noise textures. The x, y, and z values of scales is generally set to 1, 2, and 3. This will make the first noise texture a single tile. It also makes the second noise texture tiled twice in both directions. And finally it makes the third noise texture tiled three times in both directions. The last variable is called padding. It is a single float that is used to make the NoiseBuffer a size that is divisible by 16. Padding will generally just be set to 0.0f. cbuffer NoiseBuffer { float frameTime; float3 scrollSpeeds; float3 scales; float padding; };

////////////// // TYPEDEFS // //////////////

5 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; }; The PixelInputType structure has been changed to take three different texture coordinates. We use it for sampling the same noise texture in three different ways to basically create three different noise textures from one. struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float2 texCoords1 : TEXCOORD1; float2 texCoords2 : TEXCOORD2; float2 texCoords3 : TEXCOORD3; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType FireVertexShader(VertexInputType input) { PixelInputType output;

// Change the position vector to be 4 units for proper matrix calculations. input.position.w = 1.0f; // Calculate the position of the vertex against the world, view, and projection matrices. output.position = mul(input.position, worldMatrix); output.position = mul(output.position, viewMatrix); output.position = mul(output.position, projectionMatrix); // Store the texture coordinates for the pixel shader. output.tex = input.tex; Here is where we create three different texture sampling values so that the same noise texture can be used to create three different noise textures. For each texture coordinate we first scale it by the scale value which then tiles the texture a number of times depending on the value in the scales array. After that we scroll the three different y coordinates upwards using the frame time and the value in the scrollSpeeds array. The scroll speed for all three will be different which gives the fire dimension. // Compute texture coordinates for first noise texture using the first scale and upward scrolling speed values. output.texCoords1 = (input.tex * scales.x);

6 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

output.texCoords1.y = output.texCoords1.y + (frameTime * scrollSpeeds.x); // Compute texture coordinates for second noise texture using the second scale and upward scrolling speed values. output.texCoords2 = (input.tex * scales.y); output.texCoords2.y = output.texCoords2.y + (frameTime * scrollSpeeds.y); // Compute texture coordinates for third noise texture using the third scale and upward scrolling speed values. output.texCoords3 = (input.tex * scales.z); output.texCoords3.y = output.texCoords3.y + (frameTime * scrollSpeeds.z); return output; }

Fire.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: fire.ps ////////////////////////////////////////////////////////////////////////////////

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: FireShaderClass //////////////////////////////////////////////////////////////////////////////// class FireShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; The vertex shader has a constant buffer with variables for calculating noise so we need to create a structure that mirrors it so that we can set those values. This structure contains the frame speed, the three different scroll speeds, and the three different noise scales. The structure also has a padding variable that is used to make the structure a multiple of 16 which is a requirement for when the noise buffer is created. struct NoiseBufferType { float frameTime; D3DXVECTOR3 scrollSpeeds; D3DXVECTOR3 scales; float padding; }; The pixel shader also has a constant buffer with variables used for distorting the noise values to create the fire effect. This new structure is used in conjunction with

10 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

a buffer to set the values in the pixel shader. The structure contains the three distortion arrays and the distortion scale and bias. struct DistortionBufferType { D3DXVECTOR2 distortion1; D3DXVECTOR2 distortion2; D3DXVECTOR2 distortion3; float distortionScale; float distortionBias; }; public: FireShaderClass(); FireShaderClass(const FireShaderClass&); ~FireShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float, D3DXVECTOR3, D3DXVECTOR3, D3DXVECTOR2, D3DXVECTOR2, D3DXVECTOR2, float, float); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float, D3DXVECTOR3, D3DXVECTOR3, D3DXVECTOR2, D3DXVECTOR2, D3DXVECTOR2, float, float); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; We have a new buffer for the noise constant buffer in the vertex shader. ID3D11Buffer* m_noiseBuffer; ID3D11SamplerState* m_sampleState; There is a new sampler state which will use Clamp instead of Wrap for the fire effect. ID3D11SamplerState* m_sampleState2;

11 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

Also there is a new distortion buffer for the distortion constant buffer in the pixel shader. ID3D11Buffer* m_distortionBuffer; }; #endif

Fireshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: fireshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "fireshaderclass.h" All the private pointers in the class are initialized to null in the class constructor. FireShaderClass::FireShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_noiseBuffer = 0; m_sampleState = 0; m_sampleState2 = 0; m_distortionBuffer = 0; }

FireShaderClass::FireShaderClass(const FireShaderClass& other) { }

15 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the dynamic matrix constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the matrix buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } Setup and create the new noise buffer.

16 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

// Setup the description of the dynamic noise constant buffer that is in the vertex shader. noiseBufferDesc.Usage = D3D11_USAGE_DYNAMIC; noiseBufferDesc.ByteWidth = sizeof(NoiseBufferType); noiseBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; noiseBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; noiseBufferDesc.MiscFlags = 0; noiseBufferDesc.StructureByteStride = 0; // Create the noise buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&noiseBufferDesc, NULL, &m_noiseBuffer); if(FAILED(result)) { return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } Setup and create the new sampler state that uses CLAMP instead of WRAP. // Create a second texture sampler state description for a Clamp sampler. samplerDesc2.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc2.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; samplerDesc2.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; samplerDesc2.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; samplerDesc2.MipLODBias = 0.0f;

17 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

samplerDesc2.MaxAnisotropy = 1; samplerDesc2.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc2.BorderColor[0] = 0; samplerDesc2.BorderColor[1] = 0; samplerDesc2.BorderColor[2] = 0; samplerDesc2.BorderColor[3] = 0; samplerDesc2.MinLOD = 0; samplerDesc2.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc2, &m_sampleState2); if(FAILED(result)) { return false; } Setup and create the new distortion buffer. // Setup the description of the dynamic distortion constant buffer that is in the pixel shader. distortionBufferDesc.Usage = D3D11_USAGE_DYNAMIC; distortionBufferDesc.ByteWidth = sizeof(DistortionBufferType); distortionBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; distortionBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; distortionBufferDesc.MiscFlags = 0; distortionBufferDesc.StructureByteStride = 0; // Create the distortion buffer pointer so we can access the pixel shader constant buffer from within this class. result = device->CreateBuffer(&distortionBufferDesc, NULL, &m_distortionBuffer); if(FAILED(result)) { return false; } return true; }

void FireShaderClass::ShutdownShader() { The ShutdownShader function releases all the pointers that were used to access values inside the fire shader. // Release the distortion constant buffer. if(m_distortionBuffer) {

18 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

22 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

} // Get a pointer to the data in the distortion constant buffer. dataPtr3 = (DistortionBufferType*)mappedResource.pData; // Copy the data into the distortion constant buffer. dataPtr3->distortion1 = distortion1; dataPtr3->distortion2 = distortion2; dataPtr3->distortion3 = distortion3; dataPtr3->distortionScale = distortionScale; dataPtr3->distortionBias = distortionBias; // Unlock the distortion constant buffer. deviceContext->Unmap(m_distortionBuffer, 0); // Set the position of the distortion constant buffer in the pixel shader. bufferNumber = 0; // Now set the distortion constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_distortionBuffer); return true; }

http://www.rastertek.com/dx11tut33.html

This shader requires blending as we use a perturbed alpha texture for sampling and creating see through parts of the final fire effect. // Turn on alpha blending for the fire transparency. m_D3D->TurnOnAlphaBlending(); Put the square model on the graphics pipeline. // Put the square model vertex and index buffers on the graphics pipeline to prepare them for drawing. m_Model->Render(m_D3D->GetDeviceContext()); Render the square model using the flame shader. // Render the square model using the fire shader. result = m_FireShader->Render(m_D3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture1(), m_Model->GetTexture2(), m_Model->GetTexture3(), frameTime, scrollSpeeds, scales, distortion1, distortion2, distortion3, distortionScale, distortionBias); if(!result) { return false; } // Turn off alpha blending. m_D3D->TurnOffAlphaBlending(); // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
The fire shader produces an incredibly realistic fire effect. It is also highly customizable giving it the ability to produce almost any type of fire flame by just modifying one or more of the many tweakable shader variables. The flame will still need to be bill boarded or rendered a couple times at different angles in the same location to be used realistically in a 3D setting.

30 of 31

3/8/2013 12:42 PM

Tutorial 33: Fire

http://www.rastertek.com/dx11tut33.html

To Do Exercises
1. Recompile and run the program. You should get an animated fire effect. Press escape to quit. 2. Modify the many different shader values to see the different effects they produce. Start with scale and bias. You may also want to comment out certain parts of the fire shader to see the effect they have on the different textures. 3. Create your own noise texture and see how it changes the fire. 4. Create your own alpha texture to modify the overall shape of the flame.

2 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

flicker (also called Z fighting). There are a number of well known solutions to this issue but it comes at a cost depending on your implementation. In this tutorial we are going to look at just rendering a simple 10 float unit plane and coloring it based on the depth information. We will color the portion that is closest to the screen as red, then the next small portion as green, and then finally the remainder to the far clip plane as blue. The reason we are doing this is to show you a way of performing detail calculations with depth. This will allow you to extend the technique to do things such as bump mapping things that are close and then as they get distant you can move to just regular diffuse lighting. Also note that depth buffers can be used for so much more, one example being projective shadow mapping, but we are going to just start with the basics.

Framework
The frame work for this tutorial has just the basics with a new class called DepthShaderClass which will handle the depth shading.

We will start the code section of the tutorial by examining the HLSL depth shader first.

Depth.vs
//////////////////////////////////////////////////////////////////////////////// // Filename: depth.vs //////////////////////////////////////////////////////////////////////////////// The depth vertex shader only requires the matrix buffer, no other globals are needed. ///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix;

////////////////////////////////////////////////////////////////////////////////

6 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

// Class name: DepthShaderClass //////////////////////////////////////////////////////////////////////////////// class DepthShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; public: DepthShaderClass(); DepthShaderClass(const DepthShaderClass&); ~DepthShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; We only require the matrix constant buffer. ID3D11Buffer* m_matrixBuffer; }; #endif

Depthshaderclass.cpp

7 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

//////////////////////////////////////////////////////////////////////////////// // Filename: depthshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "depthshaderclass.h" The class constructor initializes all the private pointers to null. DepthShaderClass::DepthShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; }

DepthShaderClass::DepthShaderClass(const DepthShaderClass& other) { }

DepthShaderClass::~DepthShaderClass() { }

bool DepthShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; We load the depth.fx HLSL shader here. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/depth.vs", L"../Engine/depth.ps"); if(!result) { return false; } return true; }

void DepthShaderClass::Shutdown() {

8 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

// Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; } Once again this shader is fairly simple and only requires the three regular matrices as input. bool DepthShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix) { bool result;

bool DepthShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; We only need a single element in our polygonLayout description. D3D11_INPUT_ELEMENT_DESC polygonLayout[1]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0;

9 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

pixelShaderBuffer = 0; Load in the depth vertex shader. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "DepthVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } Load in the depth pixel shader. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "DepthPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer.

10 of 21

3/8/2013 12:39 PM

http://www.rastertek.com/dx11tut35.html

D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr;

void DepthShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0);

14 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Render the triangle. deviceContext->DrawIndexed(indexCount, 0, 0); return; }

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" We include the new header for the DepthShaderClass. #include "depthshaderclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; We have changed the near and far plane values to reduce how much precision is usually lost by the larger values. const float SCREEN_DEPTH = 100.0f; const float SCREEN_NEAR = 1.0f;

////////////////////////////////////////////////////////////////////////////////

15 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

// Class name: GraphicsClass //////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass* m_Model; We now have a private object for the new DepthShaderClass. DepthShaderClass* m_DepthShader; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_Model = 0;

16 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

Initialize the DepthShaderClass object to null in the class constructor. m_DepthShader = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

17 of 21

3/8/2013 12:39 PM

Tutorial 35: Depth Buffer

http://www.rastertek.com/dx11tut35.html

// Set the initial position of the camera. m_Camera->SetPosition(0.0f, 2.0f, -10.0f); // Create the model object. m_Model = new ModelClass; if(!m_Model) { return false; } Load the floor.txt model in. // Initialize the model object. result = m_Model->Initialize(m_D3D->GetDevice(), "../Engine/data/floor.txt"); if(!result) { MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK); return false; } Load the floor.txt model in. // Create the depth shader object. m_DepthShader = new DepthShaderClass; if(!m_DepthShader) { return false; } // Initialize the depth shader object. result = m_DepthShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the depth shader object.", L"Error", MB_OK); return false; } return true; }

Source Code
Visual Studio 2010 Project: dx11tut35.zip Source Only: dx11src35.zip Executable Only: dx11exe35.zip

Back to Tutorial Index

21 of 21

3/8/2013 12:39 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

Tutorial 37: Instancing

Sometimes graphics engines have a requirement to render numerous copies of the exact same geometry with just slight changes in position, scaling, color, and so forth. Particle, foliage, and tree engines are good examples of these types of systems that use the same model hundreds or thousands of times with just slight changes for each time it renders a copy. These systems tend to be very inefficient and send a large amount of data to the graphics card. Instancing is a method of rendering in DirectX 11 that eliminates this problem by accepting a single vertex buffer with the geometry and then uses a second buffer called an Instance Buffer which carries the modification information for each instance of the model geometry. The vertex buffer stays cached on the video card and then it is modified and rendered for each instance in the instance buffer. For this tutorial I will be modifying Tutorial 5: Texturing and use instancing to render four copies of the triangle with slightly different positions to show how instancing works on a basic level. The ModelClass, TextureShaderClass, and the texture HLSL program will need slight modifications for instancing to work. We will start by looking at how to modify the ModelClass to implement instancing.

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h>

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "textureclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: ModelClass //////////////////////////////////////////////////////////////////////////////// class ModelClass

1 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

{ private: struct VertexType { D3DXVECTOR3 position; D3DXVECTOR2 texture; }; We add a new structure that will hold the instance information. In this tutorial we are modifying the position of each instance of the triangle so we use a position vector. But note that it could be anything else you want to modify for each instance such as color, size, rotation, and so forth. You can modify multiple things at once for each instance also. struct InstanceType { D3DXVECTOR3 position; }; public: ModelClass(); ModelClass(const ModelClass&); ~ModelClass(); bool Initialize(ID3D11Device*, WCHAR*); void Shutdown(); void Render(ID3D11DeviceContext*); We have two new functions for getting the vertex and instance counts. We also removed the helper function which previously returned the index count as the instance count has replaced that. int GetVertexCount(); int GetInstanceCount(); ID3D11ShaderResourceView* GetTexture(); private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); void RenderBuffers(ID3D11DeviceContext*); bool LoadTexture(ID3D11Device*, WCHAR*); void ReleaseTexture(); private: ID3D11Buffer* m_vertexBuffer; The ModelClass now has an instance buffer instead of an index buffer. All buffers in DirectX 11 are generic so it uses the ID3D11Buffer type.

2 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

ID3D11Buffer* m_instanceBuffer; int m_vertexCount; The index count has been replaced with the instance count. int m_instanceCount; TextureClass* m_Texture; }; #endif

ModelClass::ModelClass() { m_vertexBuffer = 0; Initialize the new instance buffer to null in the class constructor. m_instanceBuffer = 0; m_Texture = 0; }

ModelClass::ModelClass(const ModelClass& other) { }

ModelClass::~ModelClass() { }

bool ModelClass::Initialize(ID3D11Device* device, WCHAR* textureFilename) {

3 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

bool result;

// Initialize the vertex and instance buffers. result = InitializeBuffers(device); if(!result) { return false; } // Load the texture for this model. result = LoadTexture(device, textureFilename); if(!result) { return false; } return true; }

void ModelClass::Shutdown() { // Release the model texture. ReleaseTexture(); // Shutdown the vertex and instance buffers. ShutdownBuffers(); return; }

void ModelClass::Render(ID3D11DeviceContext* deviceContext) { // Put the vertex and instance buffers on the graphics pipeline to prepare them for drawing. RenderBuffers(deviceContext); return; } These are the two new helper functions which return the vertex and instance counts. int ModelClass::GetVertexCount() {

4 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

return m_vertexCount; }

int ModelClass::GetInstanceCount() { return m_instanceCount; }

ID3D11ShaderResourceView* ModelClass::GetTexture() { return m_Texture->GetTexture(); }

bool ModelClass::InitializeBuffers(ID3D11Device* device) { VertexType* vertices; InstanceType* instances; D3D11_BUFFER_DESC vertexBufferDesc, instanceBufferDesc; D3D11_SUBRESOURCE_DATA vertexData, instanceData; HRESULT result; We will start by manually setting up the vertex buffer that holds the triangle as usual, however there will be no index buffer setup with it this time. // Set the number of vertices in the vertex array. m_vertexCount = 3; // Create the vertex array. vertices = new VertexType[m_vertexCount]; if(!vertices) { return false; } // Load the vertex array with data. vertices[0].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f); // Bottom left. vertices[0].texture = D3DXVECTOR2(0.0f, 1.0f); vertices[1].position = D3DXVECTOR3(0.0f, 1.0f, 0.0f); // Top middle. vertices[1].texture = D3DXVECTOR2(0.5f, 0.0f); vertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f); // Bottom right. vertices[2].texture = D3DXVECTOR2(1.0f, 1.0f);

5 of 28

3/8/2013 12:43 PM

http://www.rastertek.com/dx11tut37.html

// Set the vertex buffer to active in the input assembler so it can be rendered. deviceContext->IASetVertexBuffers(0, 2, bufferPointers, strides, offsets); // Set the type of primitive that should be rendered from this vertex buffer, in this case triangles. deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); return; }

bool ModelClass::LoadTexture(ID3D11Device* device, WCHAR* filename) { bool result;

void ModelClass::ReleaseTexture() { // Release the texture object. if(m_Texture) { m_Texture->Shutdown(); delete m_Texture; m_Texture = 0; } return; }

9 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

Textureshaderclass.h
The TextureShaderClass has been modified also to handle setting up instancing for the shader. //////////////////////////////////////////////////////////////////////////////// // Filename: textureshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _TEXTURESHADERCLASS_H_ #define _TEXTURESHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

10 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*); void RenderShader(ID3D11DeviceContext*, int, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState; }; #endif

TextureShaderClass::TextureShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; }

TextureShaderClass::TextureShaderClass(const TextureShaderClass& other) { }

11 of 28

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. // This setup needs to match the VertexType stucture in the ModelClass and in the shader. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;

14 of 28

3/8/2013 12:43 PM

http://www.rastertek.com/dx11tut37.html

The vertex shader has now been modified to use instancing. //////////////////////////////////////////////////////////////////////////////// // Filename: texture.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

////////////// // TYPEDEFS // ////////////// The VertexInputType structure now has the third element which will hold the instanced input position data. struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; float3 instancePosition : TEXCOORD1; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType TextureVertexShader(VertexInputType input) { PixelInputType output;

20 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

// Change the position vector to be 4 units for proper matrix calculations. input.position.w = 1.0f; Here is where we use the instanced position information to modify the position of each triangle we are drawing. // Update the position of the vertices based on the data for this particular instance. input.position.x += input.instancePosition.x; input.position.y += input.instancePosition.y; input.position.z += input.instancePosition.z; // Calculate the position of the vertex against the world, view, and projection matrices. output.position = mul(input.position, worldMatrix); output.position = mul(output.position, viewMatrix); output.position = mul(output.position, projectionMatrix); // Store the texture coordinates for the pixel shader. output.tex = input.tex; return output; }

Texture.ps
The pixel shader has not changed for this tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: texture.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture; SamplerState SampleType;

////////////// // TYPEDEFS // ////////////// struct PixelInputType

21 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

{ float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

// Sample the pixel color from the texture using the sampler at this texture coordinate location. textureColor = shaderTexture.Sample(SampleType, input.tex); return textureColor; }

Graphicsclass.h
The GraphicsClass header hasn't changed for this tutorial. //////////////////////////////////////////////////////////////////////////////// // Filename: graphicsclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GRAPHICSCLASS_H_ #define _GRAPHICSCLASS_H_

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "textureshaderclass.h"

///////////// // GLOBALS //

22 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

GraphicsClass::GraphicsClass()

23 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

{ m_D3D = 0; m_Camera = 0; m_Model = 0; m_TextureShader = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

24 of 28

3/8/2013 12:43 PM

Tutorial 37: Instancing

http://www.rastertek.com/dx11tut37.html

Source Code
Source Code and Data Files: dx11src37.zip Executable: dx11exe37.zip

Back to Tutorial Index

28 of 28

3/8/2013 12:43 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

http://www.rastertek.com/dx11tut43.html

Projection.vs
The code for the projection shaders is the directional light shaders modified to handle projected texturing. //////////////////////////////////////////////////////////////////////////////// // Filename: projection.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; We will require a separate view matrix and projection matrix for the view point that we want to project the texture from. matrix viewMatrix2; matrix projectionMatrix2; };

////////////// // TYPEDEFS // ////////////// struct VertexInputType { float4 position : POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; }; struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; The viewPosition is the position of the vertice as viewed by the location where we are going to the project the texture from. float4 viewPosition : TEXCOORD1;

4 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

};

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType ProjectionVertexShader(VertexInputType input) { PixelInputType output;

// Change the position vector to be 4 units for proper matrix calculations. input.position.w = 1.0f; // Calculate the position of the vertex against the world, view, and projection matrices. output.position = mul(input.position, worldMatrix); output.position = mul(output.position, viewMatrix); output.position = mul(output.position, projectionMatrix); Calculate the position of the vertice from the view point of where we are projecting the texture from. Note we can use the regular world matrix but we use the second pair of view and projection matrices. // Store the position of the vertice as viewed by the projection view point in a separate variable. output.viewPosition = mul(input.position, worldMatrix); output.viewPosition = mul(output.viewPosition, viewMatrix2); output.viewPosition = mul(output.viewPosition, projectionMatrix2); // Store the texture coordinates for the pixel shader. output.tex = input.tex; // Calculate the normal vector against the world matrix only. output.normal = mul(input.normal, (float3x3)worldMatrix); // Normalize the normal vector. output.normal = normalize(output.normal); return output; }

Projection.ps
////////////////////////////////////////////////////////////////////////////////

5 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

// Filename: projection.ps ////////////////////////////////////////////////////////////////////////////////

////////////// // TEXTURES // ////////////// Texture2D shaderTexture : register(t0); The projectionTexture is the texture that we will be projecting onto the scene. Texture2D projectionTexture : register(t1);

////////////// // SAMPLERS // ////////////// SamplerState SampleType;

////////////////////// // CONSTANT BUFFERS // ////////////////////// cbuffer LightBuffer { float4 ambientColor; float4 diffuseColor; float3 lightDirection; float padding; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; float3 normal : NORMAL; float4 viewPosition : TEXCOORD1; };

////////////////////////////////////////////////////////////////////////////////

6 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

// Pixel Shader //////////////////////////////////////////////////////////////////////////////// float4 ProjectionPixelShader(PixelInputType input) : SV_TARGET { float4 color; float3 lightDir; float lightIntensity; float4 textureColor; float2 projectTexCoord; float4 projectionColor; Perform regular directional lighting and texturing as usual. // Set the default output color to the ambient light value for all pixels. color = ambientColor; // Invert the light direction for calculations. lightDir = -lightDirection; // Calculate the amount of light on this pixel. lightIntensity = saturate(dot(input.normal, lightDir)); if(lightIntensity > 0.0f) { // Determine the light color based on the diffuse color and the amount of light intensity. color += (diffuseColor * lightIntensity); } // Saturate the light color. color = saturate(color); // Sample the pixel color from the texture using the sampler at this texture coordinate location. textureColor = shaderTexture.Sample(SampleType, input.tex); // Combine the light color and the texture color. color = color * textureColor; Now we calculate the projection coordinates for sampling the projected texture from. These coordinates are the position the vertex is being viewed from by the location of the projection view point. The coordinates are translated into 2D screen coordinates and moved into the 0.0f to 1.0f range from the -0.5f to +0.5f range. // Calculate the projected texture coordinates. projectTexCoord.x = input.viewPosition.x / input.viewPosition.w / 2.0f + 0.5f; projectTexCoord.y = -input.viewPosition.y / input.viewPosition.w / 2.0f + 0.5f; Next we need to check if the coordinates are in the 0.0f to 1.0f range. If they are not in that range then this pixel is not in the projection area so it is just illuminated

7 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

and textured as normal. However if it is inside the 0.0f to 1.0f range then this pixel is inside the projected texture area and we need to apply the projected texture to the output pixel. // Determine if the projected coordinates are in the 0 to 1 range. If it is then this pixel is inside the projected view port. if((saturate(projectTexCoord.x) == projectTexCoord.x) && (saturate(projectTexCoord.y) == projectTexCoord.y)) { Sample the projection texture using the projected texture coordinates and then set the output pixel color to be the projected texture color. // Sample the color value from the projection texture using the sampler at the projected texture coordinate location. projectionColor = projectionTexture.Sample(SampleType, projectTexCoord); // Set the output color of this pixel to the projection texture overriding the regular color value. color = projectionColor; } return color; }

Projectionshaderclass.h
The ProjectionShaderClass is just the LightShaderClass rewritten to handle texture projection. //////////////////////////////////////////////////////////////////////////////// // Filename: projectionshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _PROJECTIONSHADERCLASS_H_ #define _PROJECTIONSHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: ProjectionShaderClass

8 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

//////////////////////////////////////////////////////////////////////////////// class ProjectionShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; We will require a view matrix and a projection matrix from the view point of the projection to perform projected texturing. D3DXMATRIX view2; D3DXMATRIX projection2; }; struct LightBufferType { D3DXVECTOR4 ambientColor; D3DXVECTOR4 diffuseColor; D3DXVECTOR3 lightDirection; float padding; }; public: ProjectionShaderClass(); ProjectionShaderClass(const ProjectionShaderClass&); ~ProjectionShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR4, D3DXVECTOR4, D3DX D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR4, D3DXVECT D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*); void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader;

9 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11SamplerState* m_sampleState; ID3D11Buffer* m_matrixBuffer; ID3D11Buffer* m_lightBuffer; }; #endif

Projectionshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: projectionshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "projectionshaderclass.h"

ProjectionShaderClass::ProjectionShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_sampleState = 0; m_matrixBuffer = 0; m_lightBuffer = 0; }

ProjectionShaderClass::ProjectionShaderClass(const ProjectionShaderClass& other) { }

ProjectionShaderClass::~ProjectionShaderClass() { }

bool ProjectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result;

10 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

Load the projection HLSL files. // Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/projection.vs", L"../Engine/projection.ps"); if(!result) { return false; } return true; }

void ProjectionShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; }

bool ProjectionShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 lightDirection, D3DXMATRIX viewMatrix2, D3DXMATRIX projectionMatrix2, ID3D11ShaderResourceView* projectionTexture) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, ambientColor, diffuseColor, lightDirection, viewMatrix2, projectionMatrix2, projectionTexture); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; }

11 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

bool ProjectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[3]; unsigned int numElements; D3D11_SAMPLER_DESC samplerDesc; D3D11_BUFFER_DESC matrixBufferDesc; D3D11_BUFFER_DESC lightBufferDesc;

// Initialize the pointers this function will use to null. errorMessage = 0; vertexShaderBuffer = 0; pixelShaderBuffer = 0; Compile the projection vertex shader. // Compile the vertex shader code. result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ProjectionVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, vsFilename); } // If there was nothing in the error message then it simply could not find the shader file itself. else { MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK); } return false; } Compile the projection pixel shader. // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ProjectionPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result))

12 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

{ // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0; polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0;

13 of 32

http://www.rastertek.com/dx11tut43.html

ofstream fout;

bool ProjectionShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 lightDirection, D3DXMATRIX viewMatrix2, D3DXMATRIX projectionMatrix2, ID3D11ShaderResourceView* projectionTexture) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2;

// Transpose the matrices to prepare them for the shader.

17 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); Transpose the second view and projection matrices. D3DXMatrixTranspose(&viewMatrix2, &viewMatrix2); D3DXMatrixTranspose(&projectionMatrix2, &projectionMatrix2); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; Set the two new matrices in the shader. dataPtr->view2 = viewMatrix2; dataPtr->projection2 = projectionMatrix2; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; }

18 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

// Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->ambientColor = ambientColor; dataPtr2->diffuseColor = diffuseColor; dataPtr2->lightDirection = lightDirection; dataPtr2->padding = 0.0f; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); Set the projection texture in the pixel shader. deviceContext->PSSetShaderResources(1, 1, &projectionTexture); return true; }

void ProjectionShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0); deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Set the sampler state in the pixel shader. deviceContext->PSSetSamplers(0, 1, &m_sampleState); // Render the triangle. deviceContext->DrawIndexed(indexCount, 0, 0); return;

19 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

Viewpointclass.h
The ViewPointClass encapsulates the view point that we will be looking at the scene from in terms of projecting a texture. It is similar to the LightClass or CameraClass that it has a position in the 3D world and it has a position that it is looking at in the 3D world. With the position variables and projection variables set it can then generate a view matrix and a projection matrix to represent the view point in the 3D world. Those two matrices can then be sent into the shader to be used to project the texture onto the 3D scene. //////////////////////////////////////////////////////////////////////////////// // Filename: viewpointclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _VIEWPOINTCLASS_H_ #define _VIEWPOINTCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3dx10math.h>

//////////////////////////////////////////////////////////////////////////////// // Class name: ViewPointClass //////////////////////////////////////////////////////////////////////////////// class ViewPointClass { public: ViewPointClass(); ViewPointClass(const ViewPointClass&); ~ViewPointClass(); void SetPosition(float, float, float); void SetLookAt(float, float, float); void SetProjectionParameters(float, float, float, float); void GenerateViewMatrix(); void GenerateProjectionMatrix(); void GetViewMatrix(D3DXMATRIX&); void GetProjectionMatrix(D3DXMATRIX&);

20 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

private: D3DXVECTOR3 m_position, m_lookAt; D3DXMATRIX m_viewMatrix, m_projectionMatrix; float m_fieldOfView, m_aspectRatio, m_nearPlane, m_farPlane; }; #endif

Viewpointclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: viewpointclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "viewpointclass.h"

ViewPointClass::ViewPointClass() { }

ViewPointClass::ViewPointClass(const ViewPointClass& other) { }

ViewPointClass::~ViewPointClass() { }

void ViewPointClass::SetPosition(float x, float y, float z) { m_position = D3DXVECTOR3(x, y, z); return; }

void ViewPointClass::SetLookAt(float x, float y, float z) { m_lookAt = D3DXVECTOR3(x, y, z); return;

21 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

void ViewPointClass::SetProjectionParameters(float fieldOfView, float aspectRatio, float nearPlane, float farPlane) { m_fieldOfView = fieldOfView; m_aspectRatio = aspectRatio; m_nearPlane = nearPlane; m_farPlane = farPlane; return; }

void ViewPointClass::GenerateViewMatrix() { D3DXVECTOR3 up;

// Setup the vector that points upwards. up.x = 0.0f; up.y = 1.0f; up.z = 0.0f; // Create the view matrix from the three vectors. D3DXMatrixLookAtLH(&m_viewMatrix, &m_position, &m_lookAt, &up); return; }

void ViewPointClass::GenerateProjectionMatrix() { // Create the projection matrix for the view point. D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, m_fieldOfView, m_aspectRatio, m_nearPlane, m_farPlane); return; }

void ViewPointClass::GetViewMatrix(D3DXMATRIX& viewMatrix) { viewMatrix = m_viewMatrix; return; }

22 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

void ViewPointClass::GetProjectionMatrix(D3DXMATRIX& projectionMatrix) { projectionMatrix = m_projectionMatrix; return; }

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" #include "cameraclass.h" #include "modelclass.h" #include "lightclass.h" Include the headers required for projecting a texture onto the scene. #include "projectionshaderclass.h" #include "textureclass.h" #include "viewpointclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 100.0f; const float SCREEN_NEAR = 1.0f;

//////////////////////////////////////////////////////////////////////////////// // Class name: GraphicsClass

23 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

//////////////////////////////////////////////////////////////////////////////// class GraphicsClass { public: GraphicsClass(); GraphicsClass(const GraphicsClass&); ~GraphicsClass(); bool Initialize(int, int, HWND); void Shutdown(); bool Frame(); private: bool Render(); private: D3DClass* m_D3D; CameraClass* m_Camera; ModelClass *m_GroundModel, *m_CubeModel; LightClass* m_Light; Define the class pointer variables that will be used for projecting the texture. ProjectionShaderClass* m_ProjectionShader; TextureClass* m_ProjectionTexture; ViewPointClass* m_ViewPoint; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0;

24 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

m_GroundModel = 0; m_CubeModel = 0; m_Light = 0; Initialize the three pointers to null in the class constructor. m_ProjectionShader = 0; m_ProjectionTexture = 0; m_ViewPoint = 0; }

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

25 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

{ return false; } // Set the initial position and rotation of the camera. m_Camera->SetPosition(0.0f, 7.0f, -10.0f); m_Camera->SetRotation(35.0f, 0.0f, 0.0f); // Create the ground model object. m_GroundModel = new ModelClass; if(!m_GroundModel) { return false; } // Initialize the ground model object. result = m_GroundModel->Initialize(m_D3D->GetDevice(), "../Engine/data/floor.txt", L"../Engine/data/stone.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the ground model object.", L"Error", MB_OK); return false; }

// Create the cube model object. m_CubeModel = new ModelClass; if(!m_CubeModel) { return false; } // Initialize the cube model object. result = m_CubeModel->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/seafloor.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the cube model object.", L"Error", MB_OK); return false; } // Create the light object. m_Light = new LightClass; if(!m_Light) { return false; }

26 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

// Initialize the light object. m_Light->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f); m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetDirection(0.0f, -0.75f, 0.5f); Create and initialize the projection shader object. // Create the projection shader object. m_ProjectionShader = new ProjectionShaderClass; if(!m_ProjectionShader) { return false; } // Initialize the projection shader object. result = m_ProjectionShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the projection shader object.", L"Error", MB_OK); return false; } Create and initialize the DirectX 11 texture that we will be projecting onto the 3D scene. // Create the projection texture object. m_ProjectionTexture = new TextureClass; if(!m_ProjectionTexture) { return false; } // Initialize the projection texture object. result = m_ProjectionTexture->Initialize(m_D3D->GetDevice(), L"../Engine/data/dx11.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the projection texture object.", L"Error", MB_OK); return false; } Create and initialize the view point object that will be used as the location to project the texture from. When setting the projection parameters here I have set it up to create a square viewing frustum. // Create the view point object. m_ViewPoint = new ViewPointClass;

27 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

if(!m_ViewPoint) { return false; } // Initialize the view point object. m_ViewPoint->SetPosition(2.0f, 5.0f, -2.0f); m_ViewPoint->SetLookAt(0.0f, 0.0f, 0.0f); m_ViewPoint->SetProjectionParameters((float)(D3DX_PI / 2.0f), 1.0f, 0.1f, 100.0f); m_ViewPoint->GenerateViewMatrix(); m_ViewPoint->GenerateProjectionMatrix(); return true; }

void GraphicsClass::Shutdown() { We release the three texture projection related objects in the Shutdown function. // Release the view point object. if(m_ViewPoint) { delete m_ViewPoint; m_ViewPoint = 0; } // Release the projection texture object. if(m_ProjectionTexture) { m_ProjectionTexture->Shutdown(); delete m_ProjectionTexture; m_ProjectionTexture = 0; } // Release the projection shader object. if(m_ProjectionShader) { m_ProjectionShader->Shutdown(); delete m_ProjectionShader; m_ProjectionShader = 0; } // Release the light object.

28 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

if(m_Light) { delete m_Light; m_Light = 0; } // Release the cube model object. if(m_CubeModel) { m_CubeModel->Shutdown(); delete m_CubeModel; m_CubeModel = 0; } // Release the ground model object. if(m_GroundModel) { m_GroundModel->Shutdown(); delete m_GroundModel; m_GroundModel = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

bool GraphicsClass::Frame() { bool result;

29 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

// Render the graphics scene. result = Render(); if(!result) { return false; } return true; }

bool GraphicsClass::Render() { D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix; D3DXMATRIX viewMatrix2, projectionMatrix2; bool result;

// Clear the buffers to begin the scene. m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f); // Generate the view matrix based on the camera's position. m_Camera->Render(); // Get the world, view, and projection matrices from the camera and d3d objects. m_D3D->GetWorldMatrix(worldMatrix); m_Camera->GetViewMatrix(viewMatrix); m_D3D->GetProjectionMatrix(projectionMatrix); Get the second view and projection matrix from the view point object. These two matrices will be used for projecting the texture. // Get the view and projection matrices from the view point object. m_ViewPoint->GetViewMatrix(viewMatrix2); m_ViewPoint->GetProjectionMatrix(projectionMatrix2); Now render the two models using the projection shader to project the texture onto them as well as light and texture them. // Setup the translation for the ground model. D3DXMatrixTranslation(&worldMatrix, 0.0f, 1.0f, 0.0f); // Render the ground model using the projection shader. m_GroundModel->Render(m_D3D->GetDeviceContext()); result = m_ProjectionShader->Render(m_D3D->GetDeviceContext(), m_GroundModel->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_GroundModel->GetTexture(), m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Light->GetDirection(),

30 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

viewMatrix2, projectionMatrix2, m_ProjectionTexture->GetTexture()); if(!result) { return false; } // Reset the world matrix and setup the translation for the cube model. m_D3D->GetWorldMatrix(worldMatrix); D3DXMatrixTranslation(&worldMatrix, 0.0f, 2.0f, 0.0f); // Render the cube model using the projection shader. m_CubeModel->Render(m_D3D->GetDeviceContext()); result = m_ProjectionShader->Render(m_D3D->GetDeviceContext(), m_CubeModel->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_CubeModel->GetTexture(), m_Light->GetAmbientColor(), m_Light->GetDiffuseColor(), m_Light->GetDirection(), viewMatrix2, projectionMatrix2, m_ProjectionTexture->GetTexture()); if(!result) { return false; } // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
We can now project 2D textures onto 3D scenes from any defined view point.

31 of 32

3/8/2013 12:45 PM

Tutorial 43: Projective Texturing

http://www.rastertek.com/dx11tut43.html

To Do Exercises
1. Compile and run the program. You will see a 3D scene with a 2D texture projected onto it. 2. Change the texture that is being projected onto the scene. 3. Set the cube to rotate to see the effect of the projected texture on it. 4. Modify the location of the view point. 5. Modify the projection parameters of the view point to create a different shaped projection.

Source Code
Source Code and Data Files: dx11src43.zip Executable: dx11exe43.zip

Back to Tutorial Index

32 of 32

3/8/2013 12:45 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

Tutorial 45: Managing Multiple Shaders

One of the issues that quickly arises in a graphics application that uses multiple shaders is how to manage them. In the DirectX 11 tutorial series I generally don't show how manage them as it makes the tutorials less focused and harder to comprehend. So in this tutorial I will present one of the simpler methods for managing multiple shaders. For this tutorial we will use a new class called ShaderManagerClass. What this class does is it encapsulates the loading, unloading, and usage of all the shaders that the application requires. In design patterns terminology this is usually referred to as a facade pattern as we are encapsulating and providing a singular simplified interface to a much larger body of code. In this tutorial the ShaderManagerClass will contain the texture, light, and bump map shader objects. It will load and unload all three of them, and it will also provide interfaces to have them render objects. This allows us to create just a single ShaderManagerClass object and then pass a single pointer to the class object around the application so that rendering objects is just a single function call using the object pointer. This is similar to how the D3DClass has been used in previous tutorials. The following image shows a cube being rendered with a texture shader, a light shader, and a bump map shader all at the same time through the use of the ShaderManagerClass:

We will start the code section by examining the ShaderManagerClass.

Shadermanagerclass.h
//////////////////////////////////////////////////////////////////////////////// // Filename: shadermanagerclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _SHADERMANAGERCLASS_H_ #define _SHADERMANAGERCLASS_H_

/////////////////////// // MY CLASS INCLUDES //

1 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

/////////////////////// #include "d3dclass.h" Here is where we include each shader class header file that we want to use in the application. #include "textureshaderclass.h" #include "lightshaderclass.h" #include "bumpmapshaderclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: ShaderManagerClass //////////////////////////////////////////////////////////////////////////////// class ShaderManagerClass { public: ShaderManagerClass(); ShaderManagerClass(const ShaderManagerClass&); ~ShaderManagerClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); We create a single render function for each shader that the ShaderManagerClass handles. bool RenderTextureShader(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*); bool RenderLightShader(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, D3DXVECTOR3, D3DXVECTOR4, D3DXVECTOR4, D3DXVECTOR3, D3DXVECTOR4, float); bool RenderBumpMapShader(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, D3DXVECTOR3, D3DXVECTOR4); private: The ShaderManagerClass contains a private class object for each shader type the application will be using. TextureShaderClass* m_TextureShader; LightShaderClass* m_LightShader; BumpMapShaderClass* m_BumpMapShader; }; #endif

2 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

Shadermanagerclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: shadermanagerclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "shadermanagerclass.h"

ShaderManagerClass::ShaderManagerClass() { Initialize the private shader class objects to null in the class constructor. m_TextureShader = 0; m_LightShader = 0; m_BumpMapShader = 0; }

ShaderManagerClass::ShaderManagerClass(const ShaderManagerClass& other) { }

ShaderManagerClass::~ShaderManagerClass() { }

bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result; Create and initialize the texture shader object. // Create the texture shader object. m_TextureShader = new TextureShaderClass; if(!m_TextureShader) { return false; }

3 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

// Initialize the texture shader object. result = m_TextureShader->Initialize(device, hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the texture shader object.", L"Error", MB_OK); return false; } Create and initialize the light shader object. // Create the light shader object. m_LightShader = new LightShaderClass; if(!m_LightShader) { return false; } // Initialize the light shader object. result = m_LightShader->Initialize(device, hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK); return false; } Create and initialize the bump map shader object. // Create the bump map shader object. m_BumpMapShader = new BumpMapShaderClass; if(!m_BumpMapShader) { return false; } // Initialize the bump map shader object. result = m_BumpMapShader->Initialize(device, hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the bump map shader object.", L"Error", MB_OK); return false; } return true; }

4 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

The Shutdown function releases all the shaders that were in use by the application. void ShaderManagerClass::Shutdown() { // Release the bump map shader object. if(m_BumpMapShader) { m_BumpMapShader->Shutdown(); delete m_BumpMapShader; m_BumpMapShader = 0; } // Release the light shader object. if(m_LightShader) { m_LightShader->Shutdown(); delete m_LightShader; m_LightShader = 0; } // Release the texture shader object. if(m_TextureShader) { m_TextureShader->Shutdown(); delete m_TextureShader; m_TextureShader = 0; } return; } Here is where we create a specialized render function for each shader type that ShaderManagerClass uses. In the application we can now just pass around a pointer to the ShaderManagerClass object and then make a call to one of the following functions to render any model with the desired shader. bool ShaderManagerClass::RenderTextureShader(ID3D11DeviceContext* device, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRI ID3D11ShaderResourceView* texture) { bool result;

// Render the model using the texture shader. result = m_TextureShader->Render(device, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture); if(!result) { return false;

5 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

} return true; }

bool ShaderManagerClass::RenderLightShader(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXM ID3D11ShaderResourceView* texture, D3DXVECTOR3 lightDirection, D3DXVECTOR4 ambient, D3DXVECTOR4 diffuse, D3DXVECTOR3 cameraPosition, D3DXVECTOR4 specular, float specularPower) { bool result;

// Render the model using the light shader. result = m_LightShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, ambient, diffuse, cameraPosition, specular, specularPower); if(!result) { return false; } return true; }

bool ShaderManagerClass::RenderBumpMapShader(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3 ID3D11ShaderResourceView* colorTexture, ID3D11ShaderResourceView* normalTexture, D3DXVECTOR3 lightDirection, D3DXVECTOR4 diffuse) { bool result;

// Render the model using the bump map shader. result = m_BumpMapShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, colorTexture, normalTexture, lightDirection, diffuse); if(!result) { return false; } return true; }

6 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

/////////////////////// // MY CLASS INCLUDES // /////////////////////// #include "d3dclass.h" So now in the GraphicsClass we include just the header for the ShaderManagerClass instead of all the individual shader headers. #include "shadermanagerclass.h" #include "cameraclass.h" #include "lightclass.h" #include "modelclass.h" #include "bumpmodelclass.h"

///////////// // GLOBALS // ///////////// const bool FULL_SCREEN = true; const bool VSYNC_ENABLED = true; const float SCREEN_DEPTH = 1000.0f; const float SCREEN_NEAR = 0.1f;

7 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

bool Frame(); private: bool Render(float); private: D3DClass* m_D3D; We create a private pointer to the ShaderManagerClass object here. ShaderManagerClass* m_ShaderManager; CameraClass* m_Camera; LightClass* m_Light; We will use three different cube models for the purposes of the tutorial. ModelClass* m_Model1; ModelClass* m_Model2; BumpModelClass* m_Model3; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_ShaderManager = 0; m_Light = 0; m_Camera = 0; m_Model1 = 0; m_Model2 = 0; m_Model3 = 0; }

8 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

GraphicsClass::GraphicsClass(const GraphicsClass& other) { }

GraphicsClass::~GraphicsClass() { }

bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd) { bool result;

9 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

return false; } // Create the camera object. m_Camera = new CameraClass; if(!m_Camera) { return false; } // Set the initial position of the camera. m_Camera->SetPosition(0.0f, 0.0f, -10.0f); // Create the light object. m_Light = new LightClass; if(!m_Light) { return false; } // Initialize the light object. m_Light->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f); m_Light->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetDirection(0.0f, 0.0f, 1.0f); m_Light->SetSpecularColor(1.0f, 1.0f, 1.0f, 1.0f); m_Light->SetSpecularPower(64.0f); Load the three different cube models with their associated textures. This way we have three different cubes that we can each render with a different shader using the ShaderManagerClass. // Create the model object. m_Model1 = new ModelClass; if(!m_Model1) { return false; } // Initialize the model object. result = m_Model1->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/marble.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the first model object.", L"Error", MB_OK); return false; }

10 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

// Create the second model object. m_Model2 = new ModelClass; if(!m_Model2) { return false; } // Initialize the second model object. result = m_Model2->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/metal.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the second model object.", L"Error", MB_OK); return false; } // Create the third bump model object for models with normal maps and related vectors. m_Model3 = new BumpModelClass; if(!m_Model3) { return false; } // Initialize the bump model object. result = m_Model3->Initialize(m_D3D->GetDevice(), "../Engine/data/cube.txt", L"../Engine/data/stone.dds", L"../Engine/data/normal.dds"); if(!result) { MessageBox(hwnd, L"Could not initialize the third model object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { // Release the model objects. if(m_Model1) { m_Model1->Shutdown(); delete m_Model1; m_Model1 = 0; }

11 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

if(m_Model2) { m_Model2->Shutdown(); delete m_Model2; m_Model2 = 0; } if(m_Model3) { m_Model3->Shutdown(); delete m_Model3; m_Model3 = 0; } // Release the light object. if(m_Light) { delete m_Light; m_Light = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the shader manager object. if(m_ShaderManager) { m_ShaderManager->Shutdown(); delete m_ShaderManager; m_ShaderManager = 0; } // Release the D3D object. if(m_D3D) { m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return;

http://www.rastertek.com/dx11tut45.html

m_Light->GetDiffuseColor()); if(!result) { return false; } // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
Now we have a single class which encapsulates all the shading functionality that our graphics application will need.

To Do Exercises
1. Compile and run the code. You should see three cubes each shaded with a different shader. Press escape to quit. 2. Add another shader to the ShaderManagerClass and render a fourth cube using that shader. 3. Add some intelligence to the ShaderManagerClass to load and unload shaders on demand.

Source Code
Source Code and Data Files: dx11src45.zip

15 of 16

3/8/2013 12:43 PM

Tutorial 45: Managing Multiple Shaders

http://www.rastertek.com/dx11tut45.html

Executable: dx11exe45.zip

Back to Tutorial Index

16 of 16

3/8/2013 12:43 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

Tutorial 46: Glow

This tutorial will cover how to add glow to your scene using DirectX 11 and HLSL. This tutorial builds on the concepts from the DirectX blur tutorial as blur is a required step in producing a glow. Usually user interface elements (such as menu systems) and 3D objects are the two things that get glow applied to them in 2D and 3D applications. Both are done in the exact same fashion. For this tutorial I will be applying glow to just a single 2D user interface object to make the tutorial simple and to cover the most popular use of glow. However the steps are exactly the same for 3D objects. To begin I have created a simple menu button that looks like the following:

Now say I want to apply glow to just the border of the button and not the text. Controlling where we apply glow is very important as we generally don't want everything glowing. To do so I will create a black and white glow map indicating where I want the glow effect to be applied. This is similar to making an alpha map for transparency. In the case of the menu button and just applying glow to the border I would create a glow map that looks like the following:

Now that we have a glow map bitmap and the menu button bitmap we can start the glow effect. The first step is that we render just the portion of the menu button bitmap that we want the glow applied to onto a render to texture. We do the render by creating a glow map shader which takes the two bitmaps and renders the pixels from the color bitmap on the render to texture object only if there is a corresponding non-black pixel in the glow map. This way our glow map basically becomes a transparency mask allowing just the border of the menu button to be rendered to the render to texture object. With the border rendered to the render to texture object we can proceed to the next important step of applying the blur. We will down sample the texture, blur it horizontally, then blur it vertically, and then up sample it. This was done in the DirectX blur tutorial on this website so we won't cover those blur details in this tutorial. Once the render to texture has been blurred we then brighten the glow by multiplying the color by a glow strength value. The following image I used a glow strength of 3.0:

Now that we have the glow render to texture we will apply it to the final scene. We first need to render all our user interface elements as we would normally without the glow to their own render to texture. We then take the resulting render to texture object and the blurred render to texture object and combine the two textures in a glow shader. All the glow shader does is it adds the to textures together and then draws it to the back buffer. The following image is the result:

1 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

Also remember that 3D objects are done in the exact same way. Render the portions of the 3D object using the glow map to a render to texture, blur it, and combine it with the regular 3D scene using the glow shader. For this tutorial the following steps and the related render to texture objects for each step will be the following: 1. Render the glow maps to a render to texture object (output is m_RenderTexture). 2. Down sample the render to texture of the glow maps to a render to texture object that is half the size (new output is m_DownSampleTexure). 3. Perform a horizontal blur on the output of the previous step (new output is m_HorizontalBlurTexture). 4. Perform a vertical blur on the horizontal blur texture (new output is m_VerticalBlurTexture). 5. Up sample the vertical blurred texture to regular screen size again (new output is m_UpSampleTexure). 6. Now render the user interface elements to render to texture (output will be m_RenderTexture). 7. Combine the up sampled texture and the render texture of the user interface elements using the glow shader and write it to the back buffer. For the code section of this tutorial we won't be discussing anything related to blur as it was already covered in the blur tutorial. We will start by looking at the modified BitmapClass.

Bitmapclass.h
The BitmapClass has been modified and now has a glow map texture associated with it. //////////////////////////////////////////////////////////////////////////////// // Filename: bitmapclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _BITMAPCLASS_H_ #define _BITMAPCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h>

/////////////////////// // MY CLASS INCLUDES //

2 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

/////////////////////// #include "textureclass.h"

//////////////////////////////////////////////////////////////////////////////// // Class name: BitmapClass //////////////////////////////////////////////////////////////////////////////// class BitmapClass { private: struct VertexType { D3DXVECTOR3 position; D3DXVECTOR2 texture; }; public: BitmapClass(); BitmapClass(const BitmapClass&); ~BitmapClass(); bool Initialize(ID3D11Device*, int, int, WCHAR*, WCHAR*, int, int); void Shutdown(); bool Render(ID3D11DeviceContext*, int, int); int GetIndexCount(); ID3D11ShaderResourceView* GetTexture(); ID3D11ShaderResourceView* GetGlowMap(); private: bool InitializeBuffers(ID3D11Device*); void ShutdownBuffers(); bool UpdateBuffers(ID3D11DeviceContext*, int, int); void RenderBuffers(ID3D11DeviceContext*); bool LoadTextures(ID3D11Device*, WCHAR*, WCHAR*); void ReleaseTextures(); private: ID3D11Buffer *m_vertexBuffer, *m_indexBuffer; int m_vertexCount, m_indexCount; TextureClass* m_Texture; TextureClass* m_GlowMap; int m_screenWidth, m_screenHeight; int m_bitmapWidth, m_bitmapHeight;

3 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

int m_previousPosX, m_previousPosY; }; #endif

BitmapClass::BitmapClass() { m_vertexBuffer = 0; m_indexBuffer = 0; m_Texture = 0; m_GlowMap = 0; }

BitmapClass::BitmapClass(const BitmapClass& other) { }

BitmapClass::~BitmapClass() { }

bool BitmapClass::Initialize(ID3D11Device* device, int screenWidth, int screenHeight, WCHAR* textureFilename, WCHAR* glowMapFilename, int bitmapWidth, int bitm { bool result;

// Store the screen size. m_screenWidth = screenWidth; m_screenHeight = screenHeight; // Store the size in pixels that this bitmap should be rendered at.

4 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

m_bitmapWidth = bitmapWidth; m_bitmapHeight = bitmapHeight; // Initialize the previous rendering position to negative one. m_previousPosX = -1; m_previousPosY = -1; // Initialize the vertex and index buffers. result = InitializeBuffers(device); if(!result) { return false; } // Load the textures for this bitmap. result = LoadTextures(device, textureFilename, glowMapFilename); if(!result) { return false; } return true; }

void BitmapClass::Shutdown() { // Release the bitmap textures. ReleaseTextures(); // Shutdown the vertex and index buffers. ShutdownBuffers(); return; }

bool BitmapClass::Render(ID3D11DeviceContext* deviceContext, int positionX, int positionY) { bool result;

// Re-build the dynamic vertex buffer for rendering to possibly a different location on the screen. result = UpdateBuffers(deviceContext, positionX, positionY); if(!result)

5 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

{ return false; } // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing. RenderBuffers(deviceContext); return true; }

int BitmapClass::GetIndexCount() { return m_indexCount; }

ID3D11ShaderResourceView* BitmapClass::GetTexture() { return m_Texture->GetTexture(); }

ID3D11ShaderResourceView* BitmapClass::GetGlowMap() { return m_GlowMap->GetTexture(); }

// Set the number of vertices in the vertex array. m_vertexCount = 6; // Set the number of indices in the index array. m_indexCount = m_vertexCount;

6 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

// Create the vertex array. vertices = new VertexType[m_vertexCount]; if(!vertices) { return false; } // Create the index array. indices = new unsigned long[m_indexCount]; if(!indices) { return false; } // Initialize vertex array to zeros at first. memset(vertices, 0, (sizeof(VertexType) * m_vertexCount)); // Load the index array with data. for(i=0; i<m_indexCount; i++) { indices[i] = i; } // Set up the description of the static vertex buffer. vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC; vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount; vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; vertexBufferDesc.MiscFlags = 0; vertexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the vertex data. vertexData.pSysMem = vertices; vertexData.SysMemPitch = 0; vertexData.SysMemSlicePitch = 0; // Now create the vertex buffer. result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer); if(FAILED(result)) { return false; } // Set up the description of the static index buffer. indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;

7 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount; indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; indexBufferDesc.CPUAccessFlags = 0; indexBufferDesc.MiscFlags = 0; indexBufferDesc.StructureByteStride = 0; // Give the subresource structure a pointer to the index data. indexData.pSysMem = indices; indexData.SysMemPitch = 0; indexData.SysMemSlicePitch = 0; // Create the index buffer. result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer); if(FAILED(result)) { return false; } // Release the arrays now that the vertex and index buffers have been created and loaded. delete [] vertices; vertices = 0; delete [] indices; indices = 0; return true; }

8 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

return; }

// If the position we are rendering this bitmap to has not changed then don't update the vertex buffer since it // currently has the correct parameters. if((positionX == m_previousPosX) && (positionY == m_previousPosY)) { return true; } // If it has changed then update the position it is being rendered to. m_previousPosX = positionX; m_previousPosY = positionY; // Calculate the screen coordinates of the left side of the bitmap. left = (float)((m_screenWidth / 2) * -1) + (float)positionX; // Calculate the screen coordinates of the right side of the bitmap. right = left + (float)m_bitmapWidth; // Calculate the screen coordinates of the top of the bitmap. top = (float)(m_screenHeight / 2) - (float)positionY; // Calculate the screen coordinates of the bottom of the bitmap. bottom = top - (float)m_bitmapHeight; // Create the vertex array. vertices = new VertexType[m_vertexCount]; if(!vertices) { return false; } // Load the vertex array with data. // First triangle.

Glowmap.vs
The purpose of the glow map shader is to render just the glow map portions of the color bitmap onto a render to texture so that it can be further processed (blurred). The code here for the HLSL glow map shader is just the texture shader HLSL code modified to handle glow map rendering. //////////////////////////////////////////////////////////////////////////////// // Filename: glowmap.vs ////////////////////////////////////////////////////////////////////////////////

12 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader //////////////////////////////////////////////////////////////////////////////// PixelInputType GlowMapVertexShader(VertexInputType input) { PixelInputType output;

13 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

output.tex = input.tex; return output; }

Glowmap.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: glowmap.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// Texture2D shaderTexture : register(t0); We add a texture resource for the glow map. Texture2D glowMapTexture : register(t1); SamplerState SampleType;

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

14 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

First sample both the bitmap texture and the glow map texture. // Sample the pixel color from the texture using the sampler at this texture coordinate location. textureColor = shaderTexture.Sample(SampleType, input.tex); // Sample the glow map. glowMap = glowMapTexture.Sample(SampleType, input.tex); Now return just the portions of the color texture that aligns with the white pixels in the glow map. In other words black is transparent, and anything else in the bitmap that isn't black gets drawn. // If the glow map is black then return just black. Otherwise if the glow map has color then return the color from the texture. if((glowMap.r == 0.0f) && (glowMap.g == 0.0f) && (glowMap.b == 0.0f)) { color = float4(0.0f, 0.0f, 0.0f, 1.0f); } else { color = textureColor; } return color; }

Glowmapshaderclass.h
The GlowMapShaderClass is just the TextureShaderClass modified to handle an extra texture (glow map). //////////////////////////////////////////////////////////////////////////////// // Filename: glowmapshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GLOWMAPSHADERCLASS_H_ #define _GLOWMAPSHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h>

15 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

#include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: GlowMapShaderClass //////////////////////////////////////////////////////////////////////////////// class GlowMapShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; public: GlowMapShaderClass(); GlowMapShaderClass(const GlowMapShaderClass&); ~GlowMapShaderClass(); bool Initialize(ID3D11Device*, HWND); void Shutdown(); bool Render(ID3D11DeviceContext*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*); private: bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*); void ShutdownShader(); void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*); bool SetShaderParameters(ID3D11DeviceContext*, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView* void RenderShader(ID3D11DeviceContext*, int); private: ID3D11VertexShader* m_vertexShader; ID3D11PixelShader* m_pixelShader; ID3D11InputLayout* m_layout; ID3D11Buffer* m_matrixBuffer; ID3D11SamplerState* m_sampleState; }; #endif

16 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

Glowmapshaderclass.cpp
//////////////////////////////////////////////////////////////////////////////// // Filename: glowmapshaderclass.cpp //////////////////////////////////////////////////////////////////////////////// #include "glowmapshaderclass.h"

GlowMapShaderClass::GlowMapShaderClass() { m_vertexShader = 0; m_pixelShader = 0; m_layout = 0; m_matrixBuffer = 0; m_sampleState = 0; }

GlowMapShaderClass::GlowMapShaderClass(const GlowMapShaderClass& other) { }

GlowMapShaderClass::~GlowMapShaderClass() { }

bool GlowMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd) { bool result;

// Initialize the vertex and pixel shaders. result = InitializeShader(device, hwnd, L"../Engine/glowmap.vs", L"../Engine/glowmap.ps"); if(!result) { return false; } return true; }

17 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

void GlowMapShaderClass::Shutdown() { // Shutdown the vertex and pixel shaders as well as the related objects. ShutdownShader(); return; }

bool GlowMapShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, ID3D11ShaderResourceView* glowMap) { bool result;

// Set the shader parameters that it will use for rendering. result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, glowMap); if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; }

http://www.rastertek.com/dx11tut46.html

// Setup the description of the dynamic matrix constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; samplerDesc.MipLODBias = 0.0f; samplerDesc.MaxAnisotropy = 1; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.BorderColor[0] = 0; samplerDesc.BorderColor[1] = 0; samplerDesc.BorderColor[2] = 0; samplerDesc.BorderColor[3] = 0; samplerDesc.MinLOD = 0; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; // Create the texture sampler state. result = device->CreateSamplerState(&samplerDesc, &m_sampleState); if(FAILED(result)) { return false; } return true; }

void GlowMapShaderClass::ShutdownShader() { // Release the sampler state. if(m_sampleState)

21 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

{ m_sampleState->Release(); m_sampleState = 0; } // Release the matrix constant buffer. if(m_matrixBuffer) { m_matrixBuffer->Release(); m_matrixBuffer = 0; } // Release the layout. if(m_layout) { m_layout->Release(); m_layout = 0; } // Release the pixel shader. if(m_pixelShader) { m_pixelShader->Release(); m_pixelShader = 0; } // Release the vertex shader. if(m_vertexShader) { m_vertexShader->Release(); m_vertexShader = 0; } return; }

void GlowMapShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename) { char* compileErrors; unsigned long bufferSize, i; ofstream fout;

// Get a pointer to the error message text buffer.

22 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

compileErrors = (char*)(errorMessage->GetBufferPointer()); // Get the length of the message. bufferSize = errorMessage->GetBufferSize(); // Open a file to write the error message to. fout.open("shader-error.txt"); // Write out the error message. for(i=0; i<bufferSize; i++) { fout << compileErrors[i]; } // Close the file. fout.close(); // Release the error message. errorMessage->Release(); errorMessage = 0; // Pop a message up on the screen to notify the user to check the text file for compile errors. MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK); return; }

bool GlowMapShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, ID3D11ShaderResourceView* glowMap) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber;

23 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

void GlowMapShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount) { // Set the vertex input layout. deviceContext->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. deviceContext->VSSetShader(m_vertexShader, NULL, 0); deviceContext->PSSetShader(m_pixelShader, NULL, 0); // Set the sampler state in the pixel shader. deviceContext->PSSetSamplers(0, 1, &m_sampleState); // Render the triangle. deviceContext->DrawIndexed(indexCount, 0, 0); return;

24 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

Glow.vs
The purpose of the glow shader is to combine the blurred glow map texture with the actual regular color rendering of the scene. The regular scene is rendered to the input colorTexture, and the glow (blurred glow map) part of the scene has been rendered to the input glowTexture. The shader then multiplies the glowTexture by the glowStrength value to increase the glow. After that it adds the glow texture with the color texture to get the final pixel result. //////////////////////////////////////////////////////////////////////////////// // Filename: glow.vs ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// cbuffer MatrixBuffer { matrix worldMatrix; matrix viewMatrix; matrix projectionMatrix; };

//////////////////////////////////////////////////////////////////////////////// // Vertex Shader

25 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

//////////////////////////////////////////////////////////////////////////////// PixelInputType GlowVertexShader(VertexInputType input) { PixelInputType output;

Glow.ps
//////////////////////////////////////////////////////////////////////////////// // Filename: glow.ps ////////////////////////////////////////////////////////////////////////////////

///////////// // GLOBALS // ///////////// The render to texture of the regular scene is sent into the shader as colorTexture. Texture2D colorTexture : register(t0); The blurred glow map render to texture is sent into the shader as glowTexture. Texture2D glowTexture : register(t1); SamplerState SampleType; The glowStrength variable in the GlowBuffer is for increasing the blurred glow map texture so that the glow has a stronger effect.

26 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

cbuffer GlowBuffer { float glowStrength; float3 padding; };

////////////// // TYPEDEFS // ////////////// struct PixelInputType { float4 position : SV_POSITION; float2 tex : TEXCOORD0; };

27 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

Glowshaderclass.h
The GlowShaderClass is just the TextureShaderClass modified to handle glow related variables. //////////////////////////////////////////////////////////////////////////////// // Filename: glowshaderclass.h //////////////////////////////////////////////////////////////////////////////// #ifndef _GLOWSHADERCLASS_H_ #define _GLOWSHADERCLASS_H_

////////////// // INCLUDES // ////////////// #include <d3d11.h> #include <d3dx10math.h> #include <d3dx11async.h> #include <fstream> using namespace std;

//////////////////////////////////////////////////////////////////////////////// // Class name: GlowShaderClass //////////////////////////////////////////////////////////////////////////////// class GlowShaderClass { private: struct MatrixBufferType { D3DXMATRIX world; D3DXMATRIX view; D3DXMATRIX projection; }; struct GlowBufferType { float glowStrength; D3DXVECTOR3 padding; }; public: GlowShaderClass(); GlowShaderClass(const GlowShaderClass&); ~GlowShaderClass();

http://www.rastertek.com/dx11tut46.html

if(!result) { return false; } // Now render the prepared buffers with the shader. RenderShader(deviceContext, indexCount); return true; }

bool GlowShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename) { HRESULT result; ID3D10Blob* errorMessage; ID3D10Blob* vertexShaderBuffer; ID3D10Blob* pixelShaderBuffer; D3D11_INPUT_ELEMENT_DESC polygonLayout[2]; unsigned int numElements; D3D11_BUFFER_DESC matrixBufferDesc; D3D11_BUFFER_DESC glowBufferDesc; D3D11_SAMPLER_DESC samplerDesc;

31 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

return false; } // Compile the pixel shader code. result = D3DX11CompileFromFile(psFilename, NULL, NULL, "GlowPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL); if(FAILED(result)) { // If the shader failed to compile it should have writen something to the error message. if(errorMessage) { OutputShaderErrorMessage(errorMessage, hwnd, psFilename); } // If there was nothing in the error message then it simply could not find the file itself. else { MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK); } return false; } // Create the vertex shader from the buffer. result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader); if(FAILED(result)) { return false; } // Create the pixel shader from the buffer. result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader); if(FAILED(result)) { return false; } // Create the vertex input layout description. polygonLayout[0].SemanticName = "POSITION"; polygonLayout[0].SemanticIndex = 0; polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT; polygonLayout[0].InputSlot = 0; polygonLayout[0].AlignedByteOffset = 0; polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[0].InstanceDataStepRate = 0;

32 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

polygonLayout[1].SemanticName = "TEXCOORD"; polygonLayout[1].SemanticIndex = 0; polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT; polygonLayout[1].InputSlot = 0; polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; polygonLayout[1].InstanceDataStepRate = 0; // Get a count of the elements in the layout. numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]); // Create the vertex input layout. result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout); if(FAILED(result)) { return false; } // Release the vertex shader buffer and pixel shader buffer since they are no longer needed. vertexShaderBuffer->Release(); vertexShaderBuffer = 0; pixelShaderBuffer->Release(); pixelShaderBuffer = 0; // Setup the description of the dynamic matrix constant buffer that is in the vertex shader. matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType); matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; matrixBufferDesc.MiscFlags = 0; matrixBufferDesc.StructureByteStride = 0; // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class. result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer); if(FAILED(result)) { return false; } // Setup the description of the dynamic glow constant buffer that is in the pixel shader. glowBufferDesc.Usage = D3D11_USAGE_DYNAMIC; glowBufferDesc.ByteWidth = sizeof(GlowBufferType);

// Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix);

36 of 59

http://www.rastertek.com/dx11tut46.html

bool RenderUIElementsToTexture(); bool RenderGlowScene(); private: D3DClass* m_D3D; CameraClass* m_Camera; TextureShaderClass* m_TextureShader; BitmapClass* m_Bitmap; RenderTextureClass *m_RenderTexture, *m_DownSampleTexure, *m_HorizontalBlurTexture, *m_VerticalBlurTexture, *m_UpSampleTexure; OrthoWindowClass *m_SmallWindow, *m_FullScreenWindow; HorizontalBlurShaderClass* m_HorizontalBlurShader; VerticalBlurShaderClass* m_VerticalBlurShader; GlowMapShaderClass* m_GlowMapShader; GlowShaderClass* m_GlowShader; }; #endif

GraphicsClass::GraphicsClass() { m_D3D = 0; m_Camera = 0; m_TextureShader = 0; m_Bitmap = 0; m_RenderTexture = 0; m_DownSampleTexure = 0; m_SmallWindow = 0; m_HorizontalBlurTexture = 0; m_HorizontalBlurShader = 0; m_VerticalBlurTexture = 0; m_VerticalBlurShader = 0; m_UpSampleTexure = 0; m_FullScreenWindow = 0; m_GlowMapShader = 0;

40 of 59

http://www.rastertek.com/dx11tut46.html

// Create the glow shader object. m_GlowShader = new GlowShaderClass; if(!m_GlowShader) { return false; } // Initialize the glow shader object. result = m_GlowShader->Initialize(m_D3D->GetDevice(), hwnd); if(!result) { MessageBox(hwnd, L"Could not initialize the glow shader object.", L"Error", MB_OK); return false; } return true; }

void GraphicsClass::Shutdown() { // Release the glow shader object. if(m_GlowShader) { m_GlowShader->Shutdown(); delete m_GlowShader; m_GlowShader = 0; } // Release the glow map shader object. if(m_GlowMapShader) { m_GlowMapShader->Shutdown(); delete m_GlowMapShader; m_GlowMapShader = 0; } // Release the full screen ortho window object. if(m_FullScreenWindow) { m_FullScreenWindow->Shutdown(); delete m_FullScreenWindow; m_FullScreenWindow = 0; }

46 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

// Release the up sample render to texture object. if(m_UpSampleTexure) { m_UpSampleTexure->Shutdown(); delete m_UpSampleTexure; m_UpSampleTexure = 0; } // Release the vertical blur shader object. if(m_VerticalBlurShader) { m_VerticalBlurShader->Shutdown(); delete m_VerticalBlurShader; m_VerticalBlurShader = 0; } // Release the vertical blur render to texture object. if(m_VerticalBlurTexture) { m_VerticalBlurTexture->Shutdown(); delete m_VerticalBlurTexture; m_VerticalBlurTexture = 0; } // Release the horizontal blur shader object. if(m_HorizontalBlurShader) { m_HorizontalBlurShader->Shutdown(); delete m_HorizontalBlurShader; m_HorizontalBlurShader = 0; } // Release the horizontal blur render to texture object. if(m_HorizontalBlurTexture) { m_HorizontalBlurTexture->Shutdown(); delete m_HorizontalBlurTexture; m_HorizontalBlurTexture = 0; } // Release the small ortho window object. if(m_SmallWindow) { m_SmallWindow->Shutdown(); delete m_SmallWindow;

47 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

m_SmallWindow = 0; } // Release the down sample render to texture object. if(m_DownSampleTexure) { m_DownSampleTexure->Shutdown(); delete m_DownSampleTexure; m_DownSampleTexure = 0; } // Release the render to texture object. if(m_RenderTexture) { m_RenderTexture->Shutdown(); delete m_RenderTexture; m_RenderTexture = 0; } // Release the bitmap object. if(m_Bitmap) { m_Bitmap->Shutdown(); delete m_Bitmap; m_Bitmap = 0; } // Release the texture shader object. if(m_TextureShader) { m_TextureShader->Shutdown(); delete m_TextureShader; m_TextureShader = 0; } // Release the camera object. if(m_Camera) { delete m_Camera; m_Camera = 0; } // Release the D3D object. if(m_D3D) {

48 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

m_D3D->Shutdown(); delete m_D3D; m_D3D = 0; } return; }

bool GraphicsClass::Frame() { bool result;

// Render the graphics scene. result = Render(); if(!result) { return false; } return true; } The Render function calls the different steps required to produce the glow. It is similar to the blur tutorial except that we start by rendering the glow map to a texture instead of the 3D scene. After that we do the blurring as normal. Once the blur is complete we render the UI elements to another render to texture and combine it with the blurred texture for the final result. bool GraphicsClass::Render() { bool result;

// First render the glow maps to a render texture. result = RenderGlowMapToTexture(); if(!result) { return false; } // Next down sample the render texture to a smaller sized texture. result = DownSampleTexture(); if(!result) { return false;

52 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

{ D3DXMATRIX worldMatrix, viewMatrix, orthoMatrix; float screenSizeX; bool result;

// Set the render target to be the render to texture. m_HorizontalBlurTexture->SetRenderTarget(m_D3D->GetDeviceContext()); // Clear the render to texture. m_HorizontalBlurTexture->ClearRenderTarget(m_D3D->GetDeviceContext(), 0.0f, 0.0f, 0.0f, 1.0f); // Generate the view matrix based on the camera's position. m_Camera->Render(); // Get the world and view matrices from the camera and d3d objects. m_Camera->GetViewMatrix(viewMatrix); m_D3D->GetWorldMatrix(worldMatrix); // Get the ortho matrix from the render to texture since texture has different dimensions. m_HorizontalBlurTexture->GetOrthoMatrix(orthoMatrix); // Turn off the Z buffer to begin all 2D rendering. m_D3D->TurnZBufferOff(); // Store the screen width in a float that will be used in the horizontal blur shader. screenSizeX = (float)m_HorizontalBlurTexture->GetTextureWidth(); // Put the small ortho window vertex and index buffers on the graphics pipeline to prepare them for drawing. m_SmallWindow->Render(m_D3D->GetDeviceContext()); // Render the small ortho window using the horizontal blur shader and the down sampled render to texture resource. result = m_HorizontalBlurShader->Render(m_D3D->GetDeviceContext(), m_SmallWindow->GetIndexCount(), worldMatrix, viewMatrix, orthoMatrix, m_DownSampleTexure->GetShaderResourceView(), screenSizeX); if(!result) { return false; } // Turn the Z buffer back on now that all 2D rendering has completed. m_D3D->TurnZBufferOn(); // Reset the render target back to the original back buffer and not the render to texture anymore. m_D3D->SetBackBufferRenderTarget();

53 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

// Reset the viewport back to the original. m_D3D->ResetViewport(); return true; }

bool GraphicsClass::RenderVerticalBlurToTexture() { D3DXMATRIX worldMatrix, viewMatrix, orthoMatrix; float screenSizeY; bool result;

// Set the render target to be the render to texture. m_VerticalBlurTexture->SetRenderTarget(m_D3D->GetDeviceContext()); // Clear the render to texture. m_VerticalBlurTexture->ClearRenderTarget(m_D3D->GetDeviceContext(), 0.0f, 0.0f, 0.0f, 1.0f); // Generate the view matrix based on the camera's position. m_Camera->Render(); // Get the world and view matrices from the camera and d3d objects. m_Camera->GetViewMatrix(viewMatrix); m_D3D->GetWorldMatrix(worldMatrix); // Get the ortho matrix from the render to texture since texture has different dimensions. m_VerticalBlurTexture->GetOrthoMatrix(orthoMatrix); // Turn off the Z buffer to begin all 2D rendering. m_D3D->TurnZBufferOff(); // Store the screen height in a float that will be used in the vertical blur shader. screenSizeY = (float)m_VerticalBlurTexture->GetTextureHeight(); // Put the small ortho window vertex and index buffers on the graphics pipeline to prepare them for drawing. m_SmallWindow->Render(m_D3D->GetDeviceContext()); // Render the small ortho window using the vertical blur shader and the horizontal blurred render to texture resource. result = m_VerticalBlurShader->Render(m_D3D->GetDeviceContext(), m_SmallWindow->GetIndexCount(), worldMatrix, viewMatrix, orthoMatrix, m_HorizontalBlurTexture->GetShaderResourceView(), screenSizeY); if(!result) { return false;

54 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

http://www.rastertek.com/dx11tut46.html

// Put the full screen ortho window vertex and index buffers on the graphics pipeline to prepare them for drawing. m_FullScreenWindow->Render(m_D3D->GetDeviceContext()); // Render the full screen ortho window using the texture shader and the full screen sized blurred render to texture resource. m_GlowShader->Render(m_D3D->GetDeviceContext(), m_FullScreenWindow->GetIndexCount(), worldMatrix, viewMatrix, orthoMatrix, m_RenderTexture->GetShaderResourceView(), m_UpSampleTexure->GetShaderResourceView(), 3.0f); // Turn the Z buffer back on now that all 2D rendering has completed. m_D3D->TurnZBufferOn(); // Present the rendered scene to the screen. m_D3D->EndScene(); return true; }

Summary
We can now apply selective glow to our scene using glow maps.

To Do Exercises
1. Compile and run the program. You should see a glow applied to the bitmap object. Press escape to quit. 2. Modify the glow strength to see the effect it has. 3. Create a different glow map to make only the text glow. 4. Add glow to a 3D scene (such as the spinning cube from the other tutorials). 5. Use an additional texture such as noise or a gradient and animate the glow by translating the noise or gradient texture and using it as intensity for the glow.

Source Code

58 of 59

3/8/2013 12:47 PM

Tutorial 46: Glow

http://www.rastertek.com/dx11tut46.html

Source Code and Data Files: dx11src46.zip Executable: dx11exe46.zip

Back to Tutorial Index

59 of 59

3/8/2013 12:47 PM

MidSem17 Soln
No ratings yet
MidSem17 Soln
10 pages
C# For Beginners: An Introduction to C# Programming with Tutorials and Hands-On Examples
From Everand
C# For Beginners: An Introduction to C# Programming with Tutorials and Hands-On Examples
Nathan Metzler
5/5 (1)
C# for Beginners: Learn in 24 Hours
From Everand
C# for Beginners: Learn in 24 Hours
Alex Nordeen
No ratings yet
Practical Ethical Hacking from Scratch
From Everand
Practical Ethical Hacking from Scratch
Ansh Goyal
4.5/5 (2)
Chenming Hu Ch1 Slides
No ratings yet
Chenming Hu Ch1 Slides
31 pages
Walkthrough: Create A Traditional Windows Desktop Application (C++)
No ratings yet
Walkthrough: Create A Traditional Windows Desktop Application (C++)
15 pages
Practical No - 1 Aim: To Setup Directx 11, Window Framework and Initialize Direct3D Device
No ratings yet
Practical No - 1 Aim: To Setup Directx 11, Window Framework and Initialize Direct3D Device
17 pages
Lesson 1 Introducing Windows Programming: Ivan Moisè
No ratings yet
Lesson 1 Introducing Windows Programming: Ivan Moisè
11 pages
Lesson List and Schedule: Visual C++/MFC Tutorial - Lesson 1: Behind The Scenes With Handles and Messages
100% (2)
Lesson List and Schedule: Visual C++/MFC Tutorial - Lesson 1: Behind The Scenes With Handles and Messages
41 pages
Win APITutorial
No ratings yet
Win APITutorial
20 pages
Introduction To Win32
No ratings yet
Introduction To Win32
21 pages
Subject: Cs1253-Visual Programming Year/Sem: Iii/Vi Unit - I
100% (1)
Subject: Cs1253-Visual Programming Year/Sem: Iii/Vi Unit - I
4 pages
Window Message Windows Procedure Painting Window Closing Window
No ratings yet
Window Message Windows Procedure Painting Window Closing Window
18 pages
Yashwant Kanitker - VC++, COM and Beyond
100% (3)
Yashwant Kanitker - VC++, COM and Beyond
20 pages
Fresher PyQt5: A Beginner’s Guide to PyQt5
From Everand
Fresher PyQt5: A Beginner’s Guide to PyQt5
Edward Chang
No ratings yet
Pyqt6 101: A Beginner’s Guide to PyQt6
From Everand
Pyqt6 101: A Beginner’s Guide to PyQt6
Edward Chang
No ratings yet
Some Tutorials in Computer Networking Hacking
From Everand
Some Tutorials in Computer Networking Hacking
Dr. Hidaia Mahmood Alassouli
No ratings yet
Introduction To Windows Concepts
No ratings yet
Introduction To Windows Concepts
61 pages
Windows Batch File Programming
From Everand
Windows Batch File Programming
Michael Elliott
2/5 (2)
Direct Show Tutorial
No ratings yet
Direct Show Tutorial
10 pages
Visual Basic 6.0 Programming By Examples: 7 Windows Application Examples
From Everand
Visual Basic 6.0 Programming By Examples: 7 Windows Application Examples
Sergey Skudaev
3/5 (2)
Writing Video Applications: Dr. Lisa Spencer Last Updated 6/23/06
No ratings yet
Writing Video Applications: Dr. Lisa Spencer Last Updated 6/23/06
89 pages
TetroGL - An OpenGL Game Tutorial in C++ For Win32 Platforms - Part 1 - CodeProject
No ratings yet
TetroGL - An OpenGL Game Tutorial in C++ For Win32 Platforms - Part 1 - CodeProject
20 pages
Johnnie's Win32 API Tutorial
0% (1)
Johnnie's Win32 API Tutorial
7 pages
OpenGL Programming With Windows MFC
No ratings yet
OpenGL Programming With Windows MFC
11 pages
CS1253 - Visual Programming
No ratings yet
CS1253 - Visual Programming
3 pages
AutoIT Scripting For Beginners
From Everand
AutoIT Scripting For Beginners
Rajan
5/5 (2)
Lucrarea de Laborator Nr. 2: Raport La
No ratings yet
Lucrarea de Laborator Nr. 2: Raport La
5 pages
Vpqpfinal
No ratings yet
Vpqpfinal
21 pages
Learn R By Coding
From Everand
Learn R By Coding
Thomas Kurnicki
No ratings yet
Lect2 - 2009 1 API MFC
No ratings yet
Lect2 - 2009 1 API MFC
22 pages
Get Started With Win32 and C++
No ratings yet
Get Started With Win32 and C++
148 pages
Win32 Programming
No ratings yet
Win32 Programming
90 pages
Inspiring Powershell Articles
From Everand
Inspiring Powershell Articles
Murat Yildirimoglu
No ratings yet
MFC Windows Programming (App/Window Approach)
No ratings yet
MFC Windows Programming (App/Window Approach)
6 pages
Visual Programming Qbank
100% (1)
Visual Programming Qbank
4 pages
Module 4: The Graphics Device Interface (GDI), Colors, and Fonts
No ratings yet
Module 4: The Graphics Device Interface (GDI), Colors, and Fonts
33 pages
The Mac Terminal Reference and Scripting Primer
From Everand
The Mac Terminal Reference and Scripting Primer
Jay Docherty
4.5/5 (3)
Introduction To Microsoft Windows MFC Programming The Application - Window Approach
100% (1)
Introduction To Microsoft Windows MFC Programming The Application - Window Approach
15 pages
52386a80aca05d24a6950fb4a2377bc1
No ratings yet
52386a80aca05d24a6950fb4a2377bc1
147 pages
6th Sem. CS 1305.-Visual Prog.
No ratings yet
6th Sem. CS 1305.-Visual Prog.
5 pages
Python Advanced Programming: The Guide to Learn Python Programming. Reference with Exercises and Samples About Dynamical Programming, Multithreading, Multiprocessing, Debugging, Testing and More
From Everand
Python Advanced Programming: The Guide to Learn Python Programming. Reference with Exercises and Samples About Dynamical Programming, Multithreading, Multiprocessing, Debugging, Testing and More
Marcus Richards
No ratings yet
05-Microsoft Foundation Classes
No ratings yet
05-Microsoft Foundation Classes
22 pages
Windows GDI Programming: CIS 487/587 Bruce R. Maxim UM-Dearborn
No ratings yet
Windows GDI Programming: CIS 487/587 Bruce R. Maxim UM-Dearborn
32 pages
VT Presentation
No ratings yet
VT Presentation
22 pages
Angular for Kids: Start Your Coding Adventure
From Everand
Angular for Kids: Start Your Coding Adventure
Abdelfattah Ragab
No ratings yet
Spring Boot Intermediate Microservices: Resilient Microservices with Spring Boot 2 and Spring Cloud
From Everand
Spring Boot Intermediate Microservices: Resilient Microservices with Spring Boot 2 and Spring Cloud
Jens Boje
No ratings yet
Win32 Winprog
100% (1)
Win32 Winprog
83 pages
C++ - Double Buffering in Direct2D - Stack Overflow
No ratings yet
C++ - Double Buffering in Direct2D - Stack Overflow
4 pages
Windows System Programming: CS462 - SA Notes Dr. Mohammed Ameen
No ratings yet
Windows System Programming: CS462 - SA Notes Dr. Mohammed Ameen
13 pages
Learn Java Programming in 24 Hours
From Everand
Learn Java Programming in 24 Hours
PublishDrive
No ratings yet
Project - Phase-1 Basic of Programming
No ratings yet
Project - Phase-1 Basic of Programming
2 pages
Unit II
No ratings yet
Unit II
57 pages
Introduction To MFC: Microsoft Foundation Classes
0% (1)
Introduction To MFC: Microsoft Foundation Classes
172 pages
Steps To Win32 Application
No ratings yet
Steps To Win32 Application
13 pages
06 Introduction To MFC
50% (2)
06 Introduction To MFC
172 pages
C++ Graphics For Windows Using Winbgim: Download and Install The Winbgim Devpak File "Winbgim-6.0-1G17L.Devpak"
No ratings yet
C++ Graphics For Windows Using Winbgim: Download and Install The Winbgim Devpak File "Winbgim-6.0-1G17L.Devpak"
7 pages
Umbraco User's Guide
From Everand
Umbraco User's Guide
Nik Wahlberg
4/5 (1)
Basics with Windows Powershell
From Everand
Basics with Windows Powershell
Prometheus MMS
No ratings yet
NoSQL Injection for Elasticsearch
From Everand
NoSQL Injection for Elasticsearch
Gary Drocella
No ratings yet
2 f05 Win32api
No ratings yet
2 f05 Win32api
9 pages
Software Design Simplified
From Everand
Software Design Simplified
Liviu Catalin Dorobantu
No ratings yet
Alignment of Non-Overlapping Images
No ratings yet
Alignment of Non-Overlapping Images
8 pages
Large-Scale and Drift-Free Surface Reconstruction Using Online Subvolume Registration
No ratings yet
Large-Scale and Drift-Free Surface Reconstruction Using Online Subvolume Registration
9 pages
Deblurring
No ratings yet
Deblurring
15 pages
Highlighting Parts of GUI Text - Unity Answers
No ratings yet
Highlighting Parts of GUI Text - Unity Answers
5 pages
Setting Up GLUT: CS 148 Autumn 2011-2012 September 24, 2012
No ratings yet
Setting Up GLUT: CS 148 Autumn 2011-2012 September 24, 2012
3 pages
Another Introduction To Ray Tracing
100% (1)
Another Introduction To Ray Tracing
308 pages
EE368 Project: Visual Code Marker Detection Through Geometric Feature Recognition
No ratings yet
EE368 Project: Visual Code Marker Detection Through Geometric Feature Recognition
9 pages
CH 1
No ratings yet
CH 1
34 pages
Experience Implementing An Elliptical Head Tracker in Matlab
No ratings yet
Experience Implementing An Elliptical Head Tracker in Matlab
7 pages
Lecture1 2up
No ratings yet
Lecture1 2up
11 pages
Programming Concepts and Embedded Programming in C and C++
No ratings yet
Programming Concepts and Embedded Programming in C and C++
55 pages
Documents PDF
No ratings yet
Documents PDF
975 pages
Assignment 1 Smart Homes
No ratings yet
Assignment 1 Smart Homes
3 pages
DC Convolution Codes
No ratings yet
DC Convolution Codes
136 pages
Understanding Machine Learning Theory Algorithms
No ratings yet
Understanding Machine Learning Theory Algorithms
449 pages
Introduction To Computers and Word
No ratings yet
Introduction To Computers and Word
175 pages
Quantization: Input-Output Characteristic of A Scalar Quantizer
No ratings yet
Quantization: Input-Output Characteristic of A Scalar Quantizer
34 pages
Lecture2 Photoshop
No ratings yet
Lecture2 Photoshop
26 pages
Java Guide
No ratings yet
Java Guide
102 pages
Sad 2
No ratings yet
Sad 2
7 pages
Developer Track 6 TrustZone TEEs and Trusted Video Path Implementation Considerations
No ratings yet
Developer Track 6 TrustZone TEEs and Trusted Video Path Implementation Considerations
31 pages
Dansguardian Web Content Filtering
No ratings yet
Dansguardian Web Content Filtering
9 pages
Receiving Transactions Data Collection Script
No ratings yet
Receiving Transactions Data Collection Script
2 pages
English
No ratings yet
English
6 pages
C Variables
No ratings yet
C Variables
5 pages
DE2 115 User Manual
No ratings yet
DE2 115 User Manual
122 pages
Polymorphism
No ratings yet
Polymorphism
19 pages
Data Communications Network
100% (1)
Data Communications Network
106 pages
Implementing Group Policy
100% (1)
Implementing Group Policy
50 pages
Ķeifer
No ratings yet
Ķeifer
2 pages
Sdfaf
No ratings yet
Sdfaf
8 pages
UT Dallas Syllabus For cs6366.501.09s Taught by Kang Zhang (Kzhang)
No ratings yet
UT Dallas Syllabus For cs6366.501.09s Taught by Kang Zhang (Kzhang)
1 page
ADSP-BF592: Blackfin Embedded Processor
No ratings yet
ADSP-BF592: Blackfin Embedded Processor
48 pages
Draytek Vigor 2925 User Guide
No ratings yet
Draytek Vigor 2925 User Guide
950 pages
Machine Vision Toolbox For MATLABr3
No ratings yet
Machine Vision Toolbox For MATLABr3
189 pages
Python Notes/Cheat Sheet: Operator Functionality
No ratings yet
Python Notes/Cheat Sheet: Operator Functionality
7 pages
Userguide v1.2
No ratings yet
Userguide v1.2
9 pages
C Malloc : C Dynamic Memory Allocation
No ratings yet
C Malloc : C Dynamic Memory Allocation
14 pages
Network Simulator
No ratings yet
Network Simulator
3 pages