void ShadowMapRenderer::setupVirtualLightCamera(Camera* camera, DirectionalLightNode* lightNode, int cascadeIndex)
{
const float BOUND_EXPAND_FACTOR = 0.8f;
_Assert(camera != NULL);
_Assert(cascadeIndex >= 0 && cascadeIndex < CASCADE_COUNTS);
DirectionalLight* dirLight = lightNode->GetDirLight();
Vector3 lightDir = dirLight->GetDirection();
lightDir.Normalize();
Vector3 frustumPos[5];
{
float farZ = 0;
float aspect = 0;
float fov = 0;
camera->GetCameraParams(NULL, &farZ, &fov, &aspect);
farZ *= calcCascadeDist(cascadeIndex);
float fy = farZ * tanf(fov / 2.0f);
float fx = aspect * fy;
frustumPos[0] = Vector3::Zero;
frustumPos[1] = Vector3(-fx, fy, farZ);
frustumPos[2] = Vector3( fx, fy, farZ);
frustumPos[3] = Vector3(-fx, -fy, farZ);
frustumPos[4] = Vector3( fx, -fy, farZ);
}
D3DXMATRIX matCameraViewInv;
D3DXMatrixInverse(&matCameraViewInv, 0, &camera->ViewMatrix());
D3DXMATRIX matLightView;
{
Vector3 lightPos = lightNode->GetWorldPosition();
D3DXMATRIX matRotTranspose, matTransInverse;
D3DXMatrixTranspose(&matRotTranspose, &(lightNode->GetWorldOrient().Matrix()));
D3DXMatrixTranslation(&matTransInverse, -lightPos.x, -lightPos.y, -lightPos.z);
matLightView = matTransInverse * matRotTranspose;
}
AABBox lightSpaceBound;
for(int i = 0; i < 5; ++i)
{
Vector3 posW = PosVecTransform(frustumPos[i], matCameraViewInv);
Vector3 posL = PosVecTransform(posW, matLightView);
lightSpaceBound = AABBox::CombinePoint(lightSpaceBound, posL);
}
float nearZ = 0.1f;
float farZ = 0;
float width = 0;
float height = 0;
{
Vector3 lookDir = camera->GetWorldForward();
lookDir.Normalize();
float adjustFactor = lookDir.Dot(lightDir); // lookDir与lightDir贴近时, 向后扩展virtualCamera范围
float expandDist = adjustFactor * BOUND_EXPAND_FACTOR * fabsf(lightSpaceBound.mMax.z - lightSpaceBound.mMin.z);
Vector3 centerL = lightSpaceBound.GetCenter();
D3DXMATRIX matLightViewInv;
D3DXMatrixInverse(&matLightViewInv, 0, &matLightView);
Vector3 centerW = PosVecTransform(centerL, matLightViewInv);
float lightDist = fabsf(lightSpaceBound.mMax.z - lightSpaceBound.mMin.z) / 2.0f;
width = fabsf(lightSpaceBound.mMax.x - lightSpaceBound.mMin.x);
height = fabsf(lightSpaceBound.mMax.y - lightSpaceBound.mMin.y);
farZ = 2.0f * lightDist + expandDist;
mVirtualCamera[cascadeIndex].pos = centerW - (lightDist + expandDist) * lightDir;
}
D3DXMATRIX matLightProj;
D3DXMatrixOrthoLH(&matLightProj, width, height, nearZ, farZ);
D3DXMATRIX matVirtualCameraView;
{
Vector3 virtualCameraPos = mVirtualCamera[cascadeIndex].pos;
D3DXMATRIX matRotTranspose, matTransInverse;
D3DXMatrixTranspose(&matRotTranspose, &(lightNode->GetWorldOrient().Matrix()));
D3DXMatrixTranslation(&matTransInverse, -virtualCameraPos.x, -virtualCameraPos.y, -virtualCameraPos.z);
matVirtualCameraView = matTransInverse * matRotTranspose;
mVirtualCamera[cascadeIndex].bound = AABBox::MatTransform(AABBox(Vector3(0, 0, farZ/2.0f), width, height, farZ),
InversedMatrix(matVirtualCameraView));
}
mVirtualCamera[cascadeIndex].matVP = matVirtualCameraView * matLightProj;
}
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen,
float screenDepth, float screenNear)
{
HRESULT result = E_FAIL;
// create DirectX graphics interface factory (need to generating other DXGI objects)
IDXGIFactory* factory = nullptr;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
return false;
// create adapter
IDXGIAdapter* adapter = nullptr;
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
return false;
// enumerate outputs
IDXGIOutput* adapterOutput = nullptr;
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
return false;
// get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format
unsigned numModes = 0;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED,
&numModes, NULL);
if (FAILED(result))
return false;
// create a list to hold all possible display modes
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
return false;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED,
&numModes, displayModeList);
if (FAILED(result))
return false;
// go through all displays modes and find the one, that matches the screen width and height
unsigned numerator = 0, denominator = 0;
for (int i = 0; i < numModes; ++i)
{
if (displayModeList[i].Width == (unsigned)screenWidth)
{
if (displayModeList[i].Height == (unsigned)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// get the adapter description
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
return false;
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // store in megabytes
// convert the name of videocard to a character array and store it
unsigned stringLength = 0;
int error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error)
return false;
// write video card data in text file
std::ofstream videocardFile;
videocardFile.open("VideoCardInfo.txt");
videocardFile << "Video Card: " << m_videoCardDescription << std::endl
<< "Video Card Memory: " << m_videoCardMemory << "Mb" << std::endl;
videocardFile.close();
// release the structures and interfaces used to get information
delete[] displayModeList;
displayModeList = nullptr;
adapterOutput->Release();
adapterOutput = nullptr;
adapter->Release();
adapter = nullptr;
factory->Release();
factory = nullptr;
// initialize the swap chain description
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if (m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hwnd;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen)
swapChainDesc.Windowed = false;
else
swapChainDesc.Windowed = true;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
// create the swap chain, Direct3D device and Direct3D device context
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel,
1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result))
return false;
// get the pointer to the back buffer
ID3D11Texture2D* backBufferPtr = nullptr;
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
return false;
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if (FAILED(result))
return false;
backBufferPtr->Release();
backBufferPtr = nullptr;
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
return false;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// stencil operations if pixel is front-facing
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// stencil operations if pixel is back-facing
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(result))
return false;
// set the depth stencil state
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// initialize the depth stencil view
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
return false;
// bind the render target view and depth stencil buffer to the output render pipeline
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// setup the raster description which will determine how and what polygons will be drawn
D3D11_RASTERIZER_DESC rasterDesc;
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result))
return false;
m_deviceContext->RSSetState(m_rasterState);
// setup the viewport for rendering
D3D11_VIEWPORT viewport;
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
m_deviceContext->RSSetViewports(1, &viewport);
// setup the projection matrix
float fieldOfView = (float)D3DX_PI / 4.0f;
float screenAspect = (float)screenWidth / (float)screenHeight;
// create the projection matrix for 3D rendering
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// initialize the world matrix
D3DXMatrixIdentity(&m_worldMatrix);
// create an orthographic matrix for 2D rendering
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
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;
ID3D10Texture2D* backBufferPtr;
D3D10_TEXTURE2D_DESC depthBufferDesc;
D3D10_DEPTH_STENCIL_DESC depthStencilDesc;
D3D10_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D10_VIEWPORT viewport;
float fieldOfView, screenAspect;
D3D10_RASTERIZER_DESC rasterDesc;
// Store the vsync setting.
m_vsync_enabled = vsync;
// Create a DirectX graphics interface factory.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
{
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if(FAILED(result))
{
return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
{
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if(FAILED(result))
{
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
{
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
{
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for(i=0; i<numModes; i++)
{
if(displayModeList[i].Width == (unsigned int)screenWidth)
{
if(displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get the adapter (video card) description.
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
{
return false;
}
// Store the dedicated video card memory in megabytes.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
return false;
}
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// Set the refresh rate of the back buffer.
if(m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if(fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Create the swap chain and the Direct3D device.
result = D3D10CreateDeviceAndSwapChain(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION,
&swapChainDesc, &m_swapChain, &m_device);
if(FAILED(result))
{
return false;
}
// Get the pointer to the back buffer.
result = m_swapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&backBufferPtr);
if(FAILED(result))
{
return false;
}
// Create the render target view with the back buffer pointer.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if(FAILED(result))
{
return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D10_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
{
return false;
}
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D10_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
// Create the depth stencil state.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
{
return false;
}
// Set the depth stencil state on the D3D device.
m_device->OMSetDepthStencilState(m_depthStencilState, 1);
// Initialize the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
{
return false;
}
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_device->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D10_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D10_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
{
return false;
}
// Now set the rasterizer state.
m_device->RSSetState(m_rasterState);
// Setup the viewport for rendering.
viewport.Width = screenWidth;
viewport.Height = screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
// Create the viewport.
m_device->RSSetViewports(1, &viewport);
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&m_worldMatrix);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
void CCamera::SetOrthoProjParams( float w, float h, float fNear, float fFar )
{
D3DXMatrixOrthoLH( &m_ProjTrans, w, h, fNear, fFar );
}
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;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
_vsync_enabled = vsync;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
for (i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth)
{
if (displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
error = wcstombs_s(&stringLength, _videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
delete[] displayModeList;
displayModeList = NULL;
adapterOutput->Release();
adapterOutput = NULL;
adapter->Release();
adapter = NULL;
factory->Release();
factory = NULL;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if (_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hWnd;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
featureLevel = D3D_FEATURE_LEVEL_11_0;
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &_swapChain, &_device, NULL, &_deviceContext);
if (FAILED(result))
{
return false;
}
result = _swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
{
return false;
}
result = _device->CreateRenderTargetView(backBufferPtr, NULL, &_renderTargetView);
if (FAILED(result))
{
return false;
}
backBufferPtr->Release();
backBufferPtr = NULL;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
result = _device->CreateTexture2D(&depthBufferDesc, NULL, &_depthStencilBuffer);
if (FAILED(result))
{
return false;
}
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
result = _device->CreateDepthStencilState(&depthStencilDesc, &_depthStencilState);
if (FAILED(result))
{
return false;
}
_deviceContext->OMSetDepthStencilState(_depthStencilState, 1);
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
result = _device->CreateDepthStencilView(_depthStencilBuffer, &depthStencilViewDesc, &_depthStencilView);
if (FAILED(result))
{
return false;
}
_deviceContext->OMSetRenderTargets(1, &_renderTargetView, _depthStencilView);
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
result = _device->CreateRasterizerState(&rasterDesc, &_rasterState);
if (FAILED(result))
{
return false;
}
_deviceContext->RSSetState(_rasterState);
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
_deviceContext->RSSetViewports(1, &viewport);
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
D3DXMatrixPerspectiveFovLH(&_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
D3DXMatrixIdentity(&_worldMatrix);
D3DXMatrixOrthoLH(&_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
// This is the function used to render a single frame
void RenderFrame( void )
{
CBUFFER cBuffer;
cBuffer.LightVector = D3DXVECTOR4( 1.0f, 1.0f, 1.0f, 0.0f );
cBuffer.LightColor = D3DXCOLOR( 0.5f, 0.5f, 0.5f, 1.0f );
cBuffer.AmbientColor = D3DXCOLOR( 0.2f, 0.2f, 0.2f, 1.0f );
D3DXMATRIX matRotateY, matRotateZ, matView, matProjection, matOrtho, matScale, matTranslate[2];
D3DXMATRIX matFinal;
static float Time = 0.0f;
//Time += 0.0003f;
//Time = 9.5f;
Time = 0;
D3DXMatrixTranslation( &matTranslate[0], moveX, moveY, moveZ );
D3DXMatrixScaling( &matScale, 120.0, 120.0, 0.0f );
// Create a world matrices
D3DXMatrixRotationY( &matRotateY, Time );
D3DXMatrixRotationZ( &matRotateZ, -1.58f );
// Create a view matrix
D3DXMatrixLookAtLH( &matView,
&D3DXVECTOR3( 0.0f, 3.0f, 5.0f ), // The camera position
&D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), // The look-at position
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f )); // The up direction
// Create a projection matrix
D3DXMatrixPerspectiveFovLH( &matProjection,
( FLOAT )D3DXToRadian( 45 ), // Field of view
( FLOAT )SCREEN_WIDTH / ( FLOAT )SCREEN_HEIGHT, // Aspect ratio
1.0f, // Near view-plane
100.0f ); // Far view-plane
// Create an orthographic matrix
D3DXMatrixOrthoLH(
&matOrtho,
( FLOAT )SCREEN_WIDTH, // Set the width to the window's width
( FLOAT )SCREEN_HEIGHT, // Set the height to the window's height
1.0f, // The closest an object can be on the depth buffer is 0.0
100.0f ); // The farthest an object can be on the depth buffer is 1.0
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
// Clear the second depth stencil state before setting the parameters.
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
// Now create a second depth stencil state which turns off the Z buffer for 2D rendering. The only difference is
// that DepthEnable is set to false, all other parameters are the same as the other depth stencil state.
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Load the matrices into the constant buffer
// cBuffer.Final = matScale * matTranslate[0] * matRotateY * matRotateZ * matView * matOrtho;//matProjection;
// cBuffer.Rotation = matRotateY;
cBuffer.Final = matTranslate[0] * matScale * matRotateY * matRotateZ * matView * matOrtho;//matProjection;
cBuffer.Rotation = matRotateY * matRotateZ;
// Set the various states
devcon->RSSetState( pRS );
devcon->PSSetSamplers( 0, 1, &pSS );
devcon->OMSetBlendState( pBS, 0, 0xffffffff );
// Clear the back buffer to a deep blue
devcon->ClearRenderTargetView( backbuffer, D3DXCOLOR( 0.0f,0.0f,0.0f,1.0f));//0.0f, 0.2f, 0.4f, 1.0f ));
// Clear the depth buffer
devcon->ClearDepthStencilView( zbuffer, D3D11_CLEAR_DEPTH, 1.0f, 0 );
// Select which vertex buffer to display
UINT stride = sizeof( VERTEX );
UINT offset = 0;
devcon->IASetVertexBuffers( 0, 1, &pVBuffer, &stride, &offset );
devcon->IASetIndexBuffer( pIBuffer, DXGI_FORMAT_R32_UINT, 0 );
// Select which primtive type we are using
devcon->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
// Draw Our sprites here
// Draw the Paddle
devcon->UpdateSubresource( pCBuffer, 0, 0, &cBuffer, 0, 0 );
devcon->PSSetShaderResources( 0, 1, &pTexture[0] );
devcon->DrawIndexed( 6, 0, 0 );
devcon->UpdateSubresource( pCBuffer, 0, 0, &cBuffer, 0, 0 );
devcon->PSSetShaderResources( 0, 1, &pTexture[1] );
devcon->DrawIndexed( 6, 0, 0 );
// Switch the back buffer and the front buffer
swapchain->Present( 0, 0 );
}
HRESULT APPLICATION::Render()
{
//Setup the viewport
D3DVIEWPORT9 v, v2;
v.Width = 800;
v.Height = 600;
v.X = 0;
v.Y = 0;
v.MaxZ = 1.0f;
v.MinZ = 0.0f;
m_pDevice->SetViewport(&v);
v2 = v;
// Clear the viewport
m_pDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff4444ff, 1.0f, 0L );
// Begin the scene
if(SUCCEEDED(m_pDevice->BeginScene()))
{
//Render big city
m_city.Render(&m_camera);
RECT r[] = {{10, 10, 0, 0}, {10, 30, 0, 0}, {10, 50, 0, 0}};
m_pFont->DrawText(NULL, "Mouse Wheel: Change Camera Radius", -1, &r[0], DT_LEFT| DT_TOP | DT_NOCLIP, 0xff000000);
m_pFont->DrawText(NULL, "Arrows: Change Camera Angle", -1, &r[1], DT_LEFT| DT_TOP | DT_NOCLIP, 0xff000000);
//Render city overview, set viewport
v.X = 550;
v.Y = 20;
v.Width = 230;
v.Height = 230;
m_pDevice->SetViewport(&v);
m_pDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0L );
//Setup camera view to orthogonal view looking down on city
D3DXMATRIX viewTop, projectionTop;
D3DXMatrixLookAtLH(&viewTop, &(m_city.GetCenter() + D3DXVECTOR3(0.0f, 100.0f, 0.0f)), &m_city.GetCenter(), &D3DXVECTOR3(0,0,1));
D3DXMatrixOrthoLH(&projectionTop, m_city.m_size.x * TILE_SIZE, m_city.m_size.y * TILE_SIZE, 0.1f, 1000.0f);
m_pDevice->SetTransform(D3DTS_VIEW, &viewTop);
m_pDevice->SetTransform(D3DTS_PROJECTION, &projectionTop);
//Draw city blocks that are in view
m_city.Render(NULL);
//Restore viewport
m_pDevice->SetViewport(&v2);
//Draw line around smaller window
D3DXVECTOR2 outline[] = {D3DXVECTOR2(550, 20), D3DXVECTOR2(779, 20), D3DXVECTOR2(779, 249), D3DXVECTOR2(550, 249), D3DXVECTOR2(550, 20)};
m_pLine->SetWidth(3.0f);
m_pLine->Begin();
m_pLine->Draw(outline, 5, 0xff000000);
m_pLine->End();
//Draw mouse
m_mouse.Paint();
// End the scene.
m_pDevice->EndScene();
m_pDevice->Present(0, 0, 0, 0);
}
return S_OK;
}
void MyGame3DDevice::InitSceneEffectShader()
{
// load shader
HRSRC hResource = ::FindResource( NULL, MAKEINTRESOURCE(IDR_PIXEL_SHADER2), RT_RCDATA );
HGLOBAL hResourceData = ::LoadResource( NULL, hResource );
LPVOID pData = ::LockResource( hResourceData );
ID3DXBuffer* errorBuffer = 0;
HR( D3DXCreateEffect( pD3D9InstanceDevice,
pData,
::SizeofResource( NULL, hResource ),
0,
0,
0,
0,
&mFX,
&errorBuffer ) );
if( errorBuffer )
{
MyGameMessage( (char*)errorBuffer->GetBufferPointer() );
errorBuffer->Release();
return;
}
//initialize matrix in shader
D3DXMATRIX worldMatrix;
D3DXMatrixTranslation( &worldMatrix, -512.0f, -384.0f, 0 );
D3DXVECTOR3 position( 0.0f, 0.0f, 20.0f );
D3DXVECTOR3 targetPoint( 0.0f, 0.0f ,0.0f );
D3DXVECTOR3 upVector( 0.0f, -1.0f, 0.0f );
D3DXMATRIX viewMatrix;
D3DXMatrixLookAtLH( &viewMatrix, &position, &targetPoint, &upVector );
D3DXMATRIX projMatrix;
D3DXMatrixOrthoLH( &projMatrix, 1024.0f, 768.0f, -1009.0f, 5000.0f );
D3DXMatrixTranslation( &uiMoveMatrix, 0.0f, 0.0f, 0 );
mhUIWorldMatHandle = mFX->GetParameterByName( 0, worldMatName );
mhUIViewMatHandle = mFX->GetParameterByName( 0, viewMatName );
mhUIProjMatHandle = mFX->GetParameterByName( 0, projMatName );
mhUIMoveMatHandle = mFX->GetParameterByName( 0, moveMatName );
mhAlphaEnabled = mFX->GetParameterByName( 0, "alphaEnable" );
D3DXHANDLE mhTech = mFX->GetTechniqueByName( techniqueName );
mhTex = mFX->GetParameterByName( 0, "gTex" );
mFX->SetMatrix( mhUIWorldMatHandle, &worldMatrix );
mFX->SetMatrix( mhUIViewMatHandle, &viewMatrix );
mFX->SetMatrix( mhUIProjMatHandle, &projMatrix );
mFX->SetMatrix( mhUIMoveMatHandle, &uiMoveMatrix );
mFX->SetTechnique( mhTech );
HR(mFX->SetBool( mhAlphaEnabled, FALSE ));
return;
}
bool D3Dgraphics::Initialize(int x, int y, 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_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
D3D11_BLEND_DESC blendStateDescription;
//store vsync
m_vsync_enabled = vsync;
//get computer specs (refresh rate, vid card etc)
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
{
textDump("failed to create a dxgi factory");
return false;
}
// Use the factory to create an adapter for the primary graphics interface (video card).
result = factory->EnumAdapters(0, &adapter);
if(FAILED(result))
{
textDump("failed to create an adapter for the primary graphics card");
return false;
}
// Enumerate the primary adapter output (monitor).
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
{
textDump("failed to find the monitor");
return false;
}
// Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if(FAILED(result))
{
textDump("failed to get the number of display modes");
return false;
}
// Create a list to hold all the possible display modes for this monitor/video card combination.
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
{
textDump("failed to create the array of display modes");
return false;
}
// Now fill the display mode list structures.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
{
textDump("failed to fill the display modes list structure");
return false;
}
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the numerator and denominator of the refresh rate for that monitor.
for(i=0; i<numModes; i++)
{
if(displayModeList[i].Width == (unsigned int) x)
{
if(displayModeList[i].Height == (unsigned int) y)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
//get card name and memory
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
{
textDump("failed to get the card name and memory");
return false;
}
// Store the dedicated video card memory in megabytes.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// Convert the name of the video card to a character array and store it.
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
{
textDump("failed to write the name of the video card");
return false;
}
//release info used to get above
// Release the display mode list.
delete [] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
//START INITIALIZATION
// Initialize the swap chain description.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// Set to a single back buffer.
swapChainDesc.BufferCount = 1;
// Set the width and height of the back buffer.
swapChainDesc.BufferDesc.Width = x;
swapChainDesc.BufferDesc.Height = y;
// Set regular 32-bit surface for the back buffer.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
//set refresh rate of backbuffer depending on vsync
if(m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// Set the usage of the back buffer.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// Set the handle for the window to render to.
swapChainDesc.OutputWindow = hwnd;
// Turn multisampling off.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// Set to full screen or windowed mode.
if(fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
// Set the scan line ordering and scaling to unspecified.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// Discard the back buffer contents after presenting.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// Don't set the advanced flags.
swapChainDesc.Flags = 0;
// Set the feature level to DirectX 11.
//changed to 10.0 make things more compatible
//featureLevel = D3D_FEATURE_LEVEL_11_0;
featureLevel = D3D_FEATURE_LEVEL_10_0;
// Create the swap chain, Direct3D device, and Direct3D device context.
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if(FAILED(result))
{
textDump("failed to create a swap chain and d3d device");
return false;
}
// Get the pointer to the back buffer.
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if(FAILED(result))
{
textDump("failed to get the back buffer");
return false;
}
// Create the render target view with the back buffer pointer.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if(FAILED(result))
{
textDump("failed to create the render target to the back buffer");
return false;
}
// Release pointer to the back buffer as we no longer need it.
backBufferPtr->Release();
backBufferPtr = 0;
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = x;
depthBufferDesc.Height = y;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
{
textDump("failed to create the texture for the depth buffer");
return false;
}
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the depth stencil state.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
{
textDump("failed to create the depth stencil state");
return false;
}
// Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// Initailze the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
{
textDump("failed to create a depth stencil view");
return false;
}
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
{
textDump("failed to create the rasterizer state");
return false;
}
// Now set the rasterizer state.
m_deviceContext->RSSetState(m_rasterState);
// Setup a raster description which turns off back face culling.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_NONE;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the no culling rasterizer state.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterStateNoCulling);
if(FAILED(result))
{
textDump("failed to create no back face rasterizer state");
return false;
}
// Setup a raster description which turns off front face culling.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = true; //switches back and front faces
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the no culling rasterizer state.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterStateFrontFaceCulling);
if(FAILED(result))
{
textDump("failed to create no front face rasterizer state");
return false;
}
// Setup the viewport for rendering.
viewport.Width = (float) x;
viewport.Height = (float) y;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float) x / (float) y;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&m_worldMatrix);
//view matrix in camera class
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&m_orthoMatrix, (float) x, (float) y, screenNear, screenDepth);
//setup description for 2d drawing depth stencil
// Clear the second depth stencil state before setting the parameters.
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
// Now create a second depth stencil state which turns off the Z buffer for 2D rendering. The only difference is
// that DepthEnable is set to false, all other parameters are the same as the other depth stencil state.
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the state using the device.
result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_depthDisabledStencilState);
if(FAILED(result))
{
textDump("failed to create a depth stencil state");
return false;
}
//create blend state description
// Clear the blend state description.
ZeroMemory(&blendStateDescription, sizeof(D3D11_BLEND_DESC));
// Create an alpha enabled blend state description.
blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;;
blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO;
blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 0x0f;
// Create the blend state using the description.
result = m_device->CreateBlendState(&blendStateDescription, &m_alphaEnableBlendingState);
if(FAILED(result))
{
textDump("failed to create a blend state");
return false;
}
// Modify the description to create an alpha disabled blend state description.
blendStateDescription.RenderTarget[0].BlendEnable = FALSE;
// Create the blend state using the description.
result = m_device->CreateBlendState(&blendStateDescription, &m_alphaDisableBlendingState);
if(FAILED(result))
{
textDump("failed to allow alpha blending in the blend state");
return false;
}
return true;
}
bool Renderer::initialize(int width, int height, HWND hwnd, float zNear, float zFar, int numToDraw, char* msg)
{
numDrawables = numToDraw;
drawables = new Drawable*[numToDraw];
d3dObject = Direct3DCreate9(D3D_SDK_VERSION);
D3DCAPS9 caps;
d3dObject->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
if (!(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT))
{
LPCTSTR descr = "This program requires a video card that supports hardware vertex processing!";
strcpy_s((char*) msg, 128, descr);
return false;
}
D3DPRESENT_PARAMETERS params;
ZeroMemory(¶ms,sizeof(D3DPRESENT_PARAMETERS));
params.Windowed = TRUE;
params.BackBufferCount= 1;
params.BackBufferFormat = D3DFMT_X8R8G8B8;
params.BackBufferWidth = width;
params.BackBufferHeight = height;
params.MultiSampleType=D3DMULTISAMPLE_NONE;
params.SwapEffect = D3DSWAPEFFECT_DISCARD;
params.hDeviceWindow = hwnd;
params.EnableAutoDepthStencil = TRUE;
// VSYNC. Change to INTERVAL_IMMEDIATE to turn off VSYNC, change to INTERVAL_ONE to turn on VSYNC
params.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
// Now need to set up the depth stencil format.
D3DFORMAT formats[] = { D3DFMT_D32, D3DFMT_D24X8, D3DFMT_D16 };
D3DFORMAT format = (D3DFORMAT) 0;
for (int i = 0; i < 3; i++)
{
HRESULT result = d3dObject->CheckDeviceFormat(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_DEPTHSTENCIL,
D3DRTYPE_SURFACE, formats[i]);
if (result == D3D_OK)
{
result = d3dObject->CheckDepthStencilMatch(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, formats[i]);
if (result == D3D_OK)
{
format = formats[i];
break;
}
}
}
if (format == (D3DFORMAT) 0)
{
LPCTSTR descr = "Couldn't find a suitable depth format!";
strcpy_s((char*) msg, 128, descr);
return false;
}
params.AutoDepthStencilFormat = format;
HRESULT result = d3dObject->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING, ¶ms, &device);
if (FAILED(result))
{
LPCTSTR descr = DXGetErrorDescription(result);
strcpy_s((char*) msg, 128, descr);
return false;
}
device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
device->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
D3DVIEWPORT9 viewport;
viewport.Width = width;
viewport.Height = height;
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
viewport.X = 0;
viewport.Y = 0;
device->SetViewport(&viewport);
float fieldOfView, screenAspect;
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)width / (float)height;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&projectionMatrix, fieldOfView, screenAspect, zNear, zFar);
D3DXMatrixIdentity(&worldMatrix);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&orthoMatrix, (float)width, (float)height, zNear, zFar);
camera = new Camera;
device->SetRenderState(D3DRS_LIGHTING, TRUE);
device->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(100, 100, 100));
D3DLIGHT9 light; // create the light struct
D3DMATERIAL9 material; // create the material struct
ZeroMemory(&light, sizeof(light)); // clear out the light struct for use
light.Type = D3DLIGHT_DIRECTIONAL; // make the light type 'directional light'
light.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f); // set the light's color
light.Direction = D3DXVECTOR3(1.0f, -0.5f, 1.0f);
device->SetLight(0, &light); // send the light struct properties to light #0
device->LightEnable(0, TRUE); // turn on light #0
ZeroMemory(&material, sizeof(D3DMATERIAL9));
material.Diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
material.Ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
device->SetMaterial(&material); // set the globably-used material to &material
// Set up font stuff
D3DXCreateFont(device, 0, 10, FW_NORMAL, 1, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DRAFT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, "", &font);
device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTOP_SELECTARG1);
device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE); // Just to be safe (ignored)
return true;
}
void D3D11::init( int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear )
{
m_vsyncEnabled = vsync;
m_isWindows = fullscreen;
IDXGIFactory * pfactory;
if(FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory),(void**)&pfactory)))
return;
IDXGIAdapter * pAdapter;
if(FAILED(pfactory->EnumAdapters(0,&pAdapter)))
return;
IDXGIOutput * out;
if(FAILED(pAdapter->EnumOutputs(0,&out)))
return;
int numModes;
DXGI_MODE_DESC * displaymodeList;
if(FAILED(out->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,DXGI_ENUM_MODES_INTERLACED,&numModes,NULL)))
return;
displaymodeList = new DXGI_MODE_DESC[numModes];
if(FAILED(out->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,DXGI_ENUM_MODES_INTERLACED,&numModes,displaymodeList)))
return;
int numerator,denomerator;
for(int i = 0; i < numModes; ++i)
{
if(displaymodeList[i].Height == screenHeight && displaymodeList[i].Width == screenWidth)
{
numerator = displaymodeList[i].RefreshRate.Numerator;
denomerator = displaymodeList[i].RefreshRate.Denominator;
}
}
DXGI_ADAPTER_DESC desc;
if(FAILED(pAdapter->GetDesc(&desc)))
return;
int length;
m_videoCardMemory = static_cast<int>(desc.DedicatedVideoMemory/1024/1024);
wcstombs_s(&length,m_videoCardDescription,128,desc.Description,128);
delete[] displaymodeList;
displaymodeList = NULL;
out->Release();
out = NULL;
pAdapter->Release();
pAdapter = NULL;
pfactory->Release();
pfactory = NULL;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc,sizeof(DXGI_SWAP_CHAIN_DESC));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if(m_vsyncEnabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denomerator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
}
swapChainDesc.Windowed = m_isWindows;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
D3D_FEATURE_LEVEL level = D3D_FEATURE_LEVEL_11_0;
if(FAILED(D3D11CreateDeviceAndSwapChain(NULL,D3D_DRIVER_TYPE_HARDWARE,NULL,0,
&level,1,D3D11_SDK_VERSION,&swapChainDesc,&m_swapChain,&m_device,NULL,&m_deviceContext)))
return;
ID3D11Texture2D *backbufferTex;
if(FAILED(m_swapChain->GetBuffer(0,__uuidof(ID3D11Texture2D),(LPVOID*)&backbufferTex)))
return;
if(FAILED(m_device->CreateRenderTargetView(backbufferTex,NULL,&m_renderView)))
return;
backbufferTex->Release();
backbufferTex = 0;
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
if(FAILED(m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer)))
return ;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the depth stencil state.
if(FAILED(m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState)))
return;
// Set the depth stencil state.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
// Initialize the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
if(FAILED(m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView)))
return ;
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderView, m_depthStencilView);
D3D11_RASTERIZER_DESC rasterDesc;
// Setup the raster description which will determine how and what polygons will be drawn.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// Create the rasterizer state from the description we just filled out.
if(FAILED(m_device->CreateRasterizerState(&rasterDesc, &m_rasterState)))
return ;
// Now set the rasterizer state.
m_deviceContext->RSSetState(m_rasterState);
D3D11_VIEWPORT viewport;
// Setup the viewport for rendering.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
float fieldOfView, screenAspect;
// Setup the projection matrix.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// Create the projection matrix for 3D rendering.
D3DXMatrixPerspectiveFovLH(&m_projMat, fieldOfView, screenAspect, screenNear, screenDepth);
// Initialize the world matrix to the identity matrix.
D3DXMatrixIdentity(&m_worldMat);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&m_orthoMat, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
}
void Camera::SetOrthogonalMatrix(float width, float height, float nearPlane, float farPlane)
{
D3DXMatrixOrthoLH(&this->orthogonalMatrix, width, height, nearPlane, farPlane);
}
bool CScreen::SetDefaultGraphicsSettings2D()
{
HRESULT hr;
CGraphicsManager *pGraphicsManager = CGraphicsManager::GetInstance();
IDirect3DDevice9 *pDevice = pGraphicsManager->GetDevice();
D3DXMATRIX identityTransform, projTransform;
D3DXMatrixIdentity(&identityTransform);
D3DXMatrixOrthoLH(&projTransform, 100.0f * pGraphicsManager->GetAspectRatio(), 100.0f, -1.0f, 1.0f);
hr = pDevice->SetTransform(D3DTS_WORLD, &identityTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set world transform", hr);
return false;
}
hr = pDevice->SetTransform(D3DTS_VIEW, &identityTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set view transform", hr);
return false;
}
hr = pDevice->SetTransform(D3DTS_PROJECTION, &projTransform);
if(FAILED(hr))
{
LogErrorHr("Failed to set projection transform", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
if(FAILED(hr))
{
LogErrorHr("Failed to set cull mode render state", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to enable z", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to set z write enabled", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
if(FAILED(hr))
{
LogErrorHr("Failed to set lighting to false", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
if(FAILED(hr))
{
LogErrorHr("Failed to set alpha blending to true", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
if(FAILED(hr))
{
LogErrorHr("Failed to set alpha source render state", hr);
return false;
}
hr = pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
if(FAILED(hr))
{
LogErrorHr("Failed to set alpha dest render state", hr);
return false;
}
return true;
}
bool Direct3D::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
HRESULT result;
//Store the vsync setting
this->m_vsync_enabled = vsync;
//Create a DirectX graphics interface factory
IDXGIFactory* factory;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
//Use the factory to create an adapter for the primary graphics interface (video card)
IDXGIAdapter* adapter;
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
//Enumerate the primary adapter output (monitor)
IDXGIOutput* adapterOutput;
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
//Get the number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output(monitor)
UINT numModes;
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, nullptr);
if (FAILED(result))
{
return false;
}
//Create a list to hold all the possible display modes for this monitor/video card combination
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
//Now fill the display mode list structures
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
//Now go through all the display modes and find the one that matches the screen width and height
//When a match is found, store the numerator and denominator of the refresh rate for that monitor
UINT numerator;
UINT denominator;
for (UINT i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth)
{
if (displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
//Get the adapter (video card) description
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
//Store the dedicated video card memory in megabytes
this->m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//Convert the name of the video card to a character array and store it
UINT stringLength;
int error;
error = wcstombs_s(&stringLength, this->m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
//Release the display mode list
delete[] displayModeList;
displayModeList = nullptr;
//Release the adapter output
adapterOutput->Release();
adapterOutput = nullptr;
//Release the adapter
adapter->Release();
adapter = nullptr;
//Release the factory
factory->Release();
factory = nullptr;
// Create and Initialize the swap chain description
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
//Set to a single back buffer
swapChainDesc.BufferCount = 1;
//Set the width and height of the back buffer
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
//Set regular 32-bit surface for the back buffer
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
//Set the refresh rate of the back buffer
if (this->m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
//Set the usage of the back buffer
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
//Set the handle for the window to render to
swapChainDesc.OutputWindow = hwnd;
//Turn multi sampling off
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
//Set to full screen or windowed mode
swapChainDesc.Windowed = !fullscreen;
//Set the scan line ordering and scaling to unspecified
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
//Discard the back buffer contents after presenting
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//Don't set the advanced flags
swapChainDesc.Flags = 0;
//Set the feature level to DirectX 11
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
//Create the swap chain, Direct3D device, and Direct3D device context
result = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &this->m_swapChain, &this->m_device, nullptr, &this->m_deviceContext);
if (FAILED(result))
{
return false;
}
//Get the pointer to the back buffer
ID3D11Texture2D* backBufferPtr;
result = this->m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
{
return false;
}
//Create the render target view with the back buffer pointer
result = this->m_device->CreateRenderTargetView(backBufferPtr, nullptr, &this->m_renderTargetView);
if (FAILED(result))
{
return false;
}
//Release pointer to the back buffer as we no longer need it
backBufferPtr->Release();
backBufferPtr = nullptr;
//Initialize the description of the depth buffer
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(D3D11_TEXTURE2D_DESC));
//Set up the description of the depth buffer
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
//Create the texture for the depth buffer using the filled out description
result = this->m_device->CreateTexture2D(&depthBufferDesc, nullptr, &this->m_depthStencilBuffer);
if (FAILED(result))
{
return false;
}
//Initialize the description of the stencil state
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
//Set up the description of the stencil state
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
//Stencil operations if pixel is front-facing
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
//Stencil operations if pixel if back facing
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
//Create the depth stencil state
result = this->m_device->CreateDepthStencilState(&depthStencilDesc, &this->m_depthEnabledStencilState);
if (FAILED(result))
{
return false;
}
//Set the depth stencil state
this->m_deviceContext->OMSetDepthStencilState(this->m_depthEnabledStencilState, 1);
//Create the disabled stencil desc
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
//Clear the second depth stencil state before setting the parameters
ZeroMemory(&depthDisabledStencilDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
//Now create a second depth stencil state which turns off the Z-buffer for 2D rendering. The only difference is that DepthEnable is set to false, all other parameters are the same as the other depth stencil state
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
result = this->m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &this->m_depthDisabledStencilState);
if (FAILED(result))
{
return false;
}
//Initialize the depth stencil view
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC));
//Set up the depth stencil view description
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
//Create the depth stencil view
result = this->m_device->CreateDepthStencilView(this->m_depthStencilBuffer, &depthStencilViewDesc, &this->m_depthStencilView);
if (FAILED(result))
{
return false;
}
//Bind the render target view and depth stencil buffer to the output render pipeline
this->m_deviceContext->OMSetRenderTargets(1, &this->m_renderTargetView, this->m_depthStencilView);
//Setup the raster description which will determine how and what polygons will be drawn
D3D11_RASTERIZER_DESC rasterizerDesc;
ZeroMemory(&rasterizerDesc, sizeof(D3D11_RASTERIZER_DESC));
rasterizerDesc.AntialiasedLineEnable = false;
rasterizerDesc.CullMode = D3D11_CULL_BACK;
rasterizerDesc.DepthBias = 0;
rasterizerDesc.DepthBiasClamp = 0.0f;
rasterizerDesc.DepthClipEnable = true;
rasterizerDesc.FillMode = D3D11_FILL_SOLID;
rasterizerDesc.FrontCounterClockwise = false;
rasterizerDesc.MultisampleEnable = false;
rasterizerDesc.ScissorEnable = false;
rasterizerDesc.SlopeScaledDepthBias = 0.0f;
//Create the rasterizer state from the description we just filled out
result = this->m_device->CreateRasterizerState(&rasterizerDesc, &this->m_rasterizerState);
if (FAILED(result))
{
return false;
}
//Now set the rasterizer state
this->m_deviceContext->RSSetState(this->m_rasterizerState);
//Setup the viewport for rendering
D3D11_VIEWPORT viewport;
ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
//Create the viewport
this->m_deviceContext->RSSetViewports(1, &viewport);
//Setup the projection matrix
float fieldOfView = (float)D3DX_PI / 4.0f;
float screenAspect = (float)screenWidth / (float)screenHeight;
//Create and clear the blend state description
D3D11_BLEND_DESC blendStateDescription;
ZeroMemory(&blendStateDescription, sizeof(D3D11_BLEND_DESC));
//Create an alpha enabled blend state description
blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 0x0f;
blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
//Create the blend state using the description
result = this->m_device->CreateBlendState(&blendStateDescription, &this->m_alphaEnableBlendingState);
if (FAILED(result))
{
return false;
}
//Modify the description to create an alpha disabled blend state description
blendStateDescription.RenderTarget[0].BlendEnable = FALSE;
//Create the blend state using the description
result = this->m_device->CreateBlendState(&blendStateDescription, &this->m_alphaDisableBlendingState);
if (FAILED(result))
{
return false;
}
//Create the projection matrix for 3d rendering
D3DXMatrixPerspectiveFovLH(&this->m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
//Initialize the world matrix to the identity matrix
D3DXMatrixIdentity(&this->m_worldMatrix);
//Create an orthographic projection matrix for 2D rendering
D3DXMatrixOrthoLH(&this->m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
bool RenderTextureClass::Initialize(ID3D11Device* device, int textureWidth, int textureHeight, float screenDepth, float screenNear)
{
D3D11_TEXTURE2D_DESC textureDesc;
HRESULT result;
D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
// Store the width and height of the render texture.
m_textureWidth = textureWidth;
m_textureHeight = textureHeight;
// Initialize the render target texture description.
ZeroMemory(&textureDesc, sizeof(textureDesc));
// Setup the render target texture description.
textureDesc.Width = textureWidth;
textureDesc.Height = textureHeight;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
textureDesc.SampleDesc.Count = 1;
textureDesc.Usage = D3D11_USAGE_DEFAULT;
textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
textureDesc.CPUAccessFlags = 0;
textureDesc.MiscFlags = 0;
// Create the render target texture.
result = device->CreateTexture2D(&textureDesc, NULL, &m_renderTargetTexture);
if(FAILED(result))
{
return false;
}
// Setup the description of the render target view.
renderTargetViewDesc.Format = textureDesc.Format;
renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
renderTargetViewDesc.Texture2D.MipSlice = 0;
// Create the render target view.
result = device->CreateRenderTargetView(m_renderTargetTexture, &renderTargetViewDesc, &m_renderTargetView);
if(FAILED(result))
{
return false;
}
// Setup the description of the shader resource view.
shaderResourceViewDesc.Format = textureDesc.Format;
shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
shaderResourceViewDesc.Texture2D.MipLevels = 1;
// Create the shader resource view.
result = device->CreateShaderResourceView(m_renderTargetTexture, &shaderResourceViewDesc, &m_shaderResourceView);
if(FAILED(result))
{
return false;
}
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = textureWidth;
depthBufferDesc.Height = textureHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// Create the texture for the depth buffer using the filled out description.
result = device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if(FAILED(result))
{
return false;
}
// Initailze the depth stencil view description.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
result = device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
{
return false;
}
// Setup the viewport for rendering.
m_viewport.Width = (float)textureWidth;
m_viewport.Height = (float)textureHeight;
m_viewport.MinDepth = 0.0f;
m_viewport.MaxDepth = 1.0f;
m_viewport.TopLeftX = 0.0f;
m_viewport.TopLeftY = 0.0f;
// Setup the projection matrix.
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, ((float)D3DX_PI / 4.0f), ((float)textureWidth / (float)textureHeight), screenNear, screenDepth);
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)textureWidth, (float)textureHeight, screenNear, screenDepth);
return true;
}
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;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
// vsync(수직동기화) 설정을 저장합니다.
m_vsync_enabled = vsync;
// DirectX 그래픽 인터페이스 팩토리를 만듭니다.
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
// 팩토리 객체를 사용하여 첫번째 그래픽 카드 인터페이스에 대한 아답터를 만듭니다.
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
// 출력(모니터)에 대한 첫번째 아답터를 나열합니다.
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
// DXGI_FORMAT_R8G8B8A8_UNORM 모니터 출력 디스플레이 포맷에 맞는 모드의 개수를 구합니다.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
// 가능한 모든 모니터와 그래픽카드 조합을 저장할 리스트를 생성합니다.
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
return false;
}
// 디스플레이 모드에 대한 리스트 구조를 채워넣습니다.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
// 이제 모든 디스플레이 모드에 대해 화면 너비/높이에 맞는 디스플레이 모드를 찾습니다.
// 적합한 것을 찾으면 모니터의 새로고침 비율의 분모와 분자 값을 저장합니다.
for (i = 0; i<numModes; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth)
{
if (displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// 아답터(그래픽카드)의 description을 가져옵니다.
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
// 현재 그래픽카드의 메모리 용량을 메가바이트 단위로 저장합니다.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// 그래픽카드의 이름을 char형 문자열 배열로 바꾼 뒤 저장합니다.
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
// 디스플레이 모드 리스트의 할당을 해제합니다.
delete[] displayModeList;
displayModeList = 0;
// 출력 아답터를 할당 해제합니다.
adapterOutput->Release();
adapterOutput = 0;
// 아답터를 할당 해제합니다.
adapter->Release();
adapter = 0;
// 팩토리 객체를 할당 해제합니다.
factory->Release();
factory = 0;
// 스왑 체인 description을 초기화합니다.
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// 하나의 백버퍼만을 사용하도록 합니다.
swapChainDesc.BufferCount = 1;
// 백버퍼의 너비와 높이를 설정합니다.
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// 백퍼버로 일반적인 32bit의 서페이스를 지정합니다.
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// 백버퍼의 새로고침 비율을 설정합니다.
if (m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// 백버퍼의 용도를 설정합니다.
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// 렌더링이 이루어질 윈도우의 핸들을 설정합니다.
swapChainDesc.OutputWindow = hwnd;
// 멀티샘플링을 끕니다.
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// 윈도우 모드 또는 풀스크린 모드를 설정합니다.
if (fullscreen)
swapChainDesc.Windowed = false;
else
swapChainDesc.Windowed = true;
// 스캔라인의 정렬과 스캔라이닝을 지정되지 않으므로 (unspecified) 설정합니다.
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// 출력된 이후의 백버퍼의 내용을 버리도록 합니다.
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// 추가 옵션 플래그를 사용하지 않습니다.
swapChainDesc.Flags = 0;
// 피쳐 레벨을 DirectX 11로 설정합니다.
featureLevel = D3D_FEATURE_LEVEL_11_0;
// 스왑 체인, Direct3D 디바이스, Direct3D 디바이스 컨텍스트를 생성합니다.
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result))
return false;
// 백버퍼의 포인터를 가져옵니다.
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
return false;
// 백버퍼의 포인터로 렌더타겟 뷰를 생성합니다.
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if (FAILED(result))
return false;
// 백버퍼 포인터를 더이상 사용하지 않으므로 할당 해제합니다.
backBufferPtr->Release();
backBufferPtr = 0;
// 깊이 버퍼의 description을 초기화합니다.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// 깊이 버퍼의 description을 작성합니다.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// description을 사용하여 깊이 버퍼의 텍스쳐를 생성합니다.
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
return false;
// 스텐실 상태의 description을 초기화합니다.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// 스텐실 상태의 description을 작성합니다.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// 깊이 - 스텐실 상태를 생성합니다.
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(result))
return false;
// 깊이 - 스텐실 상태를 설정합니다.
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// 깊이 - 스텐실 뷰의 description을 초기화 합니다.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// 깊이 - 스텐실 부의 description을 작성합니다.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// 깊이 - 스텐실 뷰를 생성합니다.
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
return false;
// 렌더타겟 뷰와 깊이 - 스텐실 버퍼를 각각 출력 파이프라인에 바인딩합니다.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// 어떤 도형을 어떻게 그릴 것인지 결정하는 래스터화기 description을 작성합니다.
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// 작성한 description으로부터 래스터화기 상태를 생성합니다.
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result))
return false;
// 래스터화기 상태를 설정합니다.
m_deviceContext->RSSetState(m_rasterState);
// 렌더링을 위한 뷰포트를 설정합니다.
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// 뷰포트를 생성합니다.
m_deviceContext->RSSetViewports(1, &viewport);
// 투영 행렬을 설정합니다.
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// 3D 렌더링을 위한 투영 행렬을 생성합니다.
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// 월드 행렬을 단위 행렬로 초기화 합니다.
D3DXMatrixIdentity(&m_worldMatrix);
// 2D 렌더링에 사용될 정사영 행렬을 생성합니다.
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
//--------------------------------------------------------------------------------
bool Renderer::InitDX(HWND hWnd)
{
IDirect3D9 * _pD3D;
// Intento crear el objeto DX9
_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
if (!_pD3D)
return false;
//guardo la resolución actual del escritorio
D3DDISPLAYMODE displayMode;
HRESULT hr = _pD3D->GetAdapterDisplayMode (
D3DADAPTER_DEFAULT,
&displayMode
);
if (hr!=D3D_OK)
return false;
// Fijo los valores a la estructura D3DPRESENT_PARAMETERS
D3DPRESENT_PARAMETERS d3dPresentParameters;
ZeroMemory( &d3dPresentParameters, sizeof(d3dPresentParameters));
d3dPresentParameters.BackBufferFormat = displayMode.Format;
d3dPresentParameters.Windowed = true;
d3dPresentParameters.BackBufferCount = 1;
d3dPresentParameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dPresentParameters.hDeviceWindow = 0;
d3dPresentParameters.Flags = 0;
d3dPresentParameters.EnableAutoDepthStencil = TRUE;
d3dPresentParameters.AutoDepthStencilFormat = D3DFMT_D24S8; d3dPresentParameters.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dPresentParameters.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
//invocaremos al método CreateDevice
hr = _pD3D->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dPresentParameters,
&m_pkDevice
);
if (hr!=D3D_OK)
{
hr = _pD3D->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dPresentParameters,
&m_pkDevice
);
}
if (hr!=D3D_OK)
return false;
if (!m_pkDevice)
return false;
m_pkDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
//m_pkDevice->SetRenderState(D3DRS_ZENABLE, FALSE);
m_pkDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
m_pkDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
m_pkDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
m_pkDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
m_pkDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
m_pkDevice->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
//D3DXMatrixIdentity(&d3dmat);
//D3DXMatrixTranslation(& d3dmat, 0, 0, 1.0f);
//D3DXMatrixRotationZ(& d3dmat, 0);
//hr = m_pkDevice->SetTransform(D3DTS_WORLD, &d3dmat);
if (hr!=D3D_OK)
return false;
setViewportPosition();
D3DVIEWPORT9 kViewport;
m_pkDevice->GetViewport(&kViewport);
D3DXMatrixOrthoLH(&m_mProjectionMatrix, (float) kViewport.Width, (float) kViewport.Height, -25, 25);
hr = m_pkDevice->SetTransform(D3DTS_PROJECTION, &m_mProjectionMatrix);
if (hr!=D3D_OK)
return false;
// create the color buffer
if(!m_pkVertexBuffer.Create(m_pkDevice, true))
return false;
// create the texture buffer
if(!m_kTextureBuffer.Create(m_pkDevice, true))
return false;
return true;
}
bool DX10_Renderer::onResize()
{
// Release the old render target view before creating again
ReleaseCOM(m_pRenderTargetView);
ReleaseCOM(m_pDepthStencilView);
ReleaseCOM(m_pDepthStencilBuffer);
// Resize the buffers of the Swap Chain and create the new render target view
VALIDATEHR(m_pDX10SwapChain->ResizeBuffers(1, m_clientWidth, m_clientHeight, DXGI_FORMAT_R8G8B8A8_UNORM, 0));
// Create a temporary Back buffer
ID3D10Texture2D* pBackBuffer;
// Retrieve the Back Buffer of the Swap Chain and create a Render Target View using the Back Buffer
VALIDATEHR(m_pDX10SwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), reinterpret_cast<void**>(&pBackBuffer)));
VALIDATEHR(m_pDX10Device->CreateRenderTargetView(pBackBuffer, 0, &m_pRenderTargetView));
// Release the memory from the temporary Back Buffer
ReleaseCOM(pBackBuffer);
// Create the depth buffer.
D3D10_TEXTURE2D_DESC depthBufferDesc;
depthBufferDesc.Width = m_clientWidth;
depthBufferDesc.Height = m_clientHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1; // multi sampling must match
depthBufferDesc.SampleDesc.Quality = 0; // swap chain values.
depthBufferDesc.Usage = D3D10_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
VALIDATEHR(m_pDX10Device->CreateTexture2D(&depthBufferDesc, NULL, &m_pDepthStencilBuffer));
//--------------------------------------------------------------------------------------
// Normal Depth Stencil
//--------------------------------------------------------------------------------------
D3D10_DEPTH_STENCIL_DESC depthStencilDesc;
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D10_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
// Create the depth stencil state.
VALIDATEHR(m_pDX10Device->CreateDepthStencilState(&depthStencilDesc, &m_pDepthStencilStateNormal));
// Set the depth stencil state on the D3D device.
m_pDX10Device->OMSetDepthStencilState(m_pDepthStencilStateNormal, 1);
D3D10_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
// Initialize the depth stencil view.
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// Set up the depth stencil view description.
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create the depth stencil view.
VALIDATEHR(m_pDX10Device->CreateDepthStencilView(m_pDepthStencilBuffer, &depthStencilViewDesc, &m_pDepthStencilView));
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_pDX10Device->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);
//--------------------------------------------------------------------------------------
// Disabled Depth Stencil
//--------------------------------------------------------------------------------------
D3D10_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
// Clear the second depth stencil state before setting the parameters.
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
// Now create a second depth stencil state which turns off the Z buffer for 2D rendering.
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D10_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
// Create the state using the device.
VALIDATEHR(m_pDX10Device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_pDepthStencilStateZDisabled));
// Set the View Port for the Device
D3D10_VIEWPORT viewPort;
viewPort.TopLeftX = 0;
viewPort.TopLeftY = 0;
viewPort.Width = m_clientWidth;
viewPort.Height = m_clientHeight;
viewPort.MinDepth = 0.0f;
viewPort.MaxDepth = 1.0f;
// Binds the View port to the Rasterizer stage of the pipeline
m_pDX10Device->RSSetViewports(1, &viewPort);
// Calculate the new Projection Matrix
CalcProjMatrix();
// Create an orthographic projection matrix for 2D rendering.
D3DXMatrixOrthoLH(&m_matOrtho, static_cast<float>(m_clientWidth), static_cast<float>(m_clientHeight), 0.1f, 100.0f);
return true;
}
bool Direct3D::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
// definitions
HRESULT result;
IDXGIFactory* factory;
IDXGIAdapter* adapter;
IDXGIOutput* adapterOutput;
unsigned int numModeCount, 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_DESC depthDisabledStencilDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
ID3D11BlendState* blendState;
D3D11_BLEND_DESC blendStateDescription;
float fieldOfView, screenAspect;
///////////////////////////////// GETTING REFRESH RATE
//Create DirectX graphics interface factory
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result)) return false;
//Create adapter
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result)) return false;
//Enumerate primary adapter output
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result)) return false;
//Get number of modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModeCount, NULL);
if (FAILED(result)) return false;
//Create array to hold all possible video modes
displayModeList = new DXGI_MODE_DESC[numModeCount];
if (!displayModeList) return false;
// Fill the array
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModeCount, displayModeList);
if (FAILED(result)) return false;
// find our display mode and get refresh rate for it
for (int i = 0; i < numModeCount; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth &&
displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
// get video card description
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result)) return false;
// get video card memory
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// store
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0) return false;
delete[] displayModeList;
displayModeList = nullptr;
adapterOutput->Release();
adapterOutput = nullptr;
adapter->Release();
adapter = nullptr;
factory->Release();
factory = nullptr;
////////////////////////////////////
//////////////// SWAP CHAIN DESCRIPTION
// initialize swap chain description
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// single back buffer
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// setting refresh rate of back buffer
if (m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hwnd;
/// !! MULTISAMPLING OFF
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen) swapChainDesc.Windowed = false;
else swapChainDesc.Windowed = true;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
///////////////////////////////////////
////////// CREATING DEVICE AND SWAP CHAIN
//DirectX11
featureLevel = D3D_FEATURE_LEVEL_11_0;
//swap chain
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &featureLevel, 1,
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result)) return false;
/*
Sometimes this call to create the device will fail if the primary video card is not compatible with DirectX 11.
Some machines may have the primary card as a DirectX 10 video card and the secondary card as a DirectX 11 video card.
Also some hybrid graphics cards work that way with the primary being the low power Intel card and the secondary being the high power Nvidia card.
To get around this you will need to not use the default device and instead enumerate all the video cards in the machine and
have the user choose which one to use and then specify that card when creating the device.
*/
// get pointer to back buffer
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result)) return false;
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if (FAILED(result)) return false;
backBufferPtr->Release();
backBufferPtr = nullptr;
//////////////////////////////////////
////////// DEPTH / STENCIL BUFFER
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// create texture for depth buffer
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result)) return false;
// setup description
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// stencil operations if pixel is front-facing or back-facing
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// create state
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// initialize depth stencil view
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// create depth stencil view
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result)) return false;
////////////////////////////////////////////////
// binding target view and depth stencil buffer
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
//////////////////////////////////////////////// DONE
//////// EXTRA STUFF
// raster description - how polygons will be drawn
ZeroMemory(&rasterDesc, sizeof(rasterDesc));
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result)) return false;
m_deviceContext->RSSetState(m_rasterState);
//blending description
//ZeroMemory(&blendStateDescription, sizeof(blendStateDescription));
//blendStateDescription.AlphaToCoverageEnable = true;
//blendStateDescription.RenderTarget[0].BlendEnable = TRUE;
//blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
//blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
//blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
//blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
//blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
//blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
//blendStateDescription.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
//result = m_device->CreateBlendState(&blendStateDescription, &m_blendState);
//if (FAILED(result)) return false;
//const FLOAT blendFactor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
//m_deviceContext->OMSetBlendState(m_blendState, blendFactor, 0xffffffff);
// viewport description
viewport.Width = (float)screenWidth;
viewport.Height = (float)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
m_deviceContext->RSSetViewports(1, &viewport);
//disable depth stencil state
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_depthDisabledStencilState);
if (FAILED(result))return false;
// projection matrix
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
// world matrix
D3DXMatrixIdentity(&m_worldMatrix);
// view matrix
////////////////////////////////////////// TBA!!!!!!!
// ortographic projection
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
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;
D3D11_VIEWPORT viewport;
float fieldOfView, screenAspect;
// 保存垂直同步设置
m_vsync_enabled = vsync;
// 创建一个DirectX graphics 接口工厂
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if(FAILED(result))
return false;
// 用接口工厂创建一个主显卡的适配
result =factory->EnumAdapters(0, &adapter);
if(FAILED(result))
return false;
// 得到主适配器的输出
result = adapter->EnumOutputs(0, &adapterOutput);
if(FAILED(result))
return false;
//得到适合 DXGI_FORMAT_R8G8B8A8_UNORM 的显示模式
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &numModes, nullptr);
if(FAILED(result))
return false;
displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
return false;
// 保存显示模式到displayModeList中
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if(FAILED(result))
return false;
// 遍历所有显示模式，得到刷新率两个参数值numerator 和 denominator
for (int i = 0; i < numModes; i++)
{
if(displayModeList[i].Width == screenWidth)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
// 得到显卡描述
result = adapter->GetDesc(&adapterDesc);
if(FAILED(result))
return false;
// 保存显存大小
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
//保存显卡描述串
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if(error != 0)
return false;
// 释放显示模式列表
delete[] displayModeList;
displayModeList = nullptr;
//释放适配器输出
adapterOutput->Release();
adapterOutput = nullptr;
//释放适配器
adapter->Release();
adapter = nullptr;
//释放接口工厂
factory->Release();
factory = nullptr;
//初始化交换链描述
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
// 用1个后缓冲
swapChainDesc.BufferCount = 1;
// 帧缓冲的大小和应用程序窗口大小相等
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
// 后缓冲的surface的格式为DXGI_FORMAT_R8G8B8A8_UNORM
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
// 如果使用垂直同步，设置后缓冲的刷新率
if(m_vsync_enabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
// 设置后缓冲的用途
// 我们的渲染目标缓冲为后缓冲
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
// 后缓冲输出的窗口句柄
swapChainDesc.OutputWindow = hwnd;
// 不使用多重采样
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
// 设置全屏或者窗口模式
if(fullscreen)
swapChainDesc.Windowed = false;
else
swapChainDesc.Windowed = true;
// 设定扫描线ordering以及缩放为unspecified
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// 后缓冲内容呈现到屏幕后，放弃其内容
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//不设置标志
swapChainDesc.Flags = 0;
// 设置feature level为D3D11
// 如果显卡不支持D3D11,我们能够通过设置这个参数，使用D3D10,或者9
featureLevel = D3D_FEATURE_LEVEL_11_0;
// 创建交换链，设备以及设备上下文
result = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
&featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, nullptr, &m_deviceContext);
if(FAILED(result))
return false;
// 得到交换链中的后缓冲指针
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBufferPtr);
if(FAILED(result))
return false;
// 用后缓冲创建渲染目标视图
result = m_device->CreateRenderTargetView(backBufferPtr, nullptr, &m_renderTargetView);
if(FAILED(result))
return false;
//释放后缓冲(引用计数减1)
backBufferPtr->Release();
backBufferPtr = nullptr;
// 初始化深度缓冲描述
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
//设置深度缓冲描述
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1; //对于深度缓冲为1
depthBufferDesc.ArraySize = 1; //对于深度缓冲为1，对于纹理，这2个参数有更多用途
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// 创建深度缓冲
result = m_device->CreateTexture2D(&depthBufferDesc, nullptr, &m_depthStencilBuffer);
if(FAILED(result))
return false;
// 初始化深度模版状态描述
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// 设置深度模版状态描述
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
// D3D11_DEPTH_WRITE_MASK_ZERO禁止写深度缓冲
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// 对于front face 像素使用的模版操作操作
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// 对于back face像素使用的模版操作模式
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
//创建深度模版状态
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if(FAILED(result))
return false;
// 设置深度模版状态，使其生效
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
// 初始化深度模版视图
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// 设置深度模版视图描述
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// 创建深度模版视图
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if(FAILED(result))
return false;
// 绑定渲染目标视图和深度缓冲到渲染管线
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
// 设置光栅化描述，指定多边形如何被渲染
rasterDesc.AntialiasedLineEnable = false;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = false;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
// 创建光栅化状态
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if(FAILED(result))
return false;
// 设置光栅化状态，使其生效
m_deviceContext->RSSetState(m_rasterState);
// 设置视口，显示全部后缓冲内容
viewport.Width = (FLOAT)screenWidth;
viewport.Height = (FLOAT)screenHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0.0f;
viewport.TopLeftY = 0.0f;
// 创建视口
m_deviceContext->RSSetViewports(1, &viewport);
// 设置透视投影矩阵
fieldOfView = (float)D3DX_PI / 4.0f;
screenAspect = (float)screenWidth / (float)screenHeight;
// 创建透视投影矩阵
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);
//初始化world矩阵为单位矩阵
//该矩阵实现局部坐标到世界坐标的转换
D3DXMatrixIdentity(&m_worldMatrix);
// 创建正交投影矩阵，主要用来实施2D渲染
D3DXMatrixOrthoLH(&m_orthoMatrix, (float)screenWidth, (float)screenHeight, screenNear, screenDepth);
return true;
}
bool CD3DGraphics11::Init(HWND hWnd, UINT clientWidth, UINT clientHeight )
{
cout << "CD3DGraphics11: Client Height " << clientHeight <<"\n";
cout << "CD3DGraphics11: Client Width " << clientWidth << "\n";
m_clientHeight = clientHeight;
m_clientWidth = clientWidth;
int screenWidth = GetSystemMetrics(SM_CXSCREEN);
int screenHeight = GetSystemMetrics(SM_CYSCREEN);
D3D_FEATURE_LEVEL featureLevel;
ID3D11Texture2D* pBackBuffer;
IDXGIFactory* pFactory;
IDXGIAdapter* pAdapter;
IDXGIOutput* pAdapterOutput;
D3D11_VIEWPORT viewport;
DXGI_MODE_DESC* pDisplayModeList;
DXGI_ADAPTER_DESC adapterDesc;
DXGI_SWAP_CHAIN_DESC swapChainDesc;
D3D11_TEXTURE2D_DESC depthBufferDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
D3D11_DEPTH_STENCIL_DESC depthStencilDisabledDesc;
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
D3D11_RASTERIZER_DESC rasterDesc;
D3D11_BLEND_DESC blendDesc;
UINT nAdapterModes = 0;
int RRNumerator = 0, RRDenominator = 1;
if(FAILED(CreateDXGIFactory(__uuidof(IDXGIFactory),(void**)&pFactory))){return false;}
if(FAILED(pFactory->EnumAdapters(0,&pAdapter))){return false;}
if(FAILED(pAdapter->EnumOutputs(0,&pAdapterOutput))){return false;}
if(FAILED(pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &nAdapterModes, NULL))){return false;}
pDisplayModeList = new DXGI_MODE_DESC[nAdapterModes];
if(!pDisplayModeList){ return false; }
if(FAILED(pAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_ENUM_MODES_INTERLACED, &nAdapterModes, pDisplayModeList ))){return false;}
if(m_vsync)
{
for(UINT i = 0; i < nAdapterModes; i++)
{
if( pDisplayModeList[i].Width == screenWidth &&
pDisplayModeList[i].Height == screenHeight )
{
RRNumerator = pDisplayModeList[i].RefreshRate.Numerator;
RRDenominator = pDisplayModeList[i].RefreshRate.Denominator;
break;
}
}
}
if(FAILED(pAdapter->GetDesc(&adapterDesc))){return false;}
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024 );
if(wcstombs_s(NULL, m_videoCardDesc,128,adapterDesc.Description,128) != 0){return false;}
MEMORY::DX::SafeRelease(pAdapterOutput);
MEMORY::DX::SafeRelease(pAdapter);
MEMORY::DX::SafeRelease(pFactory);
ZeroMemory(&swapChainDesc,sizeof(swapChainDesc));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.Flags = 0;
swapChainDesc.Windowed = true;
swapChainDesc.OutputWindow = hWnd;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapChainDesc.BufferDesc.Height = clientHeight;
swapChainDesc.BufferDesc.Width = clientWidth;
swapChainDesc.BufferDesc.RefreshRate.Denominator = RRDenominator;
swapChainDesc.BufferDesc.RefreshRate.Numerator = RRNumerator;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
featureLevel = D3D_FEATURE_LEVEL_11_0;
UINT flags = 0;
#ifdef _DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
if(FAILED(D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE,NULL, flags,&featureLevel,1,
D3D11_SDK_VERSION,&swapChainDesc,&m_pSwapChain,
&m_device.pDevice,NULL,&m_device.pDeviceContext))) {return false;}
if(FAILED(m_pSwapChain->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&pBackBuffer))){return false;}
if(FAILED(m_device.pDevice->CreateRenderTargetView(pBackBuffer, NULL, &m_pRenderTargetView))){return false;}
MEMORY::DX::SafeRelease(pBackBuffer);
ZeroMemory(&depthBufferDesc,sizeof(D3D11_TEXTURE2D_DESC));
depthBufferDesc.ArraySize = 1;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.Height = clientHeight;
depthBufferDesc.Width = clientWidth;
depthBufferDesc.MiscFlags = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
if(FAILED(m_device.pDevice->CreateTexture2D(&depthBufferDesc,NULL,&m_pDepthStencilBuffer))){return false;}
ZeroMemory(&depthStencilDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
if(FAILED(m_device.pDevice->CreateDepthStencilState(&depthStencilDesc,&m_pDepthStencilState))){return false;}
ZeroMemory(&depthStencilDisabledDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
depthStencilDisabledDesc.DepthEnable = false;
depthStencilDisabledDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDisabledDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDisabledDesc.StencilEnable = true;
depthStencilDisabledDesc.StencilReadMask = 0xFF;
depthStencilDisabledDesc.StencilWriteMask = 0xFF;
depthStencilDisabledDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDisabledDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDisabledDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthStencilDisabledDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDisabledDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
if (FAILED(m_device.pDevice->CreateDepthStencilState(&depthStencilDisabledDesc, &m_pDepthStencilStateDisabled))) { return false; }
m_device.pDeviceContext->OMSetDepthStencilState(m_pDepthStencilState,1);
ZeroMemory(&depthStencilViewDesc,sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
if(FAILED(m_device.pDevice->CreateDepthStencilView(m_pDepthStencilBuffer,
&depthStencilViewDesc,&m_pDepthStencilView ))) {return false; }
ZeroMemory(&blendDesc,sizeof(D3D11_BLEND_DESC));
blendDesc.RenderTarget[0].BlendEnable = true;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_DEST_ALPHA;
blendDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f;
blendDesc.AlphaToCoverageEnable = true;
if(FAILED(m_device.pDevice->CreateBlendState(&blendDesc,&m_pAlphaBlendEnabled)))
return false;
blendDesc.RenderTarget[0].BlendEnable = false;
blendDesc.AlphaToCoverageEnable = false;
if(FAILED(m_device.pDevice->CreateBlendState(&blendDesc, &m_pAlphaBlendDisabled)))
return false;
rasterDesc.AntialiasedLineEnable = true;
rasterDesc.CullMode = D3D11_CULL_BACK;
rasterDesc.DepthBias = 0;
rasterDesc.DepthBiasClamp = 0.0f;
rasterDesc.DepthClipEnable = true;
rasterDesc.FillMode = D3D11_FILL_SOLID;
rasterDesc.FrontCounterClockwise = false;
rasterDesc.MultisampleEnable = true;
rasterDesc.ScissorEnable = false;
rasterDesc.SlopeScaledDepthBias = 0.0f;
if(FAILED(m_device.pDevice->CreateRasterizerState(&rasterDesc,&m_pRasterState))){return false;}
m_device.pDeviceContext->RSSetState(m_pRasterState);
rasterDesc.CullMode = D3D11_CULL_NONE;
if (FAILED(m_device.pDevice->CreateRasterizerState(&rasterDesc, &m_pRasterStateNoCull))) { return false; }
viewport.Height = (float)clientHeight;
viewport.Width = (float)clientWidth;
viewport.MaxDepth = 1.0f;
viewport.MinDepth = 0.0f;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
m_device.pDeviceContext->OMSetRenderTargets(1,&m_pRenderTargetView,m_pDepthStencilView);
m_device.pDeviceContext->RSSetViewports(1,&viewport);
float fov, screenAspect;
fov = (float)D3DX_PI / 4.0f;
screenAspect = (float)clientWidth / (float)clientHeight;
D3DXMatrixPerspectiveFovLH(&m_matrices.projection,fov,screenAspect,0.1f,1000.0f);
D3DXMatrixOrthoLH(&m_matrices.ortho,(float)clientWidth,(float)clientHeight,0.1f,1000.0f);
if (!InitDefaultTexture())
return false;
if(!m_colorShader.Init(*this))
return false;
if(!m_textureShader.Init(*this))
return false;
if(!m_textureLightingShader.Init(*this))
return false;
if(!m_orthoShader.Init(*this))
return false;
if (!m_specularMapShader.Init(*this))
return false;
if (!m_bumpMapShader.Init(*this))
return false;
return true;
}
// FIXME: split into multiple methods for readability
bool D3DBase::init( int screenWidth, int screenHeight, const bool vsync, HWND hwnd, const bool fullscreen, const float screenDepth, const float screenNear )
{
HRESULT result;
m_vsyncEnabled = vsync;
// Get refresh rates and find a correct one to use
// ----------------------------------------------------------------------
ComPtr<IDXGIFactory> factory;
ComPtr<IDXGIAdapter> adapter;
ComPtr<IDXGIOutput> adapterOutput;
unsigned int numModes;
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
return false;
}
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
return false;
}
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
return false;
}
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
return false;
}
DXGI_MODE_DESC* displayModeList = new DXGI_MODE_DESC[numModes];
if(!displayModeList)
{
return false;
}
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
return false;
}
// Find correct display mode
unsigned int numerator;
unsigned int denominator;
for (unsigned int i = 0; i < numModes; ++i)
{
if (displayModeList[i].Width == (unsigned int) screenWidth)
{
if (displayModeList[i].Height == (unsigned int) screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
// Get GPU name and memory
DXGI_ADAPTER_DESC adapterDesc;
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
return false;
}
// Store memory in megabytes
m_gpuMemory = (int) (adapterDesc.DedicatedVideoMemory / 1000 / 1000);
// Get GPU name
char gpuDescription[128];
size_t stringLength;
int error = wcstombs_s(&stringLength, gpuDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
return false;
}
m_gpuDescription = std::string(gpuDescription);
// Clean up
delete[] displayModeList;
adapterOutput = nullptr;
adapter = nullptr;
factory = nullptr;
//------------------------------------------------------------------------------
// Start actual directx initialization
// ------------------------------------------------------------------------------------
// Swap chain
DXGI_SWAP_CHAIN_DESC swapChainDesc;
ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Width = screenWidth;
swapChainDesc.BufferDesc.Height = screenHeight;
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
if (m_vsyncEnabled)
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator;
swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator;
}
else
{
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
}
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.OutputWindow = hwnd;
// no multisampling = 1, 0
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
if (fullscreen)
{
swapChainDesc.Windowed = false;
}
else
{
swapChainDesc.Windowed = true;
}
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags = 0;
// Set the feature level (change to 10 or 9 for backwards compatibility)
D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
// Finally create the device (note it's directX version specific)
result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, D3D11_CREATE_DEVICE_DEBUG, &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result))
{
return false;
}
// Back buffer
ComPtr<ID3D11Texture2D> backBufferPtr;
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*) &backBufferPtr);
if (FAILED(result))
{
return false;
}
result = m_device->CreateRenderTargetView(backBufferPtr.Get(), NULL, m_renderTargetView.GetAddressOf());
if (FAILED(result))
{
return false;
}
backBufferPtr = nullptr;
// -- Back buffer
// Depth buffer
// Initialize the description of the depth buffer.
D3D11_TEXTURE2D_DESC depthBufferDesc;
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1; // 1
depthBufferDesc.SampleDesc.Quality = 0; // 0
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
{
return false;
}
// -- Depth Stencil
// Initialize the description of the stencil state.
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create depth stencil state
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(result))
{
return false;
}
m_deviceContext->OMSetDepthStencilState(m_depthStencilState.Get(), 1);
// Initialize depth stencil view
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// Create depth stencil view
result = m_device->CreateDepthStencilView(m_depthStencilBuffer.Get(), &depthStencilViewDesc, &m_depthStencilView);
// Bind render target view
m_deviceContext->OMSetRenderTargets(1, m_renderTargetView.GetAddressOf(), m_depthStencilView.Get());
// -- Rasterizer state
// Setup the raster description which will determine how and what polygons will be drawn.
D3D11_RASTERIZER_DESC rasterizerDesc;
rasterizerDesc.AntialiasedLineEnable = false;
rasterizerDesc.CullMode = D3D11_CULL_BACK;
rasterizerDesc.DepthBias = 0;
rasterizerDesc.DepthBiasClamp = 0.0f;
rasterizerDesc.DepthClipEnable = true;
rasterizerDesc.FillMode = D3D11_FILL_SOLID; // D3D11_FILL_WIREFRAME for wireframe
rasterizerDesc.FrontCounterClockwise = false;
rasterizerDesc.MultisampleEnable = false; // false
rasterizerDesc.ScissorEnable = false;
rasterizerDesc.SlopeScaledDepthBias = 0.0f;
result = m_device->CreateRasterizerState(&rasterizerDesc, &m_rasterizerState);
if(FAILED(result))
{
return false;
}
m_deviceContext->RSSetState(m_rasterizerState.Get());
// Setup the viewport
D3D11_VIEWPORT viewport;
viewport.Width = static_cast<float>(screenWidth);
viewport.Height = static_cast<float>(screenHeight);
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
// Create the viewport.
m_deviceContext->RSSetViewports(1, &viewport);
// Setup projection matrix
float fov = (float) D3DX_PI / 4.0f;
float aspectRatio = (float) screenWidth / (float) screenHeight;
D3DXMatrixPerspectiveFovLH(&m_projectionMatrix, fov, aspectRatio, screenNear, screenDepth);
// Initialize world matrix
D3DXMatrixIdentity(&m_worldMatrix);
// Create camera here
// Create an orthographic projection matrix for 2D rendering
D3DXMatrixOrthoLH(&m_orthoMatrix, (float) screenWidth, (float) screenHeight, screenNear, screenDepth);
// Depth stencil stuff
// ----------------------------------------------------------------------------------------------
D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc;
ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc));
// Create second depth stencil state which turns off the Z buffer for 2D rendering
depthDisabledStencilDesc.DepthEnable = false;
depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthDisabledStencilDesc.StencilEnable = true;
depthDisabledStencilDesc.StencilReadMask = 0xFF;
depthDisabledStencilDesc.StencilWriteMask = 0xFF;
depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Create the state using the device
result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_disableDepthStencilState);
if (FAILED(result))
{
return false;
}
return true;
}
Matrix Matrix::createOrthographic(float w, float h, float zn, float zf)
{
return *D3DXMatrixOrthoLH(&tmp, w, h, zn, zf);
}
/*!
\b Parameters:
\arg \b pCamera3d ::IND_Camera3d object that defines a camera.
\b Operation:
This function sets a 3d camera. See the methods of ::IND_Camera3d for information on how you can manipulate the camera.
*/
void DirectXRender::setCamera3d(IND_Camera3d *pCamera3d) {
D3DXMATRIX mTrans, mMatView, mMatProjection;
D3DXMatrixIdentity(&mMatView);
D3DXMatrixIdentity(&mMatProjection);
// ----- View matrix -----
pCamera3d->_up = IND_Vector3 (0.0f, 1.0f, 0.0f);
pCamera3d->_look = IND_Vector3 (0.0f, 0.0f, 1.0f);
pCamera3d->_right = IND_Vector3 (1.0f, 0.0f, 0.0f);
//Buffer D3DVec3 structs from our camera 3d vectors
D3DXVECTOR3 d3dpos (pCamera3d->_pos._x,pCamera3d->_pos._y,pCamera3d->_pos._z);
D3DXVECTOR3 d3dlook (pCamera3d->_look._x,pCamera3d->_look._y, pCamera3d->_look._z);
D3DXVECTOR3 d3dup (pCamera3d->_up._x,pCamera3d->_up._y, pCamera3d->_up._z);
D3DXVECTOR3 d3dright (pCamera3d->_right._x,pCamera3d->_right._y, pCamera3d->_right._z);
// Yaw is rotation around the y axis (_up)
// Create a matrix that can carry out this rotation
D3DXMATRIX yawMatrix;
D3DXMatrixRotationAxis(&yawMatrix, &d3dup, D3DXToRadian(pCamera3d->_yaw));
// To apply yaw we rotate the _look & _right vectors about the _up vector (using our yaw matrix)
D3DXVec3TransformCoord(&d3dlook, &d3dlook, &yawMatrix);
D3DXVec3TransformCoord(&d3dright, &d3dright, &yawMatrix);
// Pitch is rotation around the x axis (_right)
// Create a matrix that can carry out this rotation
D3DXMATRIX pitchMatrix;
D3DXMatrixRotationAxis(&pitchMatrix, &d3dright, D3DXToRadian(pCamera3d->_pitch));
// To apply pitch we rotate the _look and _up vectors about the _right vector (using our pitch matrix)
D3DXVec3TransformCoord(&d3dlook, &d3dlook, &pitchMatrix);
D3DXVec3TransformCoord(&d3dup, &d3dup, &pitchMatrix);
// Roll is rotation around the z axis (_look)
// Create a matrix that can carry out this rotation
D3DXMATRIX rollMatrix;
D3DXMatrixRotationAxis(&rollMatrix, &d3dlook, D3DXToRadian(pCamera3d->_roll));
// To apply roll we rotate up and right about the look vector (using our roll matrix)
// Note: roll only really applies for things like aircraft unless you are implementing lean
D3DXVec3TransformCoord(&d3dright, &d3dright, &rollMatrix);
D3DXVec3TransformCoord(&d3dup, &d3dup, &rollMatrix);
// Build the view matrix from the transformed camera axis
mMatView._11 = pCamera3d->_right._x;
mMatView._12 = pCamera3d->_up._x;
mMatView._13 = pCamera3d->_look._x;
mMatView._21 = pCamera3d->_right._y;
mMatView._22 = pCamera3d->_up._y;
mMatView._23 = pCamera3d->_look._y;
mMatView._31 = pCamera3d->_right._z;
mMatView._32 = pCamera3d->_up._z;
mMatView._33 = pCamera3d->_look._z;
mMatView._41 = - D3DXVec3Dot(&d3dright, &d3dright);
mMatView._42 = - D3DXVec3Dot(&d3dright, &d3dup);
mMatView._43 = - D3DXVec3Dot(&d3dright, &d3dlook);
// ---- Zoom ----
D3DXMatrixScaling(&mTrans, pCamera3d->_zoom, pCamera3d->_zoom, pCamera3d->_zoom);
D3DXMatrixMultiply(&mMatView, &mTrans, &mMatView);
_info._device->SetTransform(D3DTS_VIEW, &mMatView);
// ----- Projection matrix -----
// Fov projection
if (!pCamera3d->isOrthoProjection()) {
D3DXMatrixPerspectiveFovLH(&mMatProjection, // output
pCamera3d->_fov, // Fov vertical
pCamera3d->_aspect, // Relación de aspecto del viewport
pCamera3d->_nearClippingPlane, // Near clipping plane z
pCamera3d->_farClippingPlane); // Far clipping plane z
}
// Orthographic projection
else {
D3DXMatrixOrthoLH(&mMatProjection, pCamera3d->_orthoWidth, pCamera3d->_orthoHeight, pCamera3d->_nearClippingPlane, pCamera3d->_farClippingPlane);
}
_info._device->SetTransform(D3DTS_PROJECTION, &mMatProjection);
}
void CWndChangeSex::OnDraw( C2DRender* p2DRender )
{
if( g_pPlayer == NULL )
return;
LPDIRECT3DDEVICE9 pd3dDevice = p2DRender->m_pd3dDevice;
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
pd3dDevice->SetSamplerState ( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
pd3dDevice->SetSamplerState ( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
pd3dDevice->SetRenderState( D3DRS_AMBIENT, D3DCOLOR_ARGB( 255, 255,255,255) );
CRect rect = GetClientRect();
// 뷰포트 세팅
D3DVIEWPORT9 viewport;
// 월드
D3DXMATRIXA16 matWorld;
D3DXMATRIXA16 matScale;
D3DXMATRIXA16 matRot;
D3DXMATRIXA16 matTrans;
// 카메라
D3DXMATRIX matView;
D3DXVECTOR3 vecLookAt( 0.0f, 0.0f, 3.0f );
D3DXVECTOR3 vecPos( 0.0f, 0.7f, -3.5f );
D3DXMatrixLookAtLH( &matView, &vecPos, &vecLookAt, &D3DXVECTOR3(0.0f,1.0f,0.0f) );
pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
// 왼쪽 원본 모델 랜더링
{
LPWNDCTRL lpFace = GetWndCtrl( WIDC_STATIC1 );
viewport.X = p2DRender->m_ptOrigin.x + lpFace->rect.left;//2;
viewport.X -= 6;
viewport.Y = p2DRender->m_ptOrigin.y + lpFace->rect.top;//5;
viewport.Width = lpFace->rect.Width();//p2DRender->m_clipRect.Width();
viewport.Height = lpFace->rect.Height();// - 10;//p2DRender->m_clipRect.Height();
viewport.MinZ = 0.0f;
viewport.MaxZ = 1.0f;
pd3dDevice->SetViewport(&viewport);
pd3dDevice->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0xffa08080, 1.0f, 0 ) ;
D3DXMATRIX matProj;
D3DXMatrixIdentity( &matProj );
FLOAT fAspect = ((FLOAT)viewport.Width) / (FLOAT)viewport.Height;
/*
D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4.0f, fAspect, CWorld::m_fNearPlane - 0.01f, CWorld::m_fFarPlane );
pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
*/
FLOAT fov = D3DX_PI/4.0f;//796.0f;
FLOAT h = cos(fov/2) / sin(fov/2);
FLOAT w = h * fAspect;
D3DXMatrixOrthoLH( &matProj, w, h, CWorld::m_fNearPlane - 0.01f, CWorld::m_fFarPlane );
pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
D3DXMatrixIdentity(&matScale);
D3DXMatrixIdentity(&matTrans);
D3DXMatrixIdentity(&matWorld);
D3DXMatrixScaling(&matScale, 4.5f, 4.5f, 4.5f);
if( g_pPlayer->GetSex() == SEX_MALE )
D3DXMatrixTranslation(&matTrans,0.0f,-5.6f,0.0f);
else
D3DXMatrixTranslation(&matTrans,0.0f,-5.8f,0.0f);
D3DXMatrixMultiply(&matWorld,&matWorld,&matScale);
D3DXMatrixMultiply(&matWorld, &matWorld, &matTrans );
pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
// 랜더링
pd3dDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );//m_bViewLight );
::SetLight( FALSE );
::SetFog( FALSE );
SetDiffuse( 1.0f, 1.0f, 1.0f );
SetAmbient( 1.0f, 1.0f, 1.0f );
/*
m_pModel->GetObject3D(PARTS_HAIR)->m_fAmbient[0] = 0.5f;
m_pModel->GetObject3D(PARTS_HAIR)->m_fAmbient[1] = 0.5f;
m_pModel->GetObject3D(PARTS_HAIR)->m_fAmbient[2] = 0.5f;
*/
D3DXVECTOR4 vConst( 1.0f, 1.0f, 1.0f, 1.0f );
#ifdef __YENV
D3DXVECTOR3 vDir( 0.0f, 0.0f, 1.0f );
SetLightVec( vDir );
g_Neuz.m_pEffect->SetVector( g_Neuz.m_hvFog, &vConst );
#else //__YENV
pd3dDevice->SetVertexShaderConstantF( 95, (float*)&vConst, 1 );
#endif //__YENV
::SetTransformView( matView );
::SetTransformProj( matProj );
m_pModel->Render( p2DRender->m_pd3dDevice, &matWorld );
}
}
void DeferredDemo::initApp(void)
{
D3DApp::initApp();
fx::InitAll(md3dDevice);
InputLayout::InitAll(md3dDevice);
GetTextureMgr().init(md3dDevice);
m_normalRT= new RenderTexture(md3dDevice, 1024,1024, DXGI_FORMAT_R16G16B16A16_FLOAT );
m_diffusespecRT = new RenderTexture(md3dDevice, 1024, 1024, DXGI_FORMAT_R16G16B16A16_FLOAT);
m_lightRT = new RenderTexture(md3dDevice, 1024, 1024, DXGI_FORMAT_R16G16B16A16_FLOAT);
m_quad = new NDCQuad(md3dDevice, D3DXVECTOR3(0.5f, -0.5f,0.0f), D3DXVECTOR3(0.5f, 0.5f,0.0f));
m_finalQuad = new NDCQuad(md3dDevice, D3DXVECTOR3(0.0f, 0.0f,0.0f), D3DXVECTOR3(1.0f,1.0f,1.0f));
//create solid rasterizer state
D3D10_RASTERIZER_DESC rsDesc;
ZeroMemory(&rsDesc, sizeof(rsDesc));
rsDesc.CullMode = D3D10_CULL_BACK;
rsDesc.FillMode = D3D10_FILL_SOLID ;
rsDesc.FrontCounterClockwise = false;
rsDesc.DepthClipEnable = true;
HR(md3dDevice->CreateRasterizerState(&rsDesc, &m_solidMode));
/*std::vector<D3DXVECTOR3> vb;
std::vector<uint16_t> ib;
::CreateConeMesh(vb,ib,0,1,2,12);*/
mTech = fx::ShadowFX->GetTechniqueByName("ShadowTech");
mfxLightVar = fx::ShadowFX->GetVariableByName("gLight");
mfxEyePosVar = fx::ShadowFX->GetVariableByName("gEyePosW");
mfxLightWVPVar = fx::ShadowFX->GetVariableByName("gLightWVP")->AsMatrix();
mfxWVPVar = fx::ShadowFX->GetVariableByName("gWVP")->AsMatrix();
mfxWorldVar = fx::ShadowFX->GetVariableByName("gWorld")->AsMatrix();
mfxTexMtxVar = fx::ShadowFX->GetVariableByName("gTexMtx")->AsMatrix();
mfxReflectMtrlVar = fx::ShadowFX->GetVariableByName("gReflectMtrl")->AsVector();
mfxCubeMapEnabledVar = fx::ShadowFX->GetVariableByName("gCubeMapEnabled")->AsScalar();
mfxDiffuseMapVar = fx::ShadowFX->GetVariableByName("gDiffuseMap")->AsShaderResource();
mfxSpecMapVar = fx::ShadowFX->GetVariableByName("gSpecMap")->AsShaderResource();
mfxNormalMapVar = fx::ShadowFX->GetVariableByName("gNormalMap")->AsShaderResource();
mfxShadowMapVar = fx::ShadowFX->GetVariableByName("gShadowMap")->AsShaderResource();
mfxCubeMapVar = fx::ShadowFX->GetVariableByName("gCubeMap")->AsShaderResource();
mBuildShadowMapTech = fx::BuildShadowMapFX->GetTechniqueByName("BuildShadowMapTech");
mfxBuildShadowMapLightWVPVar = fx::BuildShadowMapFX->GetVariableByName("gLightWVP")->AsMatrix();
mfxBuildShadowMapDiffuseMapVar = fx::BuildShadowMapFX->GetVariableByName("gDiffuseMap")->AsShaderResource();
//GBuffer technique and technique variables
m_genGBufferTech =fx::GenGBufferFX->GetTechniqueByName("GBufferTech");
m_ObjectModelVar = fx::GenGBufferFX->GetVariableByName("gWorld")->AsMatrix();
m_CameraViewVar = fx::GenGBufferFX->GetVariableByName("gView")->AsMatrix();
m_CameraProjVar = fx::GenGBufferFX->GetVariableByName("gProject")->AsMatrix();
m_TexMtx = fx::GenGBufferFX->GetVariableByName("gTexMtx")->AsMatrix();
m_Shininese = fx::GenGBufferFX->GetVariableByName("gShininese")->AsScalar();
m_DiffuseMapVar = fx::GenGBufferFX->GetVariableByName("gDiffuseMap")->AsShaderResource();
m_SpecMapVar = fx::GenGBufferFX->GetVariableByName("gSpecMap")->AsShaderResource();
m_NormalMapVar = fx::GenGBufferFX->GetVariableByName("gNormalMap")->AsShaderResource();
m_CubeMapVar = fx::GenGBufferFX->GetVariableByName("gCubeMap")->AsShaderResource();
m_CubeMapEnabledVar = fx::GenGBufferFX->GetVariableByName("gCubeMapEnabled")->AsScalar();
m_EyePosVar = fx::GenGBufferFX->GetVariableByName("gEyePosW");
m_depthTex.init(md3dDevice,1024,1024,false,DXGI_FORMAT_UNKNOWN);
//lighting pass tech
m_pointLightTech = fx::LightingFX->GetTechniqueByName("DeferredPointTech");
m_parallelLightTech = fx::LightingFX->GetTechniqueByName("DeferredDirectionalTech");
m_lightSourceTech = fx::LightingFX->GetTechniqueByName("LightTech");
m_pointLightVar = fx::LightingFX->GetVariableByName("gLight");
m_lightPosVVar = fx::LightingFX->GetVariableByName("gLightPosV");
m_pointLightWVPVar = fx::LightingFX->GetVariableByName("gWorldViewProj")->AsMatrix();
m_pointLightWVVar = fx::LightingFX->GetVariableByName("gWorldView")->AsMatrix();
m_depthVar = fx::LightingFX->GetVariableByName("gDepthMap")->AsShaderResource();
m_gbufferVar = fx::LightingFX->GetVariableByName("gGBufferMap")->AsShaderResource();
m_lightDirVar = fx::LightingFX->GetVariableByName("gLigthDirES");
//final shading tech
m_shadingTech = fx::ShadingFX->GetTechniqueByName("ShadingTech");
m_diffuseVar = fx::ShadingFX->GetVariableByName("gDiffuseMap")->AsShaderResource();
m_lightingVar = fx::ShadingFX->GetVariableByName("gLightingMap")->AsShaderResource();
//gen shadow map
mDrawShadowMapTech = fx::DrawShadowMapFX->GetTechniqueByName("DrawShadowMapTech");
mfxDrawShadowMapTexVar = fx::DrawShadowMapFX->GetVariableByName("gShadowMap")->AsShaderResource();
//buildNDCQuad();
mShadowMap.init(md3dDevice, 2048, 2048, false, DXGI_FORMAT_UNKNOWN);
mClearColor = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f);
GetCamera().position() = D3DXVECTOR3(0.0f, 1.8f, -10.0f);
mFloorMapRV = GetTextureMgr().createTex(L"floor_diffuse.dds");
mFloorNormalMapRV = GetTextureMgr().createTex(L"floor_normal.dds");
mBaseMapRV = GetTextureMgr().createTex(L"stone_diffuse.dds");
mBaseNormalMapRV = GetTextureMgr().createTex(L"stone_normal.dds");
mBallMapRV = GetTextureMgr().createTex(L"blackdiffuse.dds");
mColumnMapRV = GetTextureMgr().createTex(L"bricks_diffuse.dds");
mColumnNormalMapRV = GetTextureMgr().createTex(L"bricks_normal.dds");
mSpecMapRV = GetTextureMgr().createTex(L"spec.dds");
mDefaultSpecMapRV = GetTextureMgr().createTex(L"defaultspec.dds");
mDefaultNormalMapRV = GetTextureMgr().createTex(L"default_normal.dds");
mEnvMapRV = GetTextureMgr().createCubeTex(L"grassenvmap1024.dds");
mFloor.init(md3dDevice, 41, 21, 1.0f);
mBase.init(md3dDevice, 2.0f);
mBall.init(md3dDevice, 0.5f, 30, 30);
mColumn.init(md3dDevice, 0.25f, 1.0f, 3.0f, 30, 30);
mSky.init(md3dDevice, mEnvMapRV, 5000.0f);
// direction updated at runtime
mParallelLight.ambient = D3DXCOLOR(0.3f, 0.3f, 0.3f, 1.0f);
mParallelLight.diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
mParallelLight.specular = D3DXCOLOR(0.5f, 0.5f, 0.5f, 1.0f);
m_pointLight.ambient = D3DXCOLOR(0.3f, 0.3f, 0.3f, 1.0f);
m_pointLight.diffuse = D3DXCOLOR(0.3f, 1.0f, 0.6f, 1.0f);
m_pointLight.specular = D3DXCOLOR(0.5f, 0.5f, 0.5f, 1.0f);
m_pointLight.pos = D3DXVECTOR3(0.0f, 2.0f,3.0f);
m_pointLight.att = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
m_pointLight.range = 3.0f;
m_pointLightMesh = new LightBoxMesh(md3dDevice, 50.0f);
D3DXCOLOR colors[] = {
WHITE,
RED,
GREEN,
BLUE,
YELLOW
};
for(int i = 0 ; i < 5; ++i)
{
float x = 2.5f * cosf(i*2*PI/5 );
float z = 2.5f * sinf(i*2*PI/5);
m_pointLights[i].ambient = D3DXCOLOR(0.3f, 0.3f, 0.3f, 1.0f);
m_pointLights[i].diffuse = colors[i];
m_pointLights[i].specular = D3DXCOLOR(0.5f, 0.5f, 0.5f, 1.0f);
m_pointLights[i].pos = D3DXVECTOR3(x, 2.0f, z);
m_pointLights[i].att = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
m_pointLights[i].range = 3.0f;
}
D3DXMatrixOrthoLH(&mLightVolume, 30.0f, 30.0f, 1.0f, 100.0f);
}
bool CDX10Renderer::Initialise(HINSTANCE _hInstance, HWND _hwnd, int _iClientWidth, int _iClientHeight)
{
m_hAppInst = _hInstance;
m_hMainWnd = _hwnd;
m_iTargetWidth = _iClientWidth;
m_iTargetHeight = _iClientHeight;
m_iClientWidth = _iClientWidth;
m_iClientHeight = _iClientHeight;
// Set up DX swap chain
DXGI_SWAP_CHAIN_DESC sd;
sd.BufferDesc.Width = m_iTargetWidth;
sd.BufferDesc.Height = m_iTargetHeight;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.BufferCount = 1;
sd.OutputWindow = m_hMainWnd;
sd.Windowed = true;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
sd.Flags = 0;
// Create DX10 device
UINT createDeviceFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)
createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;
#endif
// Create the ID3D10Device and IDXGISwapChain which interfaces
// with the D3D10CreateDeviceAndSwapChain function
if(FAILED(D3D10CreateDeviceAndSwapChain(0, //default adapter
D3D10_DRIVER_TYPE_HARDWARE,
0, // no software device
createDeviceFlags,
D3D10_SDK_VERSION,
&sd,
&m_pSwapChain,
&m_pDevice)))
{
MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK);
return (false);
}
// Create raster states. And set an initial state
D3D10_RASTERIZER_DESC rsDesc;
ZeroMemory(&rsDesc, sizeof(D3D10_RASTERIZER_DESC));
// Make backface cull solid and set this as initial state
rsDesc.FillMode = D3D10_FILL_SOLID;
rsDesc.CullMode = D3D10_CULL_BACK;
m_pDevice->CreateRasterizerState(&rsDesc, &m_pDefaultRasterState);
m_pDevice->RSSetState(m_pDefaultRasterState);
Resize(m_iClientWidth, m_iClientHeight);
// Load the effect
if (FAILED(D3DX10CreateEffectFromFile(L"default.fx",
0,
0,
"fx_4_0",
D3D10_SHADER_ENABLE_STRICTNESS,
0,
m_pDevice,
0, 0,
&m_pDefaultEffect,
0, 0)))
{
MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK);
return (false);
}
m_pDefaultTech = m_pDefaultEffect->GetTechniqueByName("DefaultTech");
// Create matrix effect pointers
m_pWorldMatrixEffectVariable = m_pDefaultEffect->GetVariableByName( "gWorld" )->AsMatrix();
m_pViewMatrixEffectVariable = m_pDefaultEffect->GetVariableByName( "gView" )->AsMatrix();
m_pProjectionMatrixEffectVariable = m_pDefaultEffect->GetVariableByName( "gProjection" )->AsMatrix();
// Vert layout
D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 }
};
UINT numElements = 2;
D3D10_PASS_DESC passDesc;
m_pDefaultTech->GetPassByIndex(0)->GetDesc(&passDesc);
if (FAILED(m_pDevice->CreateInputLayout(layout,
numElements,
passDesc.pIAInputSignature,
passDesc.IAInputSignatureSize,
&m_pDefaultVertexInputLayout ) ) )
{
MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK);
return (false);
};
// Set the input layout
m_pDevice->IASetInputLayout(m_pDefaultVertexInputLayout);
m_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
// Set effect values now because they will not change
D3DXMATRIX world;
D3DXMatrixIdentity(&world);
D3DXMatrixTranslation(&world, m_iClientWidth * -0.5f, m_iClientHeight * -0.5f, 0.0f);
D3DXMATRIX rot;
D3DXMatrixRotationX(&rot, static_cast<float>(D3DX_PI));
world = world * rot;
// Set up the view matrix
//--------------------------------------------------------------
D3DXVECTOR3 eye(0.0f, 0.0f, -1.0f);
D3DXVECTOR3 view(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX viewMatrix;
D3DXMatrixLookAtLH( &viewMatrix, &eye, &view, &up);
//Set up projection matrix
//--------------------------------------------------------------
D3DXMATRIX projectionMatrix;
D3DXMatrixOrthoLH(&projectionMatrix, static_cast<float>(m_iClientWidth), static_cast<float>(m_iClientHeight), 0.0f, 1.0f);
//D3DXMatrixPerspectiveFovLH(&projectionMatrix, (float)D3DX_PI * 0.5f, (float)m_iClientWidth/m_iClientHeight, 0.1f, 100.0f);
m_pWorldMatrixEffectVariable->SetMatrix(world);
m_pViewMatrixEffectVariable->SetMatrix(viewMatrix);
m_pProjectionMatrixEffectVariable->SetMatrix(projectionMatrix);
D3D10_TECHNIQUE_DESC techDesc;
m_pDefaultTech->GetDesc(&techDesc);
for(unsigned int p = 0; p < techDesc.Passes; ++p )
{
m_pDefaultTech->GetPassByIndex(p)->Apply(0);
}
//create vertex buffer (space for 100 vertices)
//---------------------------------------------
UINT numVertices = 100;
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DYNAMIC;
bd.ByteWidth = sizeof( TVertex ) * numVertices; //total size of buffer in bytes
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
if ( FAILED( m_pDevice->CreateBuffer( &bd, 0, &m_pVertexBuffer ) ) )
{
MessageBoxA(0, "Failed to create DX10 device.", "ERROR", MB_OK);
return (false);
}
PushPenColour(TColour(0, 0, 0, 255).Value());
PushBrushColour(TColour(0, 0, 0, 255).Value());
// Init font
D3DX10_FONT_DESC fontDesc;
fontDesc.Height = 16;
fontDesc.Width = 0;
fontDesc.Weight = 0;
fontDesc.MipLevels = 1;
fontDesc.Italic = false;
fontDesc.CharSet = DEFAULT_CHARSET;
fontDesc.OutputPrecision = OUT_DEFAULT_PRECIS;
fontDesc.Quality = DEFAULT_QUALITY;
fontDesc.PitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
wcscpy_s(fontDesc.FaceName, L"Times New Roman");
D3DX10CreateFontIndirect(m_pDevice, &fontDesc, &m_pFont);
D3DX10CreateSprite(m_pDevice, 512, &m_pSprite);
return(true);
}
/**
* Use the aspect ratio and the clipping planes of the camera to create the projection matrix used for rendering (by taking its inverse)
* This is called within camera functions every time the aspect ratio or clipping planes change
* @author Serge Radinovich
*/
void Camera::updateProjectionMatrix()
{
//Specify the field of view, aspect ration and near and far clipping planes.
//D3DXMatrixPerspectiveFovLH(&m_projMtx, (float)(D3DX_PI / 4.0), m_fAspectRatio, m_kfNearClip, m_kfFarClip);
D3DXMatrixOrthoLH(&m_projMtx, SCREEN_WIDTH_MAX / 13, SCREEN_HEIGHT_MAX / 13, m_kfNearClip, m_kfFarClip);
}
/*!
\b Parameters:
\arg \b pWidth Width
\arg \b pHeight Height
\arg \b pNearClippingPlane Near clipping plane
\arg \b pFarClippingPlane Far clipping plane
Operation:
This function sets a orthographic projection matrix.
Using this method is equivalent to using a combination of the methods of the class ::setCamera3d().
*/
void DirectXRender::perspectiveOrtho(float pWidth, float pHeight, float pNearClippingPlane, float pFarClippingPlane) {
D3DXMATRIX mMatProj;
D3DXMatrixOrthoLH(&mMatProj, pWidth, pHeight, pNearClippingPlane, pFarClippingPlane);
_info._device->SetTransform(D3DTS_PROJECTION, &mMatProj);
}
static void CalculateLisPSM( const CCameraEntity& cam, Light& light )
{
CalculateOrthoShadow( cam, light );
const SVector3& lightDir = light.mWorldMat.getAxisZ();
const SVector3& viewDir = cam.mWorldMat.getAxisZ();
double dotProd = lightDir.dot( viewDir );
if( fabs(dotProd) >= 0.999 )
{
// degenerates to uniform shadow map
return;
}
// calculate the hull of body B in world space
HullFace bodyB;
SMatrix4x4 invCamVP;
D3DXMatrixInverse( &invCamVP, NULL, &cam.mWorldMat );
invCamVP *= cam.getProjectionMatrix();
D3DXMatrixInverse( &invCamVP, NULL, &invCamVP );
CalculateFocusedLightHull( invCamVP, lightDir, gCasterBounds, bodyB );
int zzz = bodyB.v.size();
int i, j;
/*
Frustum camFrustum( cam.getProjectionMatrix() );
std::vector<SVector3> bodyB;
bodyB.reserve( gSceneCasters.size()*8 + 8 );
for( i = 0; i < 8; ++i )
bodyB.push_back( camFrustum.pntList[i] );
int ncasters = gSceneCasters.size();
for( i = 0; i < ncasters; ++i )
{
const CAABox& aabb = gSceneCasters[i].aabb;
for( j = 0; j < 8; ++j )
{
SVector3 p;
p.x = (j&1) ? aabb.getMin().x : aabb.getMax().x;
p.y = (j&2) ? aabb.getMin().y : aabb.getMax().y;
p.z = (j&4) ? aabb.getMin().z : aabb.getMax().z;
bodyB.push_back( p );
}
}
*/
// calculate basis of light space projection
SVector3 ly = -lightDir;
SVector3 lx = ly.cross( viewDir ).getNormalized();
SVector3 lz = lx.cross( ly );
SMatrix4x4 lightW;
lightW.identify();
lightW.getAxisX() = lx;
lightW.getAxisY() = ly;
lightW.getAxisZ() = lz;
SMatrix4x4 lightV;
D3DXMatrixInverse( &lightV, NULL, &lightW );
// rotate bound body points from world into light projection space and calculate AABB there
D3DXVec3TransformCoordArray( &bodyB.v[0], sizeof(SVector3), &bodyB.v[0], sizeof(SVector3), &lightV, bodyB.v.size() );
CAABox bodyLBounds;
bodyLBounds.setNull();
for( i = 0; i < bodyB.v.size(); ++i )
bodyLBounds.extend( bodyB.v[i] );
float zextent = cam.getZFar() - cam.getZNear();
float zLextent = bodyLBounds.getMax().z - bodyLBounds.getMin().z;
if( zLextent < zextent )
zextent = zLextent;
// calculate free parameter N
double sinGamma = sqrt( 1.0-dotProd*dotProd );
const double n = ( cam.getZNear() + sqrt(cam.getZNear() * (cam.getZNear() + zextent)) ) / sinGamma;
// origin in this light space: looking at center of bounds, from distance n
SVector3 lightSpaceO = bodyLBounds.getCenter();
lightSpaceO.z = bodyLBounds.getMin().z - n;
// go through bound points in light space, and compute projected bound
float maxx = 0.0f, maxy = 0.0f, maxz = 0.0f;
for( i = 0; i < bodyB.v.size(); ++i )
{
SVector3 tmp = bodyB.v[i] - lightSpaceO;
assert( tmp.z > 0.0f );
maxx = max( maxx, fabsf(tmp.x / tmp.z) );
maxy = max( maxy, fabsf(tmp.y / tmp.z) );
maxz = max( maxz, tmp.z );
}
SVector3 lpos;
D3DXVec3TransformCoord( &lpos, &lightSpaceO, &lightW );
lightW.getOrigin() = lpos;
SMatrix4x4 lightProj;
D3DXMatrixPerspectiveLH( &lightProj, 2.0f*maxx*n, 2.0f*maxy*n, n, maxz );
SMatrix4x4 lsPermute, lsOrtho;
lsPermute._11 = 1.f; lsPermute._12 = 0.f; lsPermute._13 = 0.f; lsPermute._14 = 0.f;
lsPermute._21 = 0.f; lsPermute._22 = 0.f; lsPermute._23 =-1.f; lsPermute._24 = 0.f;
lsPermute._31 = 0.f; lsPermute._32 = 1.f; lsPermute._33 = 0.f; lsPermute._34 = 0.f;
lsPermute._41 = 0.f; lsPermute._42 = -0.5f; lsPermute._43 = 1.5f; lsPermute._44 = 1.f;
D3DXMatrixOrthoLH( &lsOrtho, 2.f, 1.f, 0.5f, 2.5f );
lsPermute *= lsOrtho;
lightProj *= lsPermute;
G_RENDERCTX->getCamera().setCameraMatrix( lightW );
SMatrix4x4 lightFinal = G_RENDERCTX->getCamera().getViewMatrix() * lightProj;
// unit cube clipping
/*
{
// receiver hull
std::vector<SVector3> receiverPts;
receiverPts.reserve( gSceneReceivers.size() * 8 );
int nreceivers = gSceneReceivers.size();
for( i = 0; i < nreceivers; ++i )
{
const CAABox& aabb = gSceneReceivers[i].aabb;
for( j = 0; j < 8; ++j )
{
SVector3 p;
p.x = (j&1) ? aabb.getMin().x : aabb.getMax().x;
p.y = (j&2) ? aabb.getMin().y : aabb.getMax().y;
p.z = (j&4) ? aabb.getMin().z : aabb.getMax().z;
receiverPts.push_back( p );
}
}
// transform to light post-perspective space
D3DXVec3TransformCoordArray( &receiverPts[0], sizeof(SVector3), &receiverPts[0], sizeof(SVector3), &lightFinal, receiverPts.size() );
CAABox recvBounds;
recvBounds.setNull();
for( i = 0; i < receiverPts.size(); ++i )
recvBounds.extend( receiverPts[i] );
recvBounds.getMax().x = min( 1.f, recvBounds.getMax().x );
recvBounds.getMin().x = max(-1.f, recvBounds.getMin().x );
recvBounds.getMax().y = min( 1.f, recvBounds.getMax().y );
recvBounds.getMin().y = max(-1.f, recvBounds.getMin().y );
float boxWidth = recvBounds.getMax().x - recvBounds.getMin().x;
float boxHeight = recvBounds.getMax().y - recvBounds.getMin().y;
if( !FLT_ALMOST_ZERO(boxWidth) && !FLT_ALMOST_ZERO(boxHeight) )
{
float boxX = ( recvBounds.getMax().x + recvBounds.getMin().x ) * 0.5f;
float boxY = ( recvBounds.getMax().y + recvBounds.getMin().y ) * 0.5f;
SMatrix4x4 clipMatrix(
2.f/boxWidth, 0.f, 0.f, 0.f,
0.f, 2.f/boxHeight, 0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
-2.f*boxX/boxWidth, -2.f*boxY/boxHeight, 0.f, 1.f );
lightProj *= clipMatrix;
}
}
*/
G_RENDERCTX->getCamera().setProjectionMatrix( lightProj );
}
