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 ); }