void DXRenderer::InitializeDX(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 = 60, denominator = 1, stringLength; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; int error; DXGI_SWAP_CHAIN_DESC swapChainDesc; 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_fScreenDepth = _screenDepth; m_fScreenNear = _screenNear; // Store the vsync setting. m_bVSyncEnabled = _vsync; // Create a DirectX graphics interface factory. result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); if (FAILED(result)) { //return false; std::cout << "Error creating DXGIFactory" << std::endl; } // 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_iVideoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // Convert the name of the video card to a character array and store it. error = wcstombs_s(&stringLength, m_sVideoCardDescription, 128, adapterDesc.Description, 128); if (error != 0) { //return false; } std::cout << "Video Card: " << m_sVideoCardDescription << std::endl; //Ora si possono liberare tutti gli oggetti e strutture create per ottenere le informazioni sulla scheda video e refresh rate // 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; //Ora inizializziamo DirectX! //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_bVSyncEnabled) { swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator; swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator; } else { swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; 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; } //Proviamo senza questa roba avanzata // 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; D3D_FEATURE_LEVEL featureLevel[] = { // TODO: Modify for supported Direct3D feature levels (see code below related to 11.1 fallback handling) D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3, D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1, }; D3D_DRIVER_TYPE driverTypes[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_REFERENCE, D3D_DRIVER_TYPE_SOFTWARE, }; UINT numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]); D3D_DRIVER_TYPE g_driverType; for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; ++driverTypeIndex) { // Prova ad inizializzare per i tipi di driver definiti g_driverType = driverTypes[driverTypeIndex]; //result = D3D11CreateDevice(nullptr, g_driverType, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &m_device, nullptr, &m_deviceContext); result = D3D11CreateDeviceAndSwapChain(nullptr, g_driverType, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &swapChainDesc, &m_dSwapChain, &m_dDevice, nullptr, &m_dDeviceContext); // Appena funziona esci if (SUCCEEDED(result)) break; } if (FAILED(result)) { //return false; std::cout << "Error creating SwapChain" << std::endl; } else std::cout << "DirectX SwapChain created successfully." << std::endl; //D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0; //Creiamo la swapchain, il device e il 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)) { return false; } */ // Get the pointer to the back buffer. result = m_dSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr); if (FAILED(result)) { //return false; std::cout << "Error creating backbuffer" << std::endl; } // Create the render target view with the back buffer pointer. result = m_dDevice->CreateRenderTargetView(backBufferPtr, NULL, &m_dRenderTargetView); if (FAILED(result)) { //return false; std::cout << "Error creating Render Target View" << std::endl; } // Release pointer to the back buffer as we no longer need it. backBufferPtr->Release(); backBufferPtr = nullptr; // 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 = 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_dDevice->CreateTexture2D(&depthBufferDesc, NULL, &m_dDepthStencilBuffer); 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 = 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_dDevice->CreateDepthStencilState(&depthStencilDesc, &m_dDepthStencilState); if (FAILED(result)) { //return false; std::cout << "Error creating Depth Stencil State" << std::endl; } // Set the depth stencil state. m_dDeviceContext->OMSetDepthStencilState(m_dDepthStencilState, 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_dDevice->CreateDepthStencilView(m_dDepthStencilBuffer, &depthStencilViewDesc, &m_dDepthStencilView); if (FAILED(result)) { //return false; std::cout << "Error creating Depth Stencil View" << std::endl; } // Bind the render target view and depth stencil buffer to the output render pipeline. m_dDeviceContext->OMSetRenderTargets(1, &m_dRenderTargetView, m_dDepthStencilView); // 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_dDevice->CreateRasterizerState(&rasterDesc, &m_dRasterState); if (FAILED(result)) { //return false; } // Now set the rasterizer state. m_dDeviceContext->RSSetState(m_dRasterState); // 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_dDeviceContext->RSSetViewports(1, &viewport); // Setup the projection matrix. fieldOfView = (float)DirectX::XM_PI / 4.0f; screenAspect = (float)_screenWidth / (float)_screenHeight; //Create constant buffer for the vertex shader D3D11_BUFFER_DESC cbDesc; ZeroMemory(&cbDesc, sizeof(D3D11_BUFFER_DESC)); cbDesc.Usage = D3D11_USAGE_DEFAULT; cbDesc.ByteWidth = sizeof(GFX::ConstantObject); cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbDesc.CPUAccessFlags = 0; cbDesc.MiscFlags = 0; D3D11_SAMPLER_DESC sampDesc; ZeroMemory(&sampDesc, sizeof(sampDesc)); sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; sampDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; sampDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; sampDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; sampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; sampDesc.MinLOD = 0; sampDesc.MaxLOD = D3D11_FLOAT32_MAX; m_dDevice->CreateSamplerState(&sampDesc, &m_dSamplerState); m_dDevice->CreateBuffer(&cbDesc, NULL, &m_bConstObj); m_dDeviceContext->VSSetConstantBuffers(0, 1, &m_bConstObj); std::cout << "DirectX initialized successfully." << std::endl; }
/* Populate the imFileInfoRec8 structure describing this file instance to Premiere. Check file validity, allocate any private instance data to share between different calls. */ prMALError SDKGetInfo8( imStdParms *stdParms, imFileAccessRec8 *fileAccessInfo, imFileInfoRec8 *fileInfo) { prMALError result = malNoError; PrivateDataH pdH = reinterpret_cast<PrivateDataH>(fileInfo->privatedata); stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(pdH)); //Lock private data (*pdH)->flacErrorCode = 0; (*pdH)->flacDecoder = 0; char filepathASCII[255]; int stringLength = (int)wcslen(reinterpret_cast<const wchar_t*>(fileAccessInfo->filepath)); wcstombs_s( NULL, reinterpret_cast<char*>(filepathASCII), sizeof (filepathASCII), fileAccessInfo->filepath, stringLength); FLAC__bool ok = true; FLAC__StreamDecoderInitStatus init_status; if(((*pdH)->flacDecoder = FLAC__stream_decoder_new()) == NULL) { (*pdH)->flacErrorCode = 1; } FLAC__stream_decoder_set_md5_checking((*pdH)->flacDecoder, true); init_status = FLAC__stream_decoder_init_file((*pdH)->flacDecoder, filepathASCII, write_callback, NULL, error_callback, pdH); if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK ) { return imBadFile; //Error, bail out } FLAC__stream_decoder_process_until_end_of_metadata((*pdH)->flacDecoder); FLAC__stream_decoder_process_single((*pdH)->flacDecoder); (*pdH)->audioChannels = FLAC__stream_decoder_get_channels((*pdH)->flacDecoder); (*pdH)->audioNumberOfSamples = FLAC__stream_decoder_get_total_samples((*pdH)->flacDecoder); (*pdH)->audioNumberOfSamplesPerSecond = FLAC__stream_decoder_get_sample_rate((*pdH)->flacDecoder); (*pdH)->audioBytesPerSample = FLAC__stream_decoder_get_bits_per_sample((*pdH)->flacDecoder) / 8; (*pdH)->audioPosition = 0; //Fill out the general file info fileInfo->accessModes = kSeparateSequentialAudio; fileInfo->hasDataRate = kPrFalse; fileInfo->hasVideo = kPrFalse; fileInfo->hasAudio = kPrTrue; fileInfo->alwaysUnquiet = 0; fileInfo->highMemUsage = 0; fileInfo->audInfo.numChannels = (*pdH)->audioChannels; fileInfo->audInfo.sampleRate = (float)(*pdH)->audioNumberOfSamplesPerSecond; fileInfo->audDuration = (*pdH)->audioNumberOfSamples; if((*pdH)->audioBytesPerSample == 1) { fileInfo->audInfo.sampleType = kPrAudioSampleType_8BitInt; } else if((*pdH)->audioBytesPerSample == 2) { fileInfo->audInfo.sampleType = kPrAudioSampleType_16BitInt; } else if((*pdH)->audioBytesPerSample == 3) { fileInfo->audInfo.sampleType = kPrAudioSampleType_24BitInt; } else if((*pdH)->audioBytesPerSample == 4) { fileInfo->audInfo.sampleType = kPrAudioSampleType_32BitInt; } else { fileInfo->audInfo.sampleType = kPrAudioSampleType_Other; } (*pdH)->suiteBasic = stdParms->piSuites->utilFuncs->getSPBasicSuite(); //Allocate an audio suite if ((*pdH)->suiteBasic) { (*pdH)->suiteBasic->AcquireSuite (kPrSDKAudioSuite, kPrSDKAudioSuiteVersion, (const void**)&(*pdH)->suiteAudio); } stdParms->piSuites->memFuncs->unlockHandle(reinterpret_cast<char**>(pdH)); //Unlock private data return result; }
BOOL CWar3KeyApp::InitInstance() { // 如果一个运行在 Windows XP 上的应用程序清单指定要 // 使用 ComCtl32.dll 版本 6 或更高版本来启用可视化方式, //则需要 InitCommonControlsEx()。否则,将无法创建窗口。 INITCOMMONCONTROLSEX InitCtrls; InitCtrls.dwSize = sizeof(InitCtrls); // 将它设置为包括所有要在应用程序中使用的 // 公共控件类。 InitCtrls.dwICC = ICC_WIN95_CLASSES; InitCommonControlsEx(&InitCtrls); CWinApp::InitInstance(); AfxEnableControlContainer(); // 标准初始化 // 如果未使用这些功能并希望减小 // 最终可执行文件的大小,则应移除下列 // 不需要的特定初始化例程 // 更改用于存储设置的注册表项 // TODO: 应适当修改该字符串, // 例如修改为公司或组织名 SetRegistryKey(_T("应用程序向导生成的本地应用程序")); HANDLE hMapping; hMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,true,_T("War3KeyMappingShared")); if (!hMapping) hMapping = CreateFileMapping((HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,sizeof(KeyMappingInformation),_T("War3KeyMappingShared")); KeyMappingInformation *lpMapping = (KeyMappingInformation*)MapViewOfFile(hMapping,FILE_MAP_WRITE,0,0,0); if(!lpMapping) { MessageBox(0,_T("OpenFileMapping failed"),_T("Error"),0); return FALSE; } memset(lpMapping,0,sizeof(KeyMappingInformation)); int i; XMLNode xMainNode; FILE *f; CWar3KeyDlg dlg; f = fopen("config.xml","rt"); if(f==NULL) { f = fopen("config.xml","wt"); fwrite("<?War3 KeyMapper Configuration?>",strlen("<?War3 KeyMapper Configuration?>"),1,f); } fclose(f); xMainNode = XMLNode::openFileHelper(_T("config.xml")); InitializeCriticalSection(&(lpMapping->CriticalSection)); for (int i=0;i<xMainNode.nChildNode();i++) { lpMapping->OriginalKey[i] = _wtoi(xMainNode.getChildNode(i).getAttribute(_T("OriginalKey"))); lpMapping->MappedKey[i] = _wtoi(xMainNode.getChildNode(i).getAttribute(_T("MappedKey"))); lpMapping->nMappingCount++; } m_pMainWnd = &dlg; dlg.lpMapping = lpMapping; INT_PTR nResponse = dlg.DoModal(); if (nResponse == IDOK) { // TODO: 在此处放置处理何时用“确定”来关闭 // 对话框的代码 } Unhook(); xMainNode=XMLNode::createXMLTopNode(_T("War3 KeyMapper Configuration"),TRUE); XMLNode xNode; wchar_t txt[256]; for (i=0;i<lpMapping->nMappingCount;i++) { _itow(i,txt,10); xNode=xMainNode.addChild(txt); _itow(lpMapping->OriginalKey[i],txt,10); xNode.addAttribute(_T("OriginalKey"),txt); _itow(lpMapping->MappedKey[i],txt,10); xNode.addAttribute(_T("MappedKey"),txt); } wchar_t *t=xMainNode.createXMLString(TRUE); size_t converted,origsize = wcslen(t) + 1; char* buffer = (char *)malloc(origsize); wcstombs_s(&converted,buffer, origsize, t, _TRUNCATE); f = fopen("config.xml","wt"); fwrite(buffer,converted-1,1,f); fclose(f); free(buffer); free(t); DeleteCriticalSection(&(lpMapping->CriticalSection)); UnmapViewOfFile(lpMapping); CloseHandle(hMapping); // 由于对话框已关闭,所以将返回 FALSE 以便退出应用程序, // 而不是启动应用程序的消息泵。 return FALSE; }
LRESULT CALLBACK EncProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp){ PAINTSTRUCT ps; static HWND hButton; HDC hdc, hMdc; TCHAR buf[256]; static int flag = 0; static WCHAR chr[MAXLENGTH + MAX_PATH]; char filename[MAXLENGTH + MAX_PATH], outfilename[MAXLENGTH + MAX_PATH] = { '\0' }; static BITMAP bm; static OPENFILENAME ofn = { 0 }; static TCHAR strFile[MAX_PATH], strCustom[256] = TEXT("Before files\0*.*\0\0"); static HBITMAP hBitmap; switch (msg){ case WM_CREATE: ofn.lStructSize = sizeof(OPENFILENAME); ofn.hwndOwner = hWnd; ofn.lpstrFilter = TEXT("Bitmap files {*.bmp}\0*.bmp\0") /*TEXT("他のファイルも同様の形式で")*/; ofn.lpstrCustomFilter = strCustom; ofn.nMaxCustFilter = 256; ofn.nFilterIndex = 0; ofn.lpstrFile = strFile; ofn.nMaxFile = MAX_PATH; ofn.Flags = OFN_FILEMUSTEXIST; GetOpenFileName(&ofn); // プッシュボタンを作成する hButton = CreateWindow( _T("BUTTON"), // ウィンドウクラス名 _T("GO"), // キャプション WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, // スタイル指定 bm.bmWidth + 20, 200, // 座標 60, 40, // サイズ hWnd, // 親ウィンドウのハンドル (HMENU)BUTTON_ID, // メニューハンドル ((LPCREATESTRUCT)lp)->hInstance, // インスタンスハンドル NULL // その他の作成データ ); break; case WM_PAINT: hdc = BeginPaint(hWnd, &ps); // 描画処理を開始します。 SetBkMode(hdc, TRANSPARENT); // 背景を透過モードにします if (flag==0){ hBitmap = (HBITMAP)LoadImage(NULL, (LPCWSTR)ofn.lpstrFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE); //エラー処理 if (hBitmap == NULL){ MessageBox(hWnd, TEXT("FailedToOpenFile"), TEXT("はい..."), MB_OK); PostMessage(hWnd, WM_CLOSE, 0, 0); EndPaint(hWnd, &ps); break; } hMdc = CreateCompatibleDC(hdc); SelectObject(hMdc, hBitmap); GetObject(hBitmap, sizeof(BITMAP), &bm); BitBlt(hdc, 5, 5, bm.bmWidth, bm.bmHeight, hMdc, 0, 0, SRCCOPY); } else{ //ひらいた画像ファイルを表示 hBitmap = (HBITMAP)LoadImage(NULL, (LPCWSTR)chr, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE); if (hBitmap == NULL){ MessageBox(hWnd, TEXT("FailedToOpenFileofOutput"), TEXT("はい..."), MB_OK); PostMessage(hWnd, WM_CLOSE, 0, 0); EndPaint(hWnd, &ps); break; } hMdc = CreateCompatibleDC(hdc); SelectObject(hMdc, hBitmap); if (!BitBlt(hdc, bm.bmWidth + 100, 5, bm.bmWidth, bm.bmHeight, hMdc, 0, 0, SRCCOPY)) MessageBox(hWnd, TEXT("FailedTobitbltofoutput"), TEXT("はい..."), MB_OK); } MoveWindow( hButton, // ウィンドウのハンドル bm.bmWidth + 25, // 横方向の位置 200, // 縦方向の位置 60, // 幅 40, // 高さ false // 再描画オプション ); /* DeleteDC(hMdc); DeleteObject(hBitmap); EndPaint(hWnd, &ps);*/ break; case WM_COMMAND: GetClassName(hWnd, buf, 255); switch (LOWORD(wp)){ case BUTTON_ID: setlocale(LC_ALL, "japanese"); //ひらいた画像ファイルを表示 wcstombs_s(0, filename, MAXLENGTH + MAX_PATH, ofn.lpstrFile, _TRUNCATE); if (!Encryption(filename)){ MessageBox(hWnd, TEXT("4545"), TEXT("変換に失敗した..."), MB_OK); return -1; } else{ wcscpy(chr,ofn.lpstrFile); wcscat(chr,_T("_conv.bmp")); ++flag; //ここでスイッチを切れ変える。 flag &= 1; InvalidateRect( hWnd, // ウィンドウのハンドル NULL, // 長方形の座標 false // 消去するかどうかの状態 ); } break; default: return (DefWindowProc(hWnd, msg, wp, lp)); } break; case WM_DESTROY: PostQuitMessage(0); break; default: return (DefWindowProc(hWnd, msg, wp, lp)); } return 0; }
HRESULT CreateLibraryByteCodeHeader(LPCOLESTR fileContents, BYTE * contentsRaw, DWORD lengthBytes, LPCWSTR bcFullPath, LPCWSTR libraryNameWide) { HRESULT hr = S_OK; HANDLE bcFileHandle = nullptr; BYTE *bcBuffer = nullptr; DWORD bcBufferSize = 0; IfFailGo(GetSerializedBuffer(fileContents, &bcBuffer, &bcBufferSize)); bcFileHandle = CreateFile(bcFullPath, GENERIC_WRITE, FILE_SHARE_DELETE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if (bcFileHandle == INVALID_HANDLE_VALUE) { IfFailGo(E_FAIL); } DWORD written; // For validating the header file against the library file auto outputStr = "//-------------------------------------------------------------------------------------------------------\r\n" "// Copyright (C) Microsoft. All rights reserved.\r\n" "// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.\r\n" "//-------------------------------------------------------------------------------------------------------\r\n" "#if 0\r\n"; IfFalseGo(WriteFile(bcFileHandle, outputStr, (DWORD)strlen(outputStr), &written, nullptr)); IfFalseGo(WriteFile(bcFileHandle, contentsRaw, lengthBytes, &written, nullptr)); if (lengthBytes < 2 || contentsRaw[lengthBytes - 2] != '\r' || contentsRaw[lengthBytes - 1] != '\n') { outputStr = "\r\n#endif\r\n"; } else { outputStr = "#endif\r\n"; } IfFalseGo(WriteFile(bcFileHandle, outputStr, (DWORD)strlen(outputStr), &written, nullptr)); // Write out the bytecode outputStr = "namespace Js\r\n{\r\n const char Library_Bytecode_"; IfFalseGo(WriteFile(bcFileHandle, outputStr, (DWORD)strlen(outputStr), &written, nullptr)); size_t convertedChars; char libraryNameNarrow[MAX_PATH + 1]; IfFalseGo((wcstombs_s(&convertedChars, libraryNameNarrow, libraryNameWide, _TRUNCATE) == 0)); IfFalseGo(WriteFile(bcFileHandle, libraryNameNarrow, (DWORD)strlen(libraryNameNarrow), &written, nullptr)); outputStr = "[] = {\r\n/* 00000000 */"; IfFalseGo(WriteFile(bcFileHandle, outputStr, (DWORD)strlen(outputStr), &written, nullptr)); for (unsigned int i = 0; i < bcBufferSize; i++) { char scratch[6]; auto scratchLen = sizeof(scratch); int num = _snprintf_s(scratch, scratchLen, " 0x%02X", bcBuffer[i]); Assert(num == 5); IfFalseGo(WriteFile(bcFileHandle, scratch, (DWORD)(scratchLen - 1), &written, nullptr)); // Add a comma and a space if this is not the last item if (i < bcBufferSize - 1) { char commaSpace[2]; _snprintf_s(commaSpace, sizeof(commaSpace), ","); // close quote, new line, offset and open quote IfFalseGo(WriteFile(bcFileHandle, commaSpace, (DWORD)strlen(commaSpace), &written, nullptr)); } // Add a line break every 16 scratches, primarily so the compiler doesn't complain about the string being too long. // Also, won't add for the last scratch if (i % 16 == 15 && i < bcBufferSize - 1) { char offset[17]; _snprintf_s(offset, sizeof(offset), "\r\n/* %08X */", i + 1); // close quote, new line, offset and open quote IfFalseGo(WriteFile(bcFileHandle, offset, (DWORD)strlen(offset), &written, nullptr)); } } outputStr = "};\r\n\r\n"; IfFalseGo(WriteFile(bcFileHandle, outputStr, (DWORD)strlen(outputStr), &written, nullptr)); outputStr = "}\r\n"; IfFalseGo(WriteFile(bcFileHandle, outputStr, (DWORD)strlen(outputStr), &written, nullptr)); Error: if (bcFileHandle != nullptr) { CloseHandle(bcFileHandle); } if (bcBuffer != nullptr) { delete[] bcBuffer; } return hr; }
void ServiceMain(int argc, char** argv) { ServiceStatus.dwServiceType = SERVICE_WIN32; ServiceStatus.dwCurrentState = SERVICE_START_PENDING; ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; ServiceStatus.dwWin32ExitCode = 0; ServiceStatus.dwServiceSpecificExitCode = 0; ServiceStatus.dwCheckPoint = 0; ServiceStatus.dwWaitHint = 0; if (isService) { hStatus = RegisterServiceCtrlHandler(HSP_SERVICE_NAME, (LPHANDLER_FUNCTION)ControlHandler); if (hStatus == 0) { return; } } // Test for only one instance is running HANDLE mutex = CreateMutex(NULL, TRUE, instanceMutexName); DWORD err = GetLastError(); if (mutex != NULL && err == ERROR_ALREADY_EXISTS || mutex == NULL && err == ERROR_ACCESS_DENIED) { // Mutex found, so another instance is running if (hStatus != 0) { ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwWin32ExitCode = ERROR_SINGLE_INSTANCE_APP; SetServiceStatus(hStatus, &ServiceStatus); } else { myLog(LOG_ERR, "%s.ServiceMain: only one instance can run, existing instance found", HSP_SERVICE_NAME); } return; } else { ServiceStatus.dwCurrentState = SERVICE_RUNNING; if (hStatus != 0) { // We are the first instance, report the running status to SCM. SetServiceStatus (hStatus, &ServiceStatus); } } wchar_t programDataDir[MAX_PATH]; if (!initialiseProgramDataDir(programDataDir, MAX_PATH)) { *programDataDir = NULL; } char mbcLogFilename[MAX_PATH]; if (isService && *programDataDir != NULL) { //set the log file name to the default. size_t dirLen = 0; if (0 == wcstombs_s(&dirLen, mbcLogFilename, MAX_PATH, programDataDir, wcslen(programDataDir))) { PathAppend(mbcLogFilename, HSP_DEFAULT_LOGFILE); logFilename = mbcLogFilename; } else { logFilename = NULL; } } if (logFilename != NULL) { // Logging on errno_t error = fopen_s(&logFile, logFilename, "wt"); if (error != 0) { logFile = stderr; myLog(LOG_ERR, "%s.ServiceMain: could not open log file %s: error %d\n", HSP_SERVICE_NAME, logFilename, error); } logFilename = NULL; } myLog(debug, "-------------Starting %s %s--------------", HSP_SERVICE_NAME, HSP_VERSION); fflush(logFile); HRESULT initComHr = initCom(); if (FAILED(initComHr)) { myLog(LOG_ERR, "%s.ServiceMain: cannot initialize COM for WMI error=0x%x", HSP_SERVICE_NAME, initComHr); if (hStatus != 0) { ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwWin32ExitCode = ERROR_APP_INIT_FAILURE; SetServiceStatus(hStatus, &ServiceStatus); } return; } HSP sp = { 0 }; sp.DNSSD_startDelay = HSP_DEFAULT_DNSSD_STARTDELAY; sp.DNSSD_retryDelay = HSP_DEFAULT_DNSSD_RETRYDELAY; // look up host-id fields at startup only (hostname // may change dynamically so will have to revisit this $$$) sp.host_hid.hostname.str = (char *)my_calloc(SFL_MAX_HOSTNAME_CHARS+1); sp.host_hid.os_release.str = (char *)my_calloc(SFL_MAX_OSRELEASE_CHARS+1); readHidCounters(&sp, &sp.host_hid); sp.nio_polling_secs = HSP_NIO_POLLING_SECS_32BIT; readInterfaces(&sp, TRUE); if (!readConfig(&sp)) { myLog(LOG_ERR, "%s.ServiceMain: invalid configuration", HSP_SERVICE_NAME); if (hStatus != 0) { ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwWin32ExitCode = ERROR_INVALID_PARAMETER; SetServiceStatus(hStatus, &ServiceStatus); } return; } sp.hyperV = testForHyperv(); if (sp.hyperV) { myLog(debug, "%s.ServiceMain Hyper-V services are running", HSP_SERVICE_NAME); if (programDataDir == NULL || !initialiseProgramDataFiles(&sp, programDataDir)) { myLog(LOG_ERR, "%s.ServiceMain: cannot initialise switch port and VM state files", HSP_SERVICE_NAME); if (hStatus != 0) { ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwWin32ExitCode = ERROR_FILE_NOT_FOUND; SetServiceStatus(hStatus, &ServiceStatus); } return; } readGuidStore(sp.f_vmStore, sp.vmStoreFile, &sp.vmStore, &sp.maxDsIndex); readGuidStore(sp.f_portStore, sp.portStoreFile, &sp.portStore, &sp.maxIfIndex); } if (sp.DNSSD) { //start the DNS thread and loop waiting until we have the config from DNSSD HANDLE dnsSDThread; unsigned threadID; dnsSDThread = (HANDLE)_beginthreadex(NULL, 0, &runDNSSD, &sp, 0, &threadID); BOOL gotConfig = FALSE; while (!gotConfig) { HSPSFlowSettings *settings = sp.sFlow->sFlowSettings; if (newerSettingsAvailable(settings)) { HSPSFlowSettings *newSettings = newSFlowSettings(); if (readSFlowSettings(newSettings)) { //we have the config now gotConfig = TRUE; if (settings != NULL) { freeSFlowSettings(settings); } sp.sFlow->sFlowSettings = newSettings; myLog(debug, "%s.ServiceMain: DNS-SD enabled. Initial sFlow settings from registry currentconfig", HSP_SERVICE_NAME); } else { freeSFlowSettings(newSettings); myLog(LOG_ERR, "%s.ServiceMain: invalid DNS-SD discovered sFlow settings", HSP_SERVICE_NAME); if (hStatus != 0) { ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwWin32ExitCode = ERROR_INVALID_PARAMETER; SetServiceStatus(hStatus, &ServiceStatus); } return; } } else { Sleep(sp.DNSSD_startDelay*1000); } } } else { // read the manual config HSPSFlowSettings *newSettings = newSFlowSettings(); if (readSFlowSettings(newSettings)) { sp.sFlow->sFlowSettings = newSettings; } else { myLog(LOG_ERR, "%s.ServiceMain: invalid sFlow configuration in registry", HSP_SERVICE_NAME); if (hStatus != 0) { ServiceStatus.dwCurrentState = SERVICE_STOPPED; ServiceStatus.dwWin32ExitCode = ERROR_INVALID_PARAMETER; SetServiceStatus(hStatus, &ServiceStatus); } return; } } openFilter(&sp); //try to initialise the sFlow filter for sampling initAgent(&sp); logSFlowSettings(sp.sFlow); // initialize the clock so we can detect second boundaries sp.clk = time(NULL); // main loop BOOL dataAvailable = true; uint32_t currReadNum = 0; while (ServiceStatus.dwCurrentState == SERVICE_RUNNING && dataAvailable) { // check for second boundaries and generate ticks for the sFlow library time_t now = time(NULL); if ((now < sp.clk) || (now - sp.clk) > HSP_MAX_TICKS) { // avoid a busy-loop of ticks if time jumps myLog(LOG_INFO, "%s.ServiceMain: time jump detected", HSP_SERVICE_NAME); sp.clk = now - 1; } while (sp.clk < now) { //only happens on second boundary //start critical if (sp.sFlow->sFlowSettings) { if (sp.clk%5 == 0 && newerSettingsAvailable(sp.sFlow->sFlowSettings)) { //get the new config HSPSFlowSettings *newSettings = newSFlowSettings(); if (readSFlowSettings(newSettings)) { //we have the config now BOOL pollingChanged = sp.sFlow->sFlowSettings->pollingInterval != newSettings->pollingInterval; BOOL samplingChanged = sp.sFlow->sFlowSettings->samplingRate != newSettings->samplingRate; freeSFlowSettings(sp.sFlow->sFlowSettings); sp.sFlow->sFlowSettings = newSettings; myLog(debug, "%s.ServiceMain: updated configuration settings", HSP_SERVICE_NAME); logSFlowSettings(sp.sFlow); if (pollingChanged) { for (SFLPoller *poller = sp.sFlow->agent->pollers; poller; poller = poller->nxt) { sfl_poller_set_sFlowCpInterval(poller, sp.sFlow->sFlowSettings->pollingInterval); } } if (samplingChanged && HSP_FILTER_ACTIVE(sp.filter)) { setFilterSamplingParams(&sp); } } else { freeSFlowSettings(newSettings); } } tick(&sp); } //end critical sp.clk++; } DWORD result; //process a queued counter poller processQueuedPoller(&sp); //timeout is set so that we loop around checking for ticks and samples //several times/s. //calculate timeout 200 if the counter poller queue is empty, 0 otherwise DWORD timeout = sp.pollerQHead == NULL ? HSP_TIMEOUT : 0; if (HSP_FILTER_ACTIVE(sp.filter)) { result = WaitForSingleObject(sp.filter.overlaps[currReadNum].hEvent, timeout); if (result == WAIT_OBJECT_0) { dataAvailable = sp.filter.overlaps[currReadNum].Internal == ERROR_SUCCESS; if (dataAvailable && sp.filter.overlaps[currReadNum].InternalHigh > 0) { //process the sample info in sp.filter.buffers[currReadNum] readPackets(&sp, sp.filter.buffers[currReadNum]); } // Re-queue this read queueRead(sp.filter.dev, sp.filter.buffers[currReadNum], sizeof(sp.filter.buffers[currReadNum]), &sp.filter.overlaps[currReadNum]); //set the next buffer to read currReadNum = (currReadNum+1)%numConcurrentReads; } } else { Sleep(timeout); } } return; }
DWORD ReceiveUpdates(CDisdrawDlg *pDrawDlg) { // // Prepare the message properties to receive. // DWORD cProps = 0; MQMSGPROPS propsMessage; MQPROPVARIANT aPropVar[2]; MSGPROPID aPropId[2]; WCHAR wcsBody[MAX_MSG_BODY_LEN+1]; aPropId[cProps] = PROPID_M_BODY; aPropVar[cProps].vt = VT_UI1 | VT_VECTOR; aPropVar[cProps].caub.cElems = sizeof(wcsBody); aPropVar[cProps].caub.pElems = (UCHAR *)wcsBody; cProps++; aPropId[cProps] = PROPID_M_BODY_SIZE; aPropVar[cProps].vt = VT_UI4; cProps++; propsMessage.cProp = cProps; propsMessage.aPropID = aPropId; propsMessage.aPropVar = aPropVar; propsMessage.aStatus = NULL; // // Keep receiving updates sent to the incoming queue. // HRESULT hr; LINE line; char mbsBody[MAX_MSG_BODY_LEN + 1]; while (TRUE) { // // Synchronously receive a message from the incoming queue. // hr = MQReceiveMessage(pDrawDlg->m_hqIncoming, INFINITE, MQ_ACTION_RECEIVE, &propsMessage, NULL, NULL, NULL, NULL); // // Determine if the message contains a keystroke or a line. // if (!FAILED(hr)) { // // Convert the body to a multibyte null-terminated string. // UINT uNumChars = aPropVar[1].ulVal/sizeof(WCHAR); size_t nResultedStringLength=0; wcstombs_s( &nResultedStringLength, mbsBody, sizeof(mbsBody), wcsBody, uNumChars ); // // Add the keystroke to the drawing. // if (uNumChars == 1) { pDrawDlg->m_drawScribble.AddKeystroke(mbsBody); } // // Add the line received to the drawing. // else { sscanf_s(mbsBody, "%07ld%07ld%07ld%07ld", &line.ptStart.x, &line.ptStart.y, &line.ptEnd.x, &line.ptEnd.y); pDrawDlg->m_drawScribble.AddLine(line); } } } return 0; }
bool D3DManager::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; D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc; D3D11_BLEND_DESC blendStateDescription; std::vector<IDXGIAdapter*> vAdapters; int largestAdapter = 0; int videoCardMemory; // Store our screen width and height m_ScreenWidth = screenWidth; m_ScreenHeight = screenHeight; // Store the vsync setting. m_vsync_enabled = vsync; // Create a DirectX graphics interface factory. result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to create a DXGI factory."); return false; } // Loop through each adapter on the computer for(UINT i = 0; factory->EnumAdapters(i, &adapter) != DXGI_ERROR_NOT_FOUND; ++i) { // Store the adapter vAdapters.push_back(adapter); // Get the adapter (video card) description. result = adapter->GetDesc(&adapterDesc); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to get the video card description."); return false; } // Store the dedicated video card memory in megabytes. videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // If the memory is larger than our current memory, save this index if(videoCardMemory > m_videoCardMemory) { m_videoCardMemory = videoCardMemory; largestAdapter = i; // 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) { log_sxerror("D3DManager", "Failed to get the name of the graphics card."); return false; } } } // Enumerate the primary adapter output (monitor). result = vAdapters.at(0)->EnumOutputs(0, &adapterOutput); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to grab 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)) { log_sxerror("D3DManager", "Failed to get a list 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) { log_sxerror("D3DManager", "Failed to create a display mode list for the monitor/gfx card combo."); 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)) { log_sxerror("D3DManager", "Failed to fill the display mode list structures."); 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; } } } // Release the display mode list. delete [] displayModeList; displayModeList = 0; // Release the adapter output. adapterOutput->Release(); adapterOutput = 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 = 60;//numerator; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;//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; //swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL; // Don't set the advanced flags. swapChainDesc.Flags = 0; // Grab the highest feature level result = D3D11CreateDevice(vAdapters.at(largestAdapter), D3D_DRIVER_TYPE_UNKNOWN, NULL, 0, NULL, 0, D3D11_SDK_VERSION, NULL, &featureLevel, NULL ); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to retrieve the featurelevel."); ErrorDescription(result); // Try to use the default adapter largestAdapter = 0; result = D3D11CreateDevice(vAdapters.at(largestAdapter), D3D_DRIVER_TYPE_UNKNOWN, NULL, 0, NULL, 0, D3D11_SDK_VERSION, NULL, &featureLevel, NULL ); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to retrieve the featurelevel the second time."); ErrorDescription(result); return false; } } #ifdef _DEBUG // Create the swap chain, Direct3D device, and Direct3D device context. result = D3D11CreateDeviceAndSwapChain(vAdapters.at(largestAdapter), D3D_DRIVER_TYPE_UNKNOWN, NULL, D3D11_CREATE_DEVICE_DEBUG | D3D11_CREATE_DEVICE_BGRA_SUPPORT , &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to create the Direct3D device, context, and swap chain."); return false; } result = m_device->QueryInterface((IID)IID_ID3D11Debug, (void**)&m_Debug); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to create a debugging interface for the device. Debugging may not work"); } else { result = m_Debug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to enable detailed object reporting."); } } #else // Create the swap chain, Direct3D device, and Direct3D device context. result = D3D11CreateDeviceAndSwapChain(vAdapters.at(largestAdapter), D3D_DRIVER_TYPE_UNKNOWN, NULL, D3D11_CREATE_DEVICE_BGRA_SUPPORT , &featureLevel, 1, D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to create the Direct3D device, context, and swap chain."); return false; } #endif // Release each adapter. for(auto it = vAdapters.begin(); it != vAdapters.end(); ++it) { (*it)->Release(); (*it) = 0; } // Get the pointer to the back buffer. result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to get a pointer to 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)) { log_sxerror("D3DManager", "Failed to create the render target view."); 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 = 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)) { log_sxerror("D3DManager", "Failed to create 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)) { log_sxerror("D3DManager", "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)) { log_sxerror("D3DManager", "Failed to create the 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)) { log_sxerror("D3DManager", "Failed to create the rasterizer state."); return false; } // Now set the rasterizer state. m_deviceContext->RSSetState(m_rasterState); // 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); // Setup the projection matrix. fieldOfView = (float)XM_PI / 4.0f; assert(screenWidth != 0); assert(screenHeight != 0); screenAspect = (float)screenWidth / (float)screenHeight; // Create the projection matrix for 3D rendering. XMStoreFloat4x4(&m_projectionMatrix, XMMatrixPerspectiveFovLH(fieldOfView, screenAspect, screenNear, screenDepth)); // Initialize the world and view matrix to the identity matrix. XMStoreFloat4x4(&m_worldMatrix, XMMatrixIdentity()); XMStoreFloat4x4(&m_viewMatrix, XMMatrixIdentity()); // Create an orthographic projection matrix for 2D rendering. XMStoreFloat4x4(&m_orthoMatrix, XMMatrixOrthographicLH((float)screenWidth, (float)screenHeight, screenNear, screenDepth)); // 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)) { log_sxerror("D3DManager", "Failed to create the depth disabled stencil state."); return false; } // 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; //blendStateDescription.RenderTarget[0].BlendEnable = true; //blendStateDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_COLOR; // This one f***s by adding white //blendStateDescription.RenderTarget[0].DestBlend = D3D11_BLEND_DEST_COLOR; // This one produces fail whale, dusky background, lite trees //blendStateDescription.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; //blendStateDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA; //blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_DEST_ALPHA; //blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; //blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 7; // Create the blend state using the description. result = m_device->CreateBlendState(&blendStateDescription, &m_alphaEnableBlendingState); if(FAILED(result)) { log_sxerror("D3DManager", "Failed to create the alpha blending 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)) { log_sxerror("D3DManager", "Failed to create the alpha disabled blending state."); return false; } return true; }
bool RenderCore::Init(int screenWidth, int screenHeight, HWND hWnd) { HRESULT hr; IDXGIAdapter1 *adapter; IDXGIOutput *adapterOutput; IDXGIOutput1 *adapterOutput1; DXGI_ADAPTER_DESC adapterDesc; DXGI_MODE_DESC *displayModeList; DXGI_SWAP_CHAIN_DESC swapChainDesc; ID3D11Texture2D *pBackBuffer; D3D11_TEXTURE2D_DESC depthBufferDesc; D3D11_DEPTH_STENCIL_DESC depthStencilDesc; D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc; D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; D3D11_RASTERIZER_DESC rasterDesc; uint32_t numModes, fpsNumerator, fpsDenominator; size_t stringLength; int error; float fov, aspect; if (!EnumerateDisplayAdapters(&g_DXGIAdapters)) { return false; } adapter = g_DXGIAdapters.at(0); hr = adapter->EnumOutputs(0, &adapterOutput); if (FAILED(hr)) { return false; } // desktop duplication stuff hr = adapterOutput->QueryInterface(&adapterOutput1); hr = adapterOutput1->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, nullptr); if (FAILED(hr)) { return false; } displayModeList = new DXGI_MODE_DESC[numModes]; if (!displayModeList) { return false; } hr = adapterOutput1->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); if (FAILED(hr)) { return false; } for (UINT i = 0; i < numModes; i++) { if (displayModeList[i].Width == (unsigned int)screenWidth) { if (displayModeList[i].Height == (unsigned int)screenHeight) { fpsNumerator = displayModeList[i].RefreshRate.Numerator; fpsDenominator = displayModeList[i].RefreshRate.Denominator; } } } hr = adapter->GetDesc(&adapterDesc); if (FAILED(hr)) { return false; } // retrieve video adapter memory and name m_VideoMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); error = wcstombs_s(&stringLength, m_VideoCardDesc, 128, adapterDesc.Description, 128); if (error != 0) { return false; } DebugOut("Found graphics adapter: %s (%dMB VRAM)\n", m_VideoCardDesc, m_VideoMemory); delete[] displayModeList; displayModeList = nullptr; adapterOutput->Release(); adapter->Release(); // set single back buffer ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = screenWidth; swapChainDesc.BufferDesc.Height = screenHeight; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swapChainDesc.BufferDesc.RefreshRate.Numerator = 60; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = hWnd; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; 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 swap chain, direct3d device, and d3d context uint32_t deviceFlags = 0; #define D3D_DEVICE_DEBUG #ifdef D3D_DEVICE_DEBUG deviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, }; uint32_t numFeatureLevels = ARRAYSIZE(featureLevels); hr = D3D11CreateDeviceAndSwapChain( nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, deviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &swapChainDesc, &m_SwapChain, &m_d3d11Device, nullptr, &m_d3d11DeviceContext); if (FAILED(hr)) { DebugOut("D3D11CreateDeviceAndSwapChain failed!\n"); return false; } // enable multithreaded device context protection ID3D10Multithread *contextMT = nullptr; m_d3d11DeviceContext->QueryInterface(&contextMT); if (contextMT) { contextMT->SetMultithreadProtected(true); contextMT->Release(); } else { DebugOut("Fatal error! ID3D10Multithread::SetMultithreadProtected for D3D11 device context failed!\n"); return false; } // get pointer to the back buffer hr = m_SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID *)&pBackBuffer); if (FAILED(hr)) { DebugOut("IDXGISwapChain::GetBuffer failed!\n"); return false; } // create render target view from back buffer hr = m_d3d11Device->CreateRenderTargetView(pBackBuffer, nullptr, &m_d3d11RenderTargetView); if (FAILED(hr)) { DebugOut("ID3D11Device::CreateRenderTargetView failed!\n"); return false; } pBackBuffer->Release(); // set up depth buffer description 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 hr = m_d3d11Device->CreateTexture2D(&depthBufferDesc, nullptr, &m_d3d11DepthStencilBuffer); if (FAILED(hr)) { DebugOut("ID3D11Device::CreateTexture2D failed! Could not create texture for depth buffer.\n"); return false; } // set up description of stencil state ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc)); depthStencilDesc.DepthEnable = true; // z-buffer enabled 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 hr = m_d3d11Device->CreateDepthStencilState(&depthStencilDesc, &m_d3d11DepthStencilState); if (FAILED(hr)) { DebugOut("ID3D11Device::CreateDepthStencilState failed!\n"); return false; } // 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. hr = m_d3d11Device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_d3d11DepthStencilDisabledState); if (FAILED(hr)) { return false; } // disable the Z-Buffer ZBufferState(0); // set up depth stencil view description 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 hr = m_d3d11Device->CreateDepthStencilView(m_d3d11DepthStencilBuffer, &depthStencilViewDesc, &m_d3d11DepthStencilView); if (FAILED(hr)) { DebugOut("ID3D11Device::CreateDepthStencilView failed!\n"); return false; } // bind render target view and depth stencil buffer to the output render pipeline m_d3d11DeviceContext->OMSetRenderTargets(1, &m_d3d11RenderTargetView, m_d3d11DepthStencilView); // set up rasterizer description rasterDesc.AntialiasedLineEnable = false; rasterDesc.CullMode = D3D11_CULL_NONE; rasterDesc.DepthBias = 0; rasterDesc.DepthBiasClamp = 0.0f; rasterDesc.DepthClipEnable = false; rasterDesc.FillMode = D3D11_FILL_SOLID; rasterDesc.FrontCounterClockwise = false; rasterDesc.MultisampleEnable = false; rasterDesc.ScissorEnable = false; rasterDesc.SlopeScaledDepthBias = 0.0f; // create the rasterizer hr = m_d3d11Device->CreateRasterizerState(&rasterDesc, &m_d3d11RasterState); if (FAILED(hr)) { DebugOut("ID3D11Device::CreateRasterizerState failed!"); return false; } m_d3d11DeviceContext->RSSetState(m_d3d11RasterState); // set up 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; // create the viewport m_d3d11DeviceContext->RSSetViewports(1, &viewport); fov = (float)PI / 4.0f; aspect = (float)screenWidth / (float)screenHeight; m_ProjectionMatrix = DirectX::XMMatrixPerspectiveFovLH(fov, aspect, SCREEN_NEAR, SCREEN_DEPTH); m_WorldMatrix = DirectX::XMMatrixIdentity(); m_OrthoMatrix = DirectX::XMMatrixOrthographicLH((float)screenWidth, (float)screenHeight, SCREEN_NEAR, SCREEN_DEPTH); // Scene is a textured quad to draw on g_Scene = new Scene(GetDevice(), GetDeviceContext(), screenWidth, screenHeight); //g_Scene2 = new Scene(GetDevice(), GetDeviceContext(), screenWidth, screenHeight); // new DXGI Desktop Duplication object g_DesktopDuplication = new DXGIDuplication(); if (!g_DesktopDuplication->Init(0, 0, &g_DXGIAdapters, GetDevice())) { DebugOut("Failed to init DXGI Desktop Duplication API!\n"); return false; } //g_DesktopDuplication2 = new DXGIDuplication(); //if (!g_DesktopDuplication2->Init(0, 1, &g_DXGIAdapters, GetDevice())) { DebugOut("Failed to init DXGI Desktop Duplication API for Adapter 1/Output 2!\n"); return false; } // initialize Media Foundation g_MFEncoder = new MF_H264_Encoder(m_d3d11Device, m_d3d11DeviceContext); if (!g_MFEncoder->Init()) { DebugOut("Failed to init Media Foundation H.264 Encoder!\n"); return false; } return true; };
bool DXManager::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen) { HRESULT result; IDXGIFactory* factory; IDXGIAdapter* adapter; IDXGIOutput* adapterOutput; unsigned int numModes, numerator = 0, denominator = 0, stringLength; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; int error; ID3D11Texture2D* backBufferPtr; //store vsync setting m_vsync_enabled = vsync; //Create a DirectX graphic 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 result = factory->EnumAdapters(0, &adapter); if(FAILED(result)) { return false; } //Enumerate the primary adapter output 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 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 modes for this monitor/video card combination displayModeList = new DXGI_MODE_DESC[numModes]; //Fill the display mode list result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); if(FAILED(result)) { return false; } for(int i = 0; i < (int)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; } } } if(numerator == 0 && denominator == 0) { return false; } //Get the adapter description result = adapter->GetDesc(&adapterDesc); if(FAILED(result)) { return false; } //Store the video card memory in megabytes m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); //Convert the name of the video card to a character array error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128); if(error != 0) { return false; } //release memory delete [] displayModeList; displayModeList = 0; adapterOutput->Release(); adapterOutput = 0; adapter->Release(); adapter = 0; factory->Release(); factory = 0; if(!InitializeSwapChain(hwnd, fullscreen, screenWidth, screenHeight, numerator, denominator)) { return false; } //Get the pointer to the back buffer result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr); if(FAILED(result)) { return false; } //create the render target view result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView); if(FAILED(result)) { return false; } //release back buffer backBufferPtr->Release(); backBufferPtr = 0; if(!InitializeDepthBuffer(screenWidth, screenHeight)) { return false; } if(!InitializeDepthStencilBuffer()) { return false; } if(!InitializeStencilView()) { return false; } //bind the render target view and depth stencil buffer to the output render pipeline m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView); if(!InitializeRasterizerState()) { return false; } InitializeViewport(screenWidth, screenHeight); if(!InitializeAlphaBlending()) { return false; } if(!InitializeZBuffer()) { return false; } 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; // Store the vsync setting. m_vsync_enabled = vsync; // Create a DX graphics interface factory result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); if (FAILED(result)) { return false; } // Adapter for the primary graphics interface (video card) result = factory->EnumAdapters(0, &adapter); if (FAILED(result)) { return false; } // 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 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; } m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128); if (error != 0) { return false; } // Release the display mode list. delete[] displayModeList; displayModeList = 0; adapterOutput->Release(); adapterOutput = 0; adapter->Release(); adapter = 0; factory->Release(); factory = 0; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); 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; //multisampling off swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; if (fullscreen) { swapChainDesc.Windowed = false; } else { swapChainDesc.Windowed = true; } //set scan line ordering and scaling to unspecified swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // discard back buffer contents after presenting swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swapChainDesc.Flags = 0; featureLevel = D3D_FEATURE_LEVEL_11_0; result = D3D11CreateDeviceAndSwapChain( NULL, D3D_DRIVER_TYPE_REFERENCE, 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 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; } //Release pointer to the back buffer as we no longer need it backBufferPtr->Release(); backBufferPtr = 0; 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; } 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; // Create the depth stencil state. result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState); if(FAILED(result)) { 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)) { 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)) { return false; } // Now set the rasterizer state. 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); // 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; }
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; D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc; D3D11_BLEND_DESC blendStateDesc; m_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; } 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 = 0; adapterOutput->Release(); adapterOutput = 0; adapter->Release(); adapter = 0; factory->Release(); factory = 0; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); 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; 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; } 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; 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; } 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 = 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 = false; 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)DirectX::XM_PI / 4.0f; screenAspect = (float)screenWidth / (float)screenHeight; m_projectionMatrix = DirectX::XMMatrixPerspectiveFovLH(fieldOfView, screenAspect, screenNear, screenDepth); m_worldMatrix = DirectX::XMMatrixIdentity(); m_orthoMatrix = DirectX::XMMatrixOrthographicLH((float)screenWidth, (float)screenHeight, screenNear, screenDepth); 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; } ZeroMemory(&blendStateDesc, sizeof(D3D11_BLEND_DESC)); blendStateDesc.RenderTarget[0].BlendEnable = TRUE; blendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; blendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; blendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; blendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; blendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; blendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; blendStateDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f; result = m_device->CreateBlendState(&blendStateDesc, &m_alphaEnableBlendingState); if(FAILED(result)) { return false; } blendStateDesc.RenderTarget[0].BlendEnable = FALSE; result = m_device->CreateBlendState(&blendStateDesc, &m_alphaDisableBlendingState); if(FAILED(result)) { return false; } return true; }
bool CD3D11Driver::init(SCreationParameters& createParam) { HRESULT result; IDXGIFactory* factory; IDXGIAdapter* adapter; IDXGIOutput* adapterOutput; unsigned int numModes, i, numerator = 0, denominator = 1, stringLength; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; int error; D3D11_TEXTURE2D_DESC depthBufferDesc; //D3D11_DEPTH_STENCIL_DESC depthStencilDesc; //D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; //D3D11_RASTERIZER_DESC rasterDesc; //D3D11_VIEWPORT viewport; //const SCreationParameters& params = mDevice->getCreationParameters(); // Create a DirectX graphics interface factory. mBackBufferWidth = createParam.BackBufferWidth; mBackBufferHeight = createParam.BackBufferHeight; 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)createParam.BackBufferWidth) { if (displayModeList[i].Height == (unsigned int)createParam.BackBufferHeight) { 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. mVideoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // Convert the name of the video card to a character array and store it. error = wcstombs_s(&stringLength, mVideoCardDescription, 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; UINT createDeviceFlags = 0; #if defined(DEBUG) || defined(_DEBUG) createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_FEATURE_LEVEL featureLevel; /* 如果将这个标志设为DEBUG,则绘制效率大大降低,且帧频极不稳定 */ //createDeviceFlags = 0; HRESULT hr; hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, 0, 0, D3D11_SDK_VERSION, &md3dDevice, &featureLevel, &md3dDeviceContext); if (FAILED(hr)) return false; #if defined(DEBUG) || defined(_DEBUG) md3dDevice->QueryInterface(__uuidof(ID3D11Debug), reinterpret_cast<void**>(&md3dDebug)); #endif if (featureLevel != D3D_FEATURE_LEVEL_11_0) { throw std::runtime_error("DirectX11 is not supported!"); return false; } UINT numQualityLevels; md3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &numQualityLevels); IDXGIDevice* dxgiDevice = 0; md3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice); IDXGIAdapter* dxgiAdapter = 0; dxgiDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&dxgiAdapter); IDXGIFactory* dxgiFactory = 0; dxgiAdapter->GetParent(__uuidof(IDXGIFactory), (void**)&dxgiFactory); DXGI_SWAP_CHAIN_DESC swapChainDesc; // Initialize the swap chain description. ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); // Set the width and height of the back buffer. swapChainDesc.BufferDesc.Width = createParam.BackBufferWidth; swapChainDesc.BufferDesc.Height = createParam.BackBufferHeight; // 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 (createParam.VsyncEnabled) { swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator; swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator; } else { swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; } // Set multisampling. if (createParam.MultiSamplingQuality == 0) { swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; createParam.MultiSamplingCount = 1; } else { swapChainDesc.SampleDesc.Count = createParam.MultiSamplingCount; UINT numQualityLevels; md3dDevice->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, 4, &numQualityLevels); swapChainDesc.SampleDesc.Quality = min(numQualityLevels - 1, createParam.MultiSamplingQuality); createParam.MultiSamplingQuality = swapChainDesc.SampleDesc.Quality; } // set member attributes of class // Set to a single back buffer. swapChainDesc.BufferCount = 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)createParam.BackBufferWindowHandle; // Set to full screen or windowed mode. if (createParam.WindowStyle & EWS_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; hr = dxgiFactory->CreateSwapChain(md3dDevice, &swapChainDesc, &md3dSwapChain); if (FAILED(hr)) return false; ReleaseCOM(dxgiDevice); ReleaseCOM(dxgiAdapter); ReleaseCOM(dxgiFactory); // Get the pointer to the back buffer. ID3D11Texture2D* backBuffer; result = md3dSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBuffer); if (FAILED(result)) { return false; } md3dDevice->CreateRenderTargetView(backBuffer, 0, &mDefaultRenderTargetView); ReleaseCOM(backBuffer); mDefaultRenderTarget = new CD3D11RenderTarget(md3dDevice, md3dDeviceContext, mDefaultRenderTargetView, createParam.BackBufferWidth, createParam.BackBufferHeight); // Initialize the description of the depth buffer. ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); // Setup the viewport for rendering. setViewport(0, 0, static_cast<f32>(mBackBufferWidth), static_cast<f32>(mBackBufferHeight)); //create resource factory mResourceFactory = new CD3D11ResourceFactory( md3dDevice, md3dDeviceContext, this); IResourceFactory::_setInstance(mResourceFactory); //create geometry creator mGeometryCreator = new CGeometryCreator; IGeometryCreator::_setInstance(mGeometryCreator); //create material manager mMaterialManager = new CMaterialManager; IMaterialManager::_setInstance(mMaterialManager); //create sampler manager mSamplerManager = new CSamplerManager(mResourceFactory); ISamplerManager::_setInstance(mSamplerManager); // create shadermanager mShaderManager = new CShaderManager(mResourceFactory); IShaderManager::_setInstance(mShaderManager); // create inputlayout manager mInputLayoutManager = new CInputLayoutManager(mResourceFactory); IInputLayoutManager::_setInstance(mInputLayoutManager); //create texture manager mTextureManager = new CTextureManager(mDevice, mResourceFactory); ITextureManager::_setInstance(mTextureManager); //create render state manager mRenderStateManager = new CRenderStateManager(mResourceFactory); IRenderStateManager::_setInstance(mRenderStateManager); //create mesh manager mMeshManager = new CMeshManager(mResourceFactory, mGeometryCreator, mTextureManager); IMeshManager::_setInstance(mMeshManager); //create pipeline manager mPipeManager = new CPipelineManager(mResourceFactory); IPipelineManager::_setInstance(mPipeManager); //create resource group manager mResourceGroupManager = new CResourceGroupManager(mTextureManager, mShaderManager, mInputLayoutManager, mRenderStateManager, mPipeManager, mMaterialManager, mMeshManager, mSamplerManager); IResourceGroupManager::_setInstance(mResourceGroupManager); //mResourceFactory->setResourceGroupManager(mResourceGroupManager); // create default depth-stencil-buffer bool multiSampling = (createParam.MultiSamplingCount > 1); mDepthStencilSurface = mTextureManager->createDepthStencilSurface("_default_depth_stencil_surface", 0, 0, createParam.DepthBits, createParam.StencilBits, multiSampling, createParam.MultiSamplingCount, createParam.MultiSamplingQuality, true); if (!mDepthStencilSurface) { GF_PRINT_CONSOLE_INFO("Depth Stencil Surface has failed to be created.\n"); return false; } D3D11DriverState.DepthStencilSurface = mDepthStencilSurface; CD3D11DepthStencilSurface* d3dDepthStencilSurface = dynamic_cast<CD3D11DepthStencilSurface*>(mDepthStencilSurface); mDefaultDepthStencilView = d3dDepthStencilSurface->getDepthStencilView(); D3D11DriverState.DepthStencilView = mDefaultDepthStencilView; // create mShadowMapRasterizeState. This state is only for rendering shadow maps. D3D11_RASTERIZER_DESC shadowRasterizeState; shadowRasterizeState.FillMode = D3D11_FILL_SOLID; shadowRasterizeState.CullMode = D3D11_CULL_BACK; // RENDER BACK FACE shadowRasterizeState.FrontCounterClockwise = TRUE; shadowRasterizeState.DepthBiasClamp = 0.0f; //shadowRasterizeState.DepthBias = 100000; //shadowRasterizeState.SlopeScaledDepthBias = 1.0f; shadowRasterizeState.DepthBias = 0; shadowRasterizeState.SlopeScaledDepthBias = 0; shadowRasterizeState.DepthClipEnable = TRUE; shadowRasterizeState.ScissorEnable = FALSE; shadowRasterizeState.MultisampleEnable = FALSE; shadowRasterizeState.AntialiasedLineEnable = FALSE; hr = md3dDevice->CreateRasterizerState(&shadowRasterizeState, &mShadowMapRasterizeState); if (FAILED(hr)) return false; D3D11DriverState.ShadowMapRasterizerState = mShadowMapRasterizeState; return true; }
BOOL CProcessTool::GetProcessExtendInfo(PSYSTEM_PROCESS_INFORMATION pSPI,PPROCESS_EXTEND_INFO pExtendInfo) { HANDLE hProcess; TCHAR szBuf[2048] ={0}; memset(pExtendInfo,0,sizeof(PPROCESS_EXTEND_INFO)); hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE,pSPI->UniqueProcessId); if(hProcess==NULL)return FALSE; //Get Exe Path,Description,Company Name if(GetModuleFileNameEx(hProcess,NULL,szBuf,MAX_PATH)!=0) { pExtendInfo->strExeFilePath = szBuf; GetFileDescription(szBuf,pExtendInfo->strDescription, pExtendInfo->strCompanyName); } //Get Virtual Memory Size PROCESS_MEMORY_COUNTERS pmc; if(GetProcessMemoryInfo(hProcess,&pmc,sizeof(PROCESS_MEMORY_COUNTERS))) { pExtendInfo->dwVirtualMemorySize = pmc.PagefileUsage; } //Get Parent Process File Path HANDLE hParent =NULL; hParent = OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_INFORMATION, FALSE,pSPI->InheritedFromUniqueProcessId); if(hParent!=NULL) { memset(szBuf,0,sizeof(szBuf)); if(GetModuleFileNameEx(hParent,NULL,szBuf,MAX_PATH)!=0) { pExtendInfo->strParentFilePath = szBuf; } } //Get Username if(WinStationGetProcessSid&&CachedGetUserFromSid) { wchar_t wcsUserName[100]={0}; char mbsUserName[100]={0}; size_t NumOfCharConverted; DWORD dwSize = sizeof(szBuf)/sizeof(TCHAR); FILETIME ftStartTime; CopyMemory(&ftStartTime,&pSPI->CreateTime,sizeof(FILETIME)); if(WinStationGetProcessSid(NULL,pSPI->UniqueProcessId,ftStartTime, (LPBYTE)szBuf,&dwSize)) { CachedGetUserFromSid(szBuf,wcsUserName,&dwSize); #ifdef _UNICODE pExtendInfo->strUserName = wcsUserName; #else wcstombs_s(&NumOfCharConverted,mbsUserName,wcsUserName, sizeof(mbsUserName)); pExtendInfo->strUserName = mbsUserName; #endif } } //Get Start time { SYSTEMTIME st; ZeroMemory(&st,sizeof(SYSTEMTIME)); FileTimeToSystemTime((FILETIME *)&pSPI->CreateTime,&st); CTime Time(st); Time +=CTimeSpan(0,8,0,0); pExtendInfo->strStartTime = Time.Format(TEXT("%Y-%m-%d %H:%M:%S")); } return TRUE; }
ColladaTexture::ColladaTexture(FCDImage * _image) { image = _image; // // // Create an image container in DevIL. // ILuint imageId; // // ilGenImages(1, &imageId); // ilBindImage(imageId); // do it square // reduce it if it is necessaryt // test this //GL_MAX_TEXTURE_SIZE. // initializate some variables hasOpacity = false; wchar_t orig[512]; const size_t newsize = 256; char nstring[newsize]; #ifdef _WIN32 // convert fstring to char*, amazing code based on http://msdn2.microsoft.com/en-us/library/ms235631(vs.80).aspx size_t convertedChars = 0; swprintf(orig, 512,L"%S", image->GetFilename().c_str() ); size_t origsize = wcslen(orig) + 1; for(int i = 0; i < (int)origsize; ++i) { if(orig[i] == '\\') { orig[i] = '/'; } } //wcstombs_s(&convertedChars, nstring, origsize, orig+2/*remove C:*/, _TRUNCATE); wcstombs_s(&convertedChars, nstring, origsize, orig, _TRUNCATE); #else swprintf(orig, 512,L"%s", image->GetFilename().c_str() ); const wchar_t * origTmp = &orig[0]; wcsnrtombs( nstring, &origTmp, 512, 256, NULL); #endif texturePathName = nstring; TextureDescriptorUtils::CreateDescriptorIfNeed(String(texturePathName)); /*try { std::vector<Magick::Image> layers; Magick::readImages(&layers, fileName); if (layers.size() != 1) { Logger::Error("Number of layers is wrong: %s", fileName.c_str()); } Magick::Image & magickImage = layers[0]; Magick::Geometry geo = magickImage.size(); //magickImage.magick("RGBA"); magickImage.modifyImage(); bool opacityFound = false; if (magickImage.type() == Magick::TrueColorMatteType) { // magickImage.type(Magick::TrueColorMatteType); Magick::PixelPacket *pixelCache = magickImage.getPixels(0, 0, geo.width(), geo.height()); int32 height = geo.height(); int32 width = geo.width(); int32 size = sizeof(pixelCache[0].opacity); int32 opaqueValue = 255; if (size == 2)opaqueValue = 65535; for (int32 y = 0; y < height; ++y) { for (int32 x = 0; x < width; ++x) { if (pixelCache[y * width + x].opacity != opaqueValue) { opacityFound = true; break; } } if (opacityFound)break; } } Logger::FrameworkDebug("Image opened: %s - %d x %d - opacity: %s", fileName.c_str(), geo.width(), geo.height(), (opacityFound) ? ("yes"):("no")); } catch( Magick::Exception &error_ ) { Logger::Error("Caught exception: %s file: %s", error_.what(), fileName.c_str()); //std::cout << "Caught exception: " << error_.what() << " file: "<< psdPathname << std::endl; }*/ // // wprintf(L"* added texture: %s", (wchar_t*)(image->GetFilename().c_str())); // printf(" name: %s\n", image->GetDaeId().c_str()); // // // Read in the image file into DevIL. // if (!ilLoadImage(nstring)) // { // wchar_t error_message[256]; // swprintf(error_message, 256, L"This texture could not be opened: %s\n", (wchar_t*)(image->GetFilename().c_str())); // wprintf(error_message); // // ilDeleteImages(1, &imageId); // textureId = -1; // } else // { // // resize if necessary // ProcessDevilImage(); // // // // gl work // glGenTextures(1, &textureId); /* Texture name generation */ // GLenum error; // if ((error = glGetError()) != GL_NO_ERROR) // { // printf("OpenGL Error: %x\n", error); // } // // glBindTexture(GL_TEXTURE_2D, textureId); /* Binding of texture name */ // // // if 4 channels, the last one is the alpha channel // if (ilGetInteger(IL_IMAGE_CHANNELS) == 4) // hasAlphaChannel = true; // // // create mipmaps and upload texture to video card memory // gluBuild2DMipmaps // ( // GL_TEXTURE_2D, // ilGetInteger(IL_IMAGE_CHANNELS), // ilGetInteger(IL_IMAGE_WIDTH), // ilGetInteger(IL_IMAGE_HEIGHT), // ilGetInteger(IL_IMAGE_FORMAT), // GL_UNSIGNED_BYTE, // ilGetData() // ); // // // // // glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); // glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); // glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // // printf("texture size: %d x %d\n", ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT)); // // // release memory, now opengl have it ! // ilDeleteImages(1, &imageId); // } }
VOID ResourceDatabase::AddBundledResources( PackedResource* pBundledResourceTable ) { assert( pBundledResourceTable != NULL ); m_BundledResources.push_back( pBundledResourceTable ); RESOURCE* pTags = NULL; DWORD dwResourceCount = 0; WCHAR strNameTemp[256]; pBundledResourceTable->GetResourceTags( &dwResourceCount, &pTags ); DWORD i = 0; while( i < dwResourceCount ) { MultiByteToWideChar( CP_ACP, 0, pTags[i].strName, strlen( pTags[i].strName ) + 1, strNameTemp, 256 ); _wcslwr_s( strNameTemp ); switch( pTags[i].dwType ) { case RESOURCETYPE_TEXTURE: { Texture2D* pTexture = new Texture2D(); pTexture->SetName( strNameTemp ); pTexture->bFromPackedResource = TRUE; DWORD dwOffset = pTags[ i ].dwOffset; D3DTexture* pD3DTexture = pBundledResourceTable->GetTexture( dwOffset ); pTexture->SetD3DTexture( pD3DTexture ); AddResource( pTexture ); #ifdef PROFILE // Report texture to texture tracker PIXReportNewTexture( pD3DTexture ); CHAR strConverted[256]; strConverted[0] = 0; wcstombs_s( 0, strConverted, strNameTemp, _countof(strConverted) ); PIXSetTextureName( pD3DTexture, TEXT(strConverted) ); #endif break; } case RESOURCETYPE_CUBEMAP: { TextureCube* pTexture = new TextureCube(); pTexture->SetName( strNameTemp ); pTexture->bFromPackedResource = TRUE; DWORD dwOffset = pTags[ i ].dwOffset; D3DCubeTexture* pD3DTexture = pBundledResourceTable->GetCubemap( dwOffset ); pTexture->SetD3DTexture( pD3DTexture ); AddResource( pTexture ); #ifdef PROFILE // Report texture to texture tracker PIXReportNewTexture( pD3DTexture ); CHAR strConverted[256]; strConverted[0] = 0; wcstombs_s( 0, strConverted, strNameTemp, _countof(strConverted) ); PIXSetTextureName( pD3DTexture, TEXT(strConverted) ); #endif break; } case RESOURCETYPE_VOLUMETEXTURE: { TextureVolume* pTexture = new TextureVolume(); pTexture->SetName( strNameTemp ); pTexture->bFromPackedResource = TRUE; DWORD dwOffset = pTags[ i ].dwOffset; D3DVolumeTexture* pD3DTexture = pBundledResourceTable->GetVolumeTexture( dwOffset ); pTexture->SetD3DTexture( pD3DTexture ); AddResource( pTexture ); #ifdef PROFILE // Report texture to texture tracker PIXReportNewTexture( pD3DTexture ); CHAR strConverted[256]; strConverted[0] = 0; wcstombs_s( 0, strConverted, strNameTemp, _countof(strConverted) ); PIXSetTextureName( pD3DTexture, TEXT(strConverted) ); #endif break; } case RESOURCETYPE_VERTEXBUFFER: case RESOURCETYPE_INDEXBUFFER: case RESOURCETYPE_USERDATA: default: { // not supported yet DebugSpew( "Unsupported resource type %d for resource \"%s\".\n", pTags[i].dwType, pTags[i].strName ); break; } } ++i; } }
bool startJVM(TCHAR* basedir, TCHAR* appFolder, TCHAR* jar, int argCount, LPTSTR *szArgList) { TCHAR jvmPath[LAUNCHER_MAXPATH+1] = {0}; JavaVMInitArgs jvmArgs; JavaVMOption options[MAX_OPTIONS+1]; JVM_CREATE createProc; JNIEnv* env; JavaVM* jvm = NULL; char jarASCII[LAUNCHER_MAXPATH] = {0}; char classpath[LAUNCHER_MAXPATH*2] = {0}; char mainclassASCII[LAUNCHER_MAXPATH] = {0}, appClasspath[LAUNCHER_MAXPATH] = {0}; size_t outlen = 0; jclass cls; jmethodID mid; TCHAR argname[MAX_OPTION_NAME + 1] = {0}; TCHAR argvalue[LAUNCHER_MAXPATH] = {0}, mainclass[LAUNCHER_MAXPATH] = {0}; CHAR argvalueASCII[LAUNCHER_MAXPATH] = {0}; HMODULE msvcrtdll; bool runtimeBundled; TCHAR tmpPath[LAUNCHER_MAXPATH] = {0}; TCHAR appid[LAUNCHER_MAXPATH] = {0}; memset(&options, 0, sizeof(JavaVMOption)*(MAX_OPTIONS + 1)); memset(&jvmArgs, 0, sizeof(JavaVMInitArgs)); makeFullFileName(basedir, _T("\\runtime"), tmpPath, sizeof(tmpPath)/sizeof(TCHAR)); runtimeBundled = fileExists(tmpPath); if (runtimeBundled) { if (!getJvmPath(basedir, jvmPath, LAUNCHER_MAXPATH)) { showError(_T("jvm.dll is not found in bundled runtime."), jvmPath); return false; } //make sure msvcr100 is loaded (or we may fail if copy of it is not installed into system) makeFullFileName(basedir, _T("runtime\\jre\\bin\\msvcr100.dll"), tmpPath, sizeof(tmpPath)/sizeof(TCHAR)); msvcrtdll = ::LoadLibrary(tmpPath); } else { if (!getSystemJvmPath(jvmPath, LAUNCHER_MAXPATH)) { showError(_T("No bundled runtime and can not find system JRE."), jvmPath); return false; } //make sure msvcr100 is loaded (or we may fail if copy of it is not installed into system) makeFullFileName(basedir, _T("\\bin\\msvcr100.dll"), tmpPath, sizeof(tmpPath)/sizeof(TCHAR)); msvcrtdll = ::LoadLibrary(tmpPath); } // Dynamically load the JVM HMODULE jvmLibHandle = LoadLibrary(jvmPath); if (jvmLibHandle == NULL) { DWORD dwErr = GetLastError(); showError(_T("Error loading jvm.dll"), jvmPath); return false; } //convert argument to ASCII string as this is what CreateJVM needs wcstombs_s(&outlen, jarASCII, LAUNCHER_MAXPATH, jar, (size_t) wcslen(jar) + 1); strcpy_s(classpath, LAUNCHER_MAXPATH*2, "-Djava.class.path="); strcat_s(classpath, LAUNCHER_MAXPATH, jarASCII); if (getConfigValue(basedir, CONFIG_CLASSPATH_KEY, argvalue, LAUNCHER_MAXPATH)) { size_t inLen = (size_t) wcslen(argvalue); //convert argument to ASCII string as this is what CreateJVM needs wcstombs_s(&outlen, argvalueASCII, sizeof(argvalueASCII), argvalue, inLen + 1); //compress spaces and replaces them with ; { char *in = argvalueASCII; char *out = argvalueASCII; bool needSemicolon = false; while (*in != 0) { if (*in == ' ') { if (needSemicolon) { *out = ';'; out++; needSemicolon = false; } } else { needSemicolon = true; *out = *in; out++; } in++; } *out = 0; } if (strlen(argvalueASCII) > 0) { strcat_s(classpath, LAUNCHER_MAXPATH, ";"); strcat_s(classpath, LAUNCHER_MAXPATH, argvalueASCII); } } // Set up the VM init args jvmArgs.version = JNI_VERSION_1_2; options[0].optionString = _strdup(classpath); int cnt = 1; if (isDebug) { options[cnt].optionString = _strdup("vfprintf"); options[cnt].extraInfo = vfprintfHook; cnt++; } //Note: should not try to quote the path. Spaces are fine here _stprintf_s(argvalue, _T("-Djava.library.path=%s"), appFolder); wcstombs_s(&outlen, argvalueASCII, sizeof(argvalueASCII), argvalue, wcslen(argvalue) + 1); options[cnt].optionString = _strdup(argvalueASCII); cnt++; //add app specific JVM parameters int idx = 1; int found = 0; do { _stprintf_s(argname, MAX_OPTION_NAME, _T("jvmarg.%d"), idx); found = getConfigValue(basedir, argname, argvalue, LAUNCHER_MAXPATH); if (found) { TCHAR* option = replaceStr(argvalue, _T("$APPDIR"), basedir); char* jvmOption = convertToDupedChar(option); if (jvmOption != NULL) { options[cnt].optionString = jvmOption; cnt++; } idx++; } } while (found && idx < MAX_OPTIONS); cnt = addUserOptions(basedir, options, cnt); jvmArgs.version = 0x00010002; jvmArgs.options = options; jvmArgs.nOptions = cnt; jvmArgs.ignoreUnrecognized = JNI_TRUE; // Create the JVM // NB: need to use ASCII string as UNICODE is not supported createProc = (JVM_CREATE) GetProcAddress(jvmLibHandle, "JNI_CreateJavaVM"); if (createProc == NULL) { showError(_T("Failed to locate JNI_CreateJavaVM"), jvmPath); return false; } if ((*createProc)(&jvm, &env, &jvmArgs) < 0) { showError(_T("Failed to create JVM"), jvmPath); return false; } if (!getConfigValue(basedir, CONFIG_MAINCLASS_KEY, mainclass, LAUNCHER_MAXPATH)) { showError(_T("Package error"), _T("No main class specified. Nothing to launch")); return false; } else { size_t inLen = (size_t) wcslen(mainclass); //convert argument to ASCII string as this is what CreateJVM needs wcstombs_s(&outlen, mainclassASCII, sizeof(mainclassASCII), mainclass, inLen + 1); } cls = env->FindClass(mainclassASCII); if (cls != NULL) { mid = env->GetStaticMethodID(cls, "main", "([Ljava/lang/String;)V"); if (mid != NULL) { jclass stringClass = env->FindClass("java/lang/String"); //prepare app arguments if any. Skip value at index 0 - this is path to executable ... //NOTE: // - what if user run in non-English/UTF-8 locale? do we need to convert args? // - extend to pass jvm args and debug args (allow them in front, use marker option to separate them?) int startArgIndex = countNumberOfSystemArguments(argCount, szArgList); jobjectArray args = env->NewObjectArray(argCount - startArgIndex, stringClass, NULL); for(int i=startArgIndex; i<argCount; i++) { size_t inLen = (size_t) wcslen(szArgList[i]); env->SetObjectArrayElement(args, i-startArgIndex, env->NewString((jchar*)szArgList[i], inLen)); } env->CallStaticVoidMethod(cls, mid, args); } else { showError(_T("no main method in the main class!"), mainclass); return false; } } else { showError(_T("no main class."), mainclass); return false; } if (env->ExceptionOccurred()) { showError(_T("Failed due to exception from main class."), mainclass); env->ExceptionDescribe(); } // If application main() exits quickly but application is run on some other thread // (e.g. Swing app performs invokeLater() in main and exits) // then if we return execution to tWinMain it will exit. // This will cause process to exit and application will not actually run. // // To avoid this we are trying to detach jvm from current thread (java.exe does the same) // Because we are doing this on the main JVM thread (i.e. one that was used to create JVM) // this call will spawn "Destroy Java VM" java thread that will shut JVM once there are // no non-daemon threads running, and then return control here. // I.e. this will happen when EDT and other app thread will exit. if (jvm->DetachCurrentThread() != 0) { showError(_T("Detach failed."), NULL); } jvm->DestroyJavaVM(); return true; }
void TestFromWide( void ) { char mbs[20]; wchar_t wc = L'\0'; wchar_t wcs[] = { 'H', 'e', 'l', 'l', 'o', '\0' }; errno_t rc; size_t retval; size_t retval2; int status; int violations = NumViolations; rc = wctomb_s( &status, mbs, 20, wc ); VERIFY( rc == 0 ); VERIFY( mbs[0] == '\0' ); VERIFY( status == 1 ); VERIFY( violations == NumViolations ); rc = wctomb_s( &status, mbs, 20, L'X' ); VERIFY( rc == 0 ); VERIFY( mbs[0] == 'X' ); VERIFY( status == 1 ); VERIFY( violations == NumViolations ); rc = wctomb_s( &status, NULL, 0, L'X' ); VERIFY( rc == 0 ); VERIFY( status == 0 ); /* no state-dependant encodings */ VERIFY( violations == NumViolations ); rc = wcstombs_s( &retval, mbs, 20, wcs, 10 ); VERIFY( rc == 0 ); VERIFY( retval == 5 ); VERIFY( !_mbscmp(mbs,"Hello") ); VERIFY( violations == NumViolations ); rc = wcstombs_s( &retval2, NULL, 0, wcs, 10 ); VERIFY( rc == 0 ); VERIFY( retval2 == 5 ); VERIFY( violations == NumViolations ); /***********************************************************************/ /* test runtime-constraints */ /***********************************************************************/ rc = wctomb_s( &status, NULL, 20, wc ); VERIFY( rc != 0 ); VERIFY( ++violations == NumViolations ); rc = wctomb_s( &status, mbs, 0, wc ); VERIFY( rc != 0 ); VERIFY( ++violations == NumViolations ); #if RSIZE_MAX != SIZE_MAX rc = wctomb_s( &status, mbs, ~0, wc ); VERIFY( rc != 0 ); VERIFY( ++violations == NumViolations ); #endif rc = wctomb_s( &status, mbs, 1, '\x81\xFC' ); VERIFY( rc != 0 ); VERIFY( ++violations == NumViolations ); mbs[0]= 'X'; rc = wcstombs_s( NULL, mbs, 20, wcs, 10 ); VERIFY( rc != 0 ); VERIFY( mbs[0] == '\0' ); VERIFY( ++violations == NumViolations ); mbs[0]= 'X'; rc = wcstombs_s( &retval, mbs, 20, NULL, 10 ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( mbs[0] == '\0' ); VERIFY( ++violations == NumViolations ); #if RSIZE_MAX != SIZE_MAX mbs[0]= 'X'; rc = wcstombs_s( &retval, mbs, ~0, wcs, 10 ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( mbs[0] == 'X' ); VERIFY( ++violations == NumViolations ); mbs[0]= 'X'; rc = wcstombs_s( &retval, mbs, 20, wcs, ~0 ); VERIFY( rc != 0 ); VERIFY( retval == -1 ); VERIFY( mbs[0] == '\0' ); VERIFY( ++violations == NumViolations ); #endif }
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; }
HRESULT DXManager::getVideoCardInfo() { HRESULT result; IDXGIFactory* factory; IDXGIAdapter* adapter; IDXGIOutput* adapterOutput; DXGI_MODE_DESC* displayModeList; DXGI_ADAPTER_DESC adapterDesc; unsigned int numModes, i, stringLength; int error; 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)m_ScreenWidth) { if (displayModeList[i].Height == (unsigned int)m_ScreenHeight) { mNumerator = displayModeList[i].RefreshRate.Numerator; mDenominator = displayModeList[i].RefreshRate.Denominator; } } } result = adapter->GetDesc(&adapterDesc); if (FAILED(result)) { return false; } m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); //MB Video Ram 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; return S_OK; }
bool D3DClass::Initialise(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_DESC depthDisabledStencilDesc; D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; D3D11_BLEND_DESC blendStateDescription; D3D11_RASTERIZER_DESC rasterDesc; float fieldOfView, screenAspect; // 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; // Initialise 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; // Set the feature level to DirectX 11. featureLevel = D3D_FEATURE_LEVEL_11_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)) { return false; } // Get the pointer to the back buffer. result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (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; // Initialise 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 = 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)) { return false; } // Initialise 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)) { return false; } // Set the depth stencil state. m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1); // Initialise 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)) { 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)) { return false; } // Now set the rasterizer state. m_deviceContext->RSSetState(m_rasterState); // Setup the viewport for rendering. m_viewport.Width = (float)screenWidth; m_viewport.Height = (float)screenHeight; m_viewport.MinDepth = 0.0f; m_viewport.MaxDepth = 1.0f; m_viewport.TopLeftX = 0.0f; m_viewport.TopLeftY = 0.0f; // Create the viewport. m_deviceContext->RSSetViewports(1, &m_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); // Initialise 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); // 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 = false; depthDisabledStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; depthDisabledStencilDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; depthDisabledStencilDesc.BackFace = depthDisabledStencilDesc.FrontFace; // Create the state using the device. result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_depthDisabledStencilState); if(FAILED(result)) { return false; } // 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_ONE; 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_SRC_ALPHA; blendStateDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA; blendStateDescription.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_SUBTRACT; blendStateDescription.RenderTarget[0].RenderTargetWriteMask = 0x0f; // Create the blend state using the description. result = m_device->CreateBlendState(&blendStateDescription, &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 = m_device->CreateBlendState(&blendStateDescription, &m_alphaDisableBlendingState); if (FAILED(result)) { return false; } return true; }
LPCSTR tcstocs(LPCTSTR lpctStr) { // typed char (WCHAR) to CHAR size_t numConv = 0; static CHAR strTemp[1024]; wcstombs_s(&numConv, strTemp, 1024, lpctStr, 1024); return strTemp; }
/** * Process session event * * This service implements the OS independent API for processing equests * sent from the environment. Under Windows, this service would process * DEBUG_EVENTs when called from the operating system. Under the NDBG * executive debugger server, these events would be sent over a PIPE. * * This method calls the environment independent session event procedure. * * \param session Debug session * \param e Output DEBUG_EVENT descriptor * \ret Session state */ dbgSessionState DbgSessionProcessEvent (dbgSession* session, DEBUG_EVENT* e) { /* clear event descriptor */ dbgEventDescr descr; memset (&descr,0,sizeof(dbgEventDescr)); /* process debug event */ switch (e->dwDebugEventCode) { /* Create process */ case CREATE_PROCESS_DEBUG_EVENT: { unsigned long long base = 0; dbgCreateProcessDescr* record; record = &descr.u.createProcess; descr.event = DBG_EVENT_CREATEPROCESS; record->entry = (vaddr_t) e->u.CreateProcessInfo.lpStartAddress; record->imageBase = (vaddr_t) e->u.CreateProcessInfo.lpBaseOfImage; record->imageName = (vaddr_t) e->u.CreateProcessInfo.lpImageName; return session->proc (session, &descr); } /* Create thread */ case CREATE_THREAD_DEBUG_EVENT: { dbgCreateThreadDescr* record; record = &descr.u.createThread; descr.event = DBG_EVENT_CREATETHREAD; record->entry = (vaddr_t) e->u.CreateThread.lpStartAddress; return session->proc (session, &descr); } /* Exception */ case EXCEPTION_DEBUG_EVENT: { dbgExceptionDescr* record; record = &descr.u.exception; record->firstChance = e->u.Exception.dwFirstChance; descr.event = DBG_EVENT_EXCEPTION; /* Converts Windows exception code to internal format */ switch (e->u.Exception.ExceptionRecord.ExceptionCode) { case EXCEPTION_ACCESS_VIOLATION: descr.u.exception.code = DBG_EXCEPTION_SEGMENT; break; case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: descr.u.exception.code = DBG_EXCEPTION_BOUNDS; break; case EXCEPTION_BREAKPOINT: descr.u.exception.code = DBG_EXCEPTION_BREAKPOINT; break; case EXCEPTION_DATATYPE_MISALIGNMENT: descr.u.exception.code = DBG_EXCEPTION_ALIGNMENT; break; case EXCEPTION_FLT_DENORMAL_OPERAND: descr.u.exception.code = DBG_EXCEPTION_FLT_DENORMAL_OPERAND; break; case EXCEPTION_FLT_DIVIDE_BY_ZERO: descr.u.exception.code = DBG_EXCEPTION_FLT_DIVIDE; break; case EXCEPTION_FLT_INEXACT_RESULT: descr.u.exception.code = DBG_EXCEPTION_FLT_INEXACT_RESULT; break; case EXCEPTION_FLT_INVALID_OPERATION: descr.u.exception.code = DBG_EXCEPTION_FLT_INVALID_OP; break; case EXCEPTION_FLT_OVERFLOW: descr.u.exception.code = DBG_EXCEPTION_FLT_OVERFLOW; break; case EXCEPTION_FLT_STACK_CHECK: descr.u.exception.code = DBG_EXCEPTION_FLT_STACK_CHECK; break; case EXCEPTION_FLT_UNDERFLOW: descr.u.exception.code = DBG_EXCEPTION_FLT_UNDERFLOW; break; case EXCEPTION_ILLEGAL_INSTRUCTION: descr.u.exception.code = DBG_EXCEPTION_INVALID_OPCODE; break; case EXCEPTION_INT_DIVIDE_BY_ZERO: descr.u.exception.code = DBG_EXCEPTION_INT_DIVIDE; break; case EXCEPTION_INT_OVERFLOW: descr.u.exception.code = DBG_EXCEPTION_INT_OVERFLOW; break; case EXCEPTION_SINGLE_STEP: descr.u.exception.code = DBG_EXCEPTION_SINGLE_STEP; break; case EXCEPTION_STACK_OVERFLOW: descr.u.exception.code = DBG_EXCEPTION_STACK; break; case EXCEPTION_IN_PAGE_ERROR: case EXCEPTION_INVALID_DISPOSITION: case EXCEPTION_NONCONTINUABLE_EXCEPTION: case EXCEPTION_PRIV_INSTRUCTION: descr.u.exception.code = DBG_EXCEPTION_GPF; break; case DBG_CONTROL_C: printf ("\n\rCtrl+c event not currently implemented."); break; } record->address = (vaddr_t) e->u.Exception.ExceptionRecord.ExceptionAddress; return session->proc (session, &descr); } /* Exit process */ case EXIT_PROCESS_DEBUG_EVENT: { dbgExitProcessDescr* record; record = &descr.u.exitProcess; descr.event = DBG_EVENT_EXITPROCESS; record->exitCode = e->u.ExitProcess.dwExitCode; return session->proc (session, &descr); } /* Exit thread */ case EXIT_THREAD_DEBUG_EVENT: { dbgExitThreadDescr* record; record = &descr.u.exitThread; descr.event = DBG_EVENT_EXITTHREAD; record->exitCode = e->u.ExitThread.dwExitCode; return session->proc (session, &descr); } /* Output string */ case OUTPUT_DEBUG_STRING_EVENT: { dbgDebugStringDescr* record; char* str = 0; dbgSessionState state = DBG_STATE_CONTINUE; /* create record */ record = &descr.u.debugString; descr.event = DBG_EVENT_PRINT; record->length = e->u.DebugString.nDebugStringLength; /* string located in process address space so we buffer it */ str = (char*)malloc(record->length); DbgProcessRequest (DBG_REQ_READ,session, e->u.DebugString.lpDebugStringData,str,record->length); record->string = (vaddr_t) str; str[record->length-1] = 0; /* 0 terminate */ /* process event and release memory */ state = session->proc (session, &descr); free(str); return state; } /* The following events are processed internally and are not passed to the core debugger. They are Windows specific events. */ /* Load DLL */ case LOAD_DLL_DEBUG_EVENT: { dbgSharedLibrary* libraryDescr; char path[64]; memset (path,0,64); /* lpImageName is a pointer in the process address space that contains a pointer to the real string in that address space. */ if (e->u.LoadDll.lpImageName) { vaddr_t imageName = 0; DbgProcessRequest (DBG_REQ_READ,session, e->u.LoadDll.lpImageName,&imageName,4); if (imageName) { wchar_t image[128]; memset (image,128,0); DbgProcessRequest (DBG_REQ_READ,session,(void*)imageName,image,127); #ifdef _MSC_VER { size_t numConverted = 0; wcstombs_s (&numConverted, path, 64, image,63); } #else wcstombs (path,image,63); #endif } } /* there is no debug event for this since its Windows specific */ DbgDisplayMessage ("(%i) Loaded '%s'", session->process.id.pid, path); break; } /* RIP Event */ case RIP_EVENT: { /* there is no debug event for this since its Windows specific */ DbgDisplayMessage ("RIP Event"); break; } /* Unload DLL */ case UNLOAD_DLL_DEBUG_EVENT: { /* Locate library object */ dbgSharedLibrary* descr = 0; listNode* cur = session->process.libraryList.first; size_t c; for (c = 0; c < session->process.libraryList.count; c++) { descr = (dbgSharedLibrary*) cur->data; if (descr->base == (vaddr_t) e->u.UnloadDll.lpBaseOfDll) break; cur = cur->next; } /* Display library and unload it */ if (cur) { DbgDisplayMessage("(%i) Unloaded '%s'", session->process.id.pid, descr->name); free (descr->name); listRemoveElement(c, &session->process.libraryList); } else DbgDisplayMessage ("(%i) Unloaded unknown DLL", session->process.id.pid); /* there is no debug event for this since its Windows specific */ break; } } /* we just continue this session for all events that dont need processing */ return DBG_STATE_CONTINUE; }
nfsstat3 CNFS3Prog::ProcedureREADLINK(void) { PrintLog("READLINK"); char *path; char *pMBBuffer = 0; post_op_attr symlink_attributes; nfspath3 data = nfspath3(); //opaque data; nfsstat3 stat; HANDLE hFile; REPARSE_DATA_BUFFER *lpOutBuffer; lpOutBuffer = (REPARSE_DATA_BUFFER*)malloc(MAXIMUM_REPARSE_DATA_BUFFER_SIZE); DWORD bytesReturned; path = GetPath(); stat = CheckFile(path); if (stat == NFS3_OK) { hFile = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_REPARSE_POINT | FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL); if (hFile == INVALID_HANDLE_VALUE) { stat = NFS3ERR_IO; } else { lpOutBuffer = (REPARSE_DATA_BUFFER*)malloc(MAXIMUM_REPARSE_DATA_BUFFER_SIZE); if (!lpOutBuffer) { stat = NFS3ERR_IO; } else { DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT, NULL, 0, lpOutBuffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &bytesReturned, NULL); if (lpOutBuffer->ReparseTag == IO_REPARSE_TAG_SYMLINK || lpOutBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) { if (lpOutBuffer->ReparseTag == IO_REPARSE_TAG_SYMLINK) { size_t plen = lpOutBuffer->SymbolicLinkReparseBuffer.PrintNameLength / sizeof(WCHAR); pMBBuffer = (char *)malloc((plen + 1)); WCHAR *szPrintName = new WCHAR[plen + 1]; wcsncpy_s(szPrintName, plen + 1, &lpOutBuffer->SymbolicLinkReparseBuffer.PathBuffer[lpOutBuffer->SymbolicLinkReparseBuffer.PrintNameOffset / sizeof(WCHAR)], plen); szPrintName[plen] = 0; size_t i; wcstombs_s(&i, pMBBuffer, (plen + 1), szPrintName, (plen + 1)); // TODO: Revisit with cleaner solution if (!PathIsRelative(pMBBuffer)) { std::string strFromChar; strFromChar.append("\\\\?\\"); strFromChar.append(pMBBuffer); char *target = _strdup(strFromChar.c_str()); // remove last folder char *pos = strrchr(path, '\\'); if (pos != NULL) { *pos = '\0'; } PathRelativePathTo(pMBBuffer, path, FILE_ATTRIBUTE_DIRECTORY, target, FILE_ATTRIBUTE_DIRECTORY); } } // TODO: Revisit with cleaner solution if (lpOutBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) { size_t slen = lpOutBuffer->MountPointReparseBuffer.SubstituteNameLength / sizeof(WCHAR); pMBBuffer = (char *)malloc((slen + 1)); WCHAR *szSubName = new WCHAR[slen + 1]; wcsncpy_s(szSubName, slen + 1, &lpOutBuffer->MountPointReparseBuffer.PathBuffer[lpOutBuffer->MountPointReparseBuffer.SubstituteNameOffset / sizeof(WCHAR)], slen); szSubName[slen] = 0; std::wstring wStringTemp(szSubName); std::string target(wStringTemp.begin(), wStringTemp.end()); target.erase(0, 2); target.insert(0, 2, '\\'); // remove last folder, see above char *pos = strrchr(path, '\\'); if (pos != NULL) { *pos = '\0'; } PathRelativePathTo(pMBBuffer, path, FILE_ATTRIBUTE_DIRECTORY, target.c_str(), FILE_ATTRIBUTE_DIRECTORY); } // write path always with / separator, so windows created symlinks work too std::string strFromChar; strFromChar.append(pMBBuffer); std::replace(strFromChar.begin(), strFromChar.end(), '\\', '/'); char *result = _strdup(strFromChar.c_str()); data.Set(result); free(pMBBuffer); free(result); } free(lpOutBuffer); } } CloseHandle(hFile); } symlink_attributes.attributes_follow = GetFileAttributesForNFS(path, &symlink_attributes.attributes); Write(&stat); Write(&symlink_attributes); if (stat == NFS3_OK) { Write(&data); } return stat; }
/// Microsoft helper function for getting the contents of a registry key void queryKey(const std::string& hive, const std::string& key, QueryData& results) { if (kRegistryHives.count(hive) != 1) { return; } HKEY hRegistryHandle; auto ret = RegOpenKeyEx(kRegistryHives.at(hive), TEXT(key.c_str()), 0, KEY_READ, &hRegistryHandle); if (ret != ERROR_SUCCESS) { return; } const DWORD maxKeyLength = 255; const DWORD maxValueName = 16383; TCHAR achClass[MAX_PATH] = TEXT(""); DWORD cchClassName = MAX_PATH; DWORD cSubKeys = 0; DWORD cbMaxSubKey; DWORD cchMaxClass; DWORD cValues; DWORD cchMaxValueName; DWORD cbMaxValueData; DWORD cbSecurityDescriptor; DWORD retCode; FILETIME ftLastWriteTime; retCode = RegQueryInfoKey(hRegistryHandle, achClass, &cchClassName, nullptr, &cSubKeys, &cbMaxSubKey, &cchMaxClass, &cValues, &cchMaxValueName, &cbMaxValueData, &cbSecurityDescriptor, &ftLastWriteTime); TCHAR achKey[maxKeyLength]; DWORD cbName; // Process registry subkeys if (cSubKeys > 0) { for (DWORD i = 0; i < cSubKeys; i++) { cbName = maxKeyLength; retCode = RegEnumKeyEx(hRegistryHandle, i, achKey, &cbName, nullptr, nullptr, nullptr, &ftLastWriteTime); if (retCode != ERROR_SUCCESS) { continue; } Row r; fs::path keyPath(key); r["hive"] = hive; r["key"] = keyPath.string(); r["subkey"] = (keyPath / achKey).string(); r["name"] = "(Default)"; r["type"] = "REG_SZ"; r["data"] = "(value not set)"; r["mtime"] = std::to_string(osquery::filetimeToUnixtime(ftLastWriteTime)); results.push_back(r); } } if (cValues <= 0) { return; } BYTE* bpDataBuff = new BYTE[cbMaxValueData]; DWORD cchValue = maxKeyLength; TCHAR achValue[maxValueName]; // Process registry values for (size_t i = 0, retCode = ERROR_SUCCESS; i < cValues; i++) { size_t cnt = 0; ZeroMemory(bpDataBuff, cbMaxValueData); cchValue = maxValueName; achValue[0] = '\0'; retCode = RegEnumValue(hRegistryHandle, static_cast<DWORD>(i), achValue, &cchValue, nullptr, nullptr, nullptr, nullptr); if (retCode != ERROR_SUCCESS) { continue; } DWORD lpData = cbMaxValueData; DWORD lpType; retCode = RegQueryValueEx( hRegistryHandle, achValue, 0, &lpType, bpDataBuff, &lpData); if (retCode != ERROR_SUCCESS) { continue; } Row r; fs::path keyPath(key); r["hive"] = hive; r["key"] = keyPath.string(); r["subkey"] = keyPath.string(); r["name"] = achValue; if (kRegistryTypes.count(lpType) > 0) { r["type"] = kRegistryTypes.at(lpType); } else { r["type"] = "UNKNOWN"; } r["mtime"] = std::to_string(osquery::filetimeToUnixtime(ftLastWriteTime)); bpDataBuff[cbMaxValueData - 1] = 0x00; /// REG_LINK is a Unicode string, which in Windows is wchar_t char* regLinkStr = nullptr; if (lpType == REG_LINK) { regLinkStr = new char[cbMaxValueData]; const size_t newSize = cbMaxValueData; size_t convertedChars = 0; wcstombs_s(&convertedChars, regLinkStr, newSize, (wchar_t*)bpDataBuff, _TRUNCATE); } BYTE* bpDataBuffTmp = bpDataBuff; std::vector<std::string> multiSzStrs; std::vector<char> regBinary; std::string data; switch (lpType) { case REG_FULL_RESOURCE_DESCRIPTOR: case REG_RESOURCE_LIST: case REG_BINARY: for (unsigned int i = 0; i < cbMaxValueData; i++) { regBinary.push_back((char)bpDataBuff[i]); } boost::algorithm::hex( regBinary.begin(), regBinary.end(), std::back_inserter(data)); r["data"] = data; break; case REG_DWORD: r["data"] = std::to_string(*((int*)bpDataBuff)); break; case REG_DWORD_BIG_ENDIAN: r["data"] = std::to_string(_byteswap_ulong(*((int*)bpDataBuff))); break; case REG_EXPAND_SZ: r["data"] = std::string((char*)bpDataBuff); break; case REG_LINK: r["data"] = std::string(regLinkStr); break; case REG_MULTI_SZ: while (*bpDataBuffTmp != 0x00) { std::string s((char*)bpDataBuffTmp); bpDataBuffTmp += s.size() + 1; multiSzStrs.push_back(s); } r["data"] = boost::algorithm::join(multiSzStrs, ","); break; case REG_NONE: r["data"] = std::string((char*)bpDataBuff); break; case REG_QWORD: r["data"] = std::to_string(*((unsigned long long*)bpDataBuff)); break; case REG_SZ: r["data"] = std::string((char*)bpDataBuff); break; default: r["data"] = ""; break; } results.push_back(r); if (regLinkStr != nullptr) { delete[](regLinkStr); } } delete[](bpDataBuff); RegCloseKey(hRegistryHandle); };
bool D3DManager::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullScreen) { HRESULT result; IDXGIFactory * factory = nullptr; IDXGIAdapter * adapter = nullptr; IDXGIOutput * adapterOutput = nullptr; unsigned int numModes; unsigned int numerator = 0; unsigned int denominator = 0; unsigned int stringLenht; DXGI_MODE_DESC * displayModeList = nullptr; DXGI_ADAPTER_DESC adapterDesc; int error; ID3D11Texture2D * backBuffer = nullptr; // Guardo el vsycn m_vsync_enable = vsync; // Creo una interfas con DirectX (IDXGIFactory) result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); if (FAILED(result)) { // TODO: Informar del Error return false; } // Uso el IDXGIFactory para crear un adapatador(Placa de Video) result = factory->EnumAdapters(0, &adapter); if (FAILED(result)) { // TODO: Informar del Error return false; } // Enumero la cantidad de monitores (Adaptador de salida) result = adapter->EnumOutputs(0, &adapterOutput); if (FAILED(result)) { // TODO: Informar del Error return false; } // Obtengo el numero de modos que se ajustan al formato DXGI_FORMAT_R8G8B8A8 para el monitor result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL); if (FAILED(result)) { // TODO: Informar del Error return false; } // Creo una lista con todos los posbles modos para esta combinacion placa de video monitor. displayModeList = new DXGI_MODE_DESC[numModes]; // Cargo la lista de display Mode result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); if (FAILED(result)) { // TODO: Informar del Error return false; } for (int i = 0; i < (int)numModes; ++i) { if (displayModeList[i].Width == (unsigned int)screenWidth && displayModeList[i].Height == (unsigned int)screenHeight) { numerator = displayModeList[i].RefreshRate.Numerator; denominator = displayModeList[i].RefreshRate.Denominator; //TODO: Loquidar el for al encontrar el valor correcto } } if (numerator == 0 && denominator == 0) { // Informar Error return false; } // Obtengo la descripcion del adaptador result = adapter->GetDesc(&adapterDesc); if (FAILED(result)) { // TODO: Informar del Error return false; } // Guardo la cantidad de memorya de video m_videoCardMemory = adapterDesc.DedicatedVideoMemory; // Convierto el nombre de la VGA a string char tmp_string[128]; error = wcstombs_s(&stringLenht, tmp_string, 128, adapterDesc.Description, 128); if (error != 0) { // TODO: Informar del Error return false; } m_videoCardDescription = tmp_string; // Released Memory delete [] displayModeList; displayModeList = nullptr; adapterOutput->Release(); adapterOutput = nullptr; adapter->Release(); adapter = nullptr; factory->Release(); factory = nullptr; if (!InitializeSwapChain(hwnd, fullScreen, screenWidth, screenHeight, numerator, denominator)) { // Todo: Informar El Error return false; } // Obtengo el puntero al BackBuffer result = mp_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBuffer); if (FAILED(result)) { // TODO: Informar del Error return false; } // Creo el render Target View result = mp_device->CreateRenderTargetView(backBuffer, NULL, &mp_renderTargetView); if (FAILED(result)) { // TODO: Informar del Error return false; } // No te Nesesito MUERE backBuffer->Release(); backBuffer = nullptr; if (!InitializeDepthBuffer(screenWidth, screenHeight)) { // TODO: Informar del Error return false; } if (!InitializeDepthStencilBuffer()) { // TODO: Informar del Error return false; } if (!InitializeStencilView()) { // TODO: Informar del Error return false; } mp_deviceContext->OMSetRenderTargets(1, &mp_renderTargetView, mp_depthStencilView); if (!InitializeRasterizerStete()) { // TODO: Informar del Error return false; } InitializeViewport(screenWidth, screenHeight); if (!InitializeAlphaBlending()) { // TODO: Informar del Error return false; } if (!InitializeZBuffer()) { // TODO: Informar del Error return false; } return true; }
STDAPI DllRegisterServer(void) { char szID[128]; WCHAR wcID[128]; char szCLSID[128]; TCHAR szModule[MAX_PATH+ 1]; char * pName = "WMI Sample Prop Provider"; char * pModel = "Both"; size_t * intReturnValue = NULL; HKEY hKey1, hKey2; // Create the path. memset(wcID, NULL, sizeof(wcID)); memset(szID, NULL, sizeof(szID)); StringFromGUID2(CLSID_PropProvider, wcID, sizeof(wcID)/sizeof(WCHAR) - 1); wcstombs_s(intReturnValue, szID, sizeof(szID), wcID, sizeof(szID)); StringCbCopy(szCLSID, sizeof(szCLSID), "Software\\classes\\CLSID\\"); StringCbCat(szCLSID, sizeof(szCLSID), (LPCTSTR)szID); // Create entries under CLSID LONG lRet = RegCreateKeyEx( HKEY_LOCAL_MACHINE, szCLSID, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey1, NULL ); if (lRet != ERROR_SUCCESS) { return E_FAIL; } lRet = RegSetValueEx(hKey1, NULL, 0, REG_SZ, (BYTE *)pName, strlen(pName)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hKey1); return E_FAIL; } lRet = RegCreateKeyEx( hKey1, "InprocServer32", 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey2, NULL ); if (lRet != ERROR_SUCCESS) { RegCloseKey(hKey1); return E_FAIL; } memset(&szModule, NULL, sizeof(szModule)); GetModuleFileName(ghModule, szModule, sizeof(szModule)/sizeof(TCHAR) - 1); lRet = RegSetValueEx(hKey2, NULL, 0, REG_SZ, (BYTE *)szModule, strlen(szModule)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hKey2); RegCloseKey(hKey1); return E_FAIL; } lRet = RegSetValueEx(hKey2, "ThreadingModel", 0, REG_SZ, (BYTE *)pModel, strlen(pModel)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hKey2); RegCloseKey(hKey1); return E_FAIL; } RegCloseKey(hKey1); RegCloseKey(hKey2); return NOERROR; }
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); }
bool tinyXMLPrase() { bool succeed = false; //ת»»¿í×Ö½Úµ½char setlocale(LC_ALL, "zh-CN"); size_t len = wcslen(strFile) + 1; size_t converted = 0; char *CStr; CStr = (char*)malloc(len*sizeof(char)*2); wcstombs_s(&converted, CStr, len*2, strFile, len*2); TiXmlDocument * myDocument = new TiXmlDocument(CStr); myDocument->LoadFile(); if (myDocument->Error()) { MessageBox(theHWND, L"XML¶Áȡʧ°Ü", L"´íÎó", 0); return false; } try { TiXmlElement * RootElement = myDocument->RootElement(); for (TiXmlElement * TestCase = RootElement->FirstChildElement(); TestCase != NULL; TestCase = TestCase->NextSiblingElement()) { int ID; TestCase->QueryIntAttribute("ID", &ID); if (ID != SETTING_XML_TESTCASE) { TestCase->Clear(); continue; } succeed = true; for (TiXmlElement * DataNode = TestCase->FirstChildElement(); DataNode != NULL; DataNode = DataNode->NextSiblingElement()) { if (strcmp(DataNode->Value(), "Entity") == 0) { if (strcmp(DataNode->Attribute("Type"), "Line") == 0) { Line * line = (Line *)mempool->Alloc(sizeof(Line)); for (TiXmlElement * pointNode = DataNode->FirstChildElement(); pointNode != NULL; pointNode = pointNode->NextSiblingElement()) { if (strcmp(pointNode->Value(), "StartPoint") == 0) { sscanf_s(pointNode->GetText(), "%hd,%hd", &line->x1, &line->y1); } else if (strcmp(pointNode->Value(), "EndPoint") == 0) { sscanf_s(pointNode->GetText(), "%hd,%hd", &line->x2, &line->y2); } } lineList.push_back(line); } else if (strcmp(DataNode->Attribute("Type"), "Circle") == 0) { Circle * circle = (Circle *)mempool->Alloc(sizeof(Circle));; for (TiXmlElement * pointNode = DataNode->FirstChildElement(); pointNode != NULL; pointNode = pointNode->NextSiblingElement()) { if (strcmp(pointNode->Value(), "CenterPoint") == 0) { sscanf_s(pointNode->GetText(), "%hd,%hd", &circle->x, &circle->y); } else if (strcmp(pointNode->Value(), "Radius") == 0) { sscanf_s(pointNode->GetText(), "%hd", &circle->r); } } circleList.push_back(circle); } } else if (strcmp(DataNode->Value(), "Boundary") == 0) { for (TiXmlElement * pointNode = DataNode->FirstChildElement(); pointNode != NULL; pointNode = pointNode->NextSiblingElement()) { if (strcmp(pointNode->Value(), "Vertex") != 0) continue; Point * point = (Point *)mempool->Alloc(sizeof(Point)); sscanf_s(pointNode->GetText(), "%hd,%hd", &point->x, &point->y); polygonList.push_back(point); } } else { //Òì³££¬»¹ÊǺöÂÔÁË°É } } } } catch (...) { myDocument->Clear(); delete(myDocument); MessageBox(theHWND, L"δ֪´íÎó", L"´íÎó", 0); return false; } if (!succeed) { myDocument->Clear(); delete(myDocument); MessageBox(theHWND, L"ûÓÐÕÒµ½Êý¾Ý½Úµã", L"´íÎó", 0); return false; } myDocument->Clear(); delete(myDocument); return true; }
bool D3D::InitializeD3D(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen) { HRESULT result; //used to test things are created ok. vsync; //---------------------------------------------------------------------------------------------- // Fetch the numerator and denominator for refresh rate and video card description. // Create DirectX Graphics Interface factory. IDXGIFactory* factory; result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); if(FAILED(result)) return false; // Create adapter. IDXGIAdapter* adapter; result = factory->EnumAdapters(0, &adapter); if(FAILED(result)) return false; // Enumerate 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_R8G8B8A8_UNORM display format for adpater output. unsigned int numModes; 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; displayModeList = new DXGI_MODE_DESC[numModes]; if(!displayModeList) return false; // Fill list. result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList); if(FAILED(result)) return false; // Loop through modes and find one that matches screen width and height, store numerator and // denominator for corresponding refresh rate. unsigned int numerator, denominator; for(unsigned int i = 0; i < numModes; ++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 adapter description. DXGI_ADAPTER_DESC adapterDesc; result = adapter->GetDesc(&adapterDesc); if(FAILED(result)) return false; // Store dedicated video card memory (in mb). m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // Convert the name of the video card to char array and store. unsigned int stringLength; int error = wcstombs_s(&stringLength, m_videoCardDesc, 128, adapterDesc.Description, 128); if(error != 0) return false; // Release unneeded memory. delete[] displayModeList; displayModeList = 0; adapterOutput->Release(); adapterOutput = 0; adapter->Release(); adapter = 0; factory->Release(); factory = 0; //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Set up SwapChain description and create swap chain. DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(swapChainDesc)); // Setup back buffer. swapChainDesc.BufferCount = 1; swapChainDesc.BufferDesc.Width = screenWidth; swapChainDesc.BufferDesc.Height = screenHeight; swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; // Refresh Rate. if(m_vsyncEnabled) { swapChainDesc.BufferDesc.RefreshRate.Numerator = numerator; swapChainDesc.BufferDesc.RefreshRate.Denominator = denominator; } else { // Draw as soon as possible. swapChainDesc.BufferDesc.RefreshRate.Numerator = 0; swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; } swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.OutputWindow = hwnd; // Turn off multisampling. swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.Windowed = !fullscreen; 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. 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; //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Set up render target view. ID3D11Texture2D* backBufferPtr; result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr); if(FAILED(result)) return false; // Create render target view with back buffer ptr. result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView); if(FAILED(result)) return false; backBufferPtr->Release(); backBufferPtr = 0; //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Set up depthStencilBuffer. D3D11_TEXTURE2D_DESC depthBufferDesc; ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); // Set up 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; // Create depth/stencil buffer. result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer); if(FAILED(result)) return false; // Setup depth stencil description. 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; 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 depth stencil state. result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState); if(FAILED(result)) return false; // Set depth stencil state. m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1); //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Create second depth stencil state with depth disabled. (for 2D rendering) D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc; 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_DECR; 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; //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Create description of the view of the depth stencil buffer. // Do this so D3D knows to use the depth buffer as a depth stencil texture. 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 render target view and depth stencil buffer to output render pipeline. m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView); //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Create rasterizer state and viewport. 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.0; result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState); if(FAILED(result)) return false; m_deviceContext->RSSetState(m_rasterState); // Set up viewport. 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); //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- // Create blend states. D3D11_BLEND_DESC blendStateDesc; ZeroMemory(&blendStateDesc, sizeof(D3D11_BLEND_DESC)); blendStateDesc.RenderTarget[0].BlendEnable = TRUE; blendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; blendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE; blendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; blendStateDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; blendStateDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; blendStateDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; blendStateDesc.RenderTarget[0].RenderTargetWriteMask = 0x0f; result = m_device->CreateBlendState(&blendStateDesc, &m_alphaEnableBlendingState); if(FAILED(result)) { return false; } blendStateDesc.RenderTarget[0].BlendEnable = FALSE; result = m_device->CreateBlendState(&blendStateDesc, &m_alphaDisableBlendingState); if(FAILED(result)) { return false; } //---------------------------------------------------------------------------------------------- return true; }