#include "quakedef.h" #ifdef D3D11QUAKE #include "winquake.h" #include "gl_draw.h" #include "glquake.h" #include "shader.h" #include "renderque.h" #include "resource.h" #define FUCKDXGI #define COBJMACROS #include ID3D11Device *pD3DDev11; ID3D11DeviceContext *d3ddevctx; //#include //ID3D11DeviceContext1 *d3ddevctx1; #ifdef WINRT //winrt crap has its own non-hwnd window crap, after years of microsoft forcing everyone to use hwnds for everything. I wonder why they don't have that many winrt apps. #pragma comment(lib, "dxgi.lib") #pragma comment(lib, "D3D11.lib") #include "dxgi1_2.h" #else /*Fixup outdated windows headers*/ #ifndef WM_XBUTTONDOWN #define WM_XBUTTONDOWN 0x020B #define WM_XBUTTONUP 0x020C #endif #ifndef MK_XBUTTON1 #define MK_XBUTTON1 0x0020 #endif #ifndef MK_XBUTTON2 #define MK_XBUTTON2 0x0040 #endif // copied from DarkPlaces in an attempt to grab more buttons #ifndef MK_XBUTTON3 #define MK_XBUTTON3 0x0080 #endif #ifndef MK_XBUTTON4 #define MK_XBUTTON4 0x0100 #endif #ifndef MK_XBUTTON5 #define MK_XBUTTON5 0x0200 #endif #ifndef MK_XBUTTON6 #define MK_XBUTTON6 0x0400 #endif #ifndef MK_XBUTTON7 #define MK_XBUTTON7 0x0800 #endif #ifndef WM_INPUT #define WM_INPUT 255 #endif #endif #define DEFINE_QGUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ const GUID DECLSPEC_SELECTANY name \ = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } DEFINE_QGUID(qIID_ID3D11Texture2D,0x6f15aaf2,0xd208,0x4e89,0x9a,0xb4,0x48,0x95,0x35,0xd3,0x4f,0x9c); #ifdef WINRT IDXGISwapChain1 *d3dswapchain; #else IDXGISwapChain *d3dswapchain; #endif IDXGIOutput *d3dscreen; ID3D11RenderTargetView *fb_backbuffer; ID3D11DepthStencilView *fb_backdepthstencil; void *d3d11mod; static unsigned int d3d11multisample_count, d3d11multisample_quality; qboolean vid_initializing; extern qboolean scr_initialized; // ready to draw extern qboolean scr_drawloading; extern qboolean scr_con_forcedraw; static qboolean d3d_resized; //sound/error code needs this HWND mainwindow; //input code needs these int window_center_x, window_center_y; RECT window_rect; int window_x, window_y; static void released3dbackbuffer(void); static qboolean resetd3dbackbuffer(int width, int height); #if 0//def _DEBUG #include const GUID IID_IDXGIDebug = { 0x119E7452,0xDE9E,0x40fe, { 0x88,0x06,0x88,0xF9,0x0C,0x12,0xB4,0x41 } }; const GUID DXGI_DEBUG_ALL = { 0xe48ae283, 0xda80, 0x490b, {0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8 }}; void DoDXGIDebug(void) { IDXGIDebug *dbg = NULL; HRESULT (WINAPI *pDXGIGetDebugInterface)(REFIID riid, void **ppDebug); dllfunction_t dxdidebugfuncs[] = { {(void**)&pDXGIGetDebugInterface, "DXGIGetDebugInterface"}, {NULL} }; pDXGIGetDebugInterface = NULL; Sys_LoadLibrary("dxgidebug", dxdidebugfuncs); pDXGIGetDebugInterface(&IID_IDXGIDebug, &dbg); if (dbg) { IDXGIDebug_ReportLiveObjects(dbg, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL); IDXGIDebug_Release(dbg); } } #else #define DoDXGIDebug() #endif char *D3D_NameForResult(HRESULT hr) { if (hr == DXGI_ERROR_DEVICE_REMOVED && pD3DDev11) hr = ID3D11Device_GetDeviceRemovedReason(pD3DDev11); switch(hr) { case E_OUTOFMEMORY: return "E_OUTOFMEMORY"; case E_NOINTERFACE: return "E_NOINTERFACE"; case DXGI_ERROR_DEVICE_HUNG: return "DXGI_ERROR_DEVICE_HUNG"; case DXGI_ERROR_DEVICE_REMOVED: return "DXGI_ERROR_DEVICE_REMOVED"; case DXGI_ERROR_DEVICE_RESET: return "DXGI_ERROR_DEVICE_RESET"; case DXGI_ERROR_DRIVER_INTERNAL_ERROR: return "DXGI_ERROR_DRIVER_INTERNAL_ERROR"; case DXGI_ERROR_INVALID_CALL: return "DXGI_ERROR_INVALID_CALL"; default: return va("%lx", hr); } } static void D3D11_PresentOrCrash(void) { extern cvar_t vid_vsync; RSpeedMark(); HRESULT hr = IDXGISwapChain_Present(d3dswapchain, max(0,vid_vsync.ival), 0); if (FAILED(hr)) Sys_Error("IDXGISwapChain_Present: %s\n", D3D_NameForResult(hr)); RSpeedEnd(RSPEED_PRESENT); } typedef enum {MS_WINDOWED, MS_FULLSCREEN, MS_FULLWINDOW, MS_UNINIT} dx11modestate_t; static dx11modestate_t modestate; //FIXME: need to push/pop render targets like gl does, to not harm shadowmaps/refraction/etc. void D3D11_ApplyRenderTargets(qboolean usedepth) { unsigned int width = 0, height = 0; int i; texid_t textures[1]; texid_t depth; ID3D11RenderTargetView *rtv[sizeof(textures)/sizeof(textures[0])]; ID3D11DepthStencilView *dsv; for (i = 0; i < sizeof(textures)/sizeof(textures[0]); i++) { if (!*r_refdef.rt_destcolour[i].texname) break; textures[i] = R2D_RT_GetTexture(r_refdef.rt_destcolour[i].texname, &width, &height); if (textures[i]->ptr2) { ID3D11ShaderResourceView_Release((ID3D11ShaderResourceView*)textures[i]->ptr2); textures[i]->ptr2 = NULL; } ID3D11Device_CreateRenderTargetView(pD3DDev11, textures[i]->ptr, NULL, &rtv[i]); } if (usedepth) { if (*r_refdef.rt_depth.texname) depth = R2D_RT_GetTexture(r_refdef.rt_depth.texname, &width, &height); else depth = R2D_RT_Configure("depth", width, height, PTI_DEPTH24, RT_IMAGEFLAGS); } else depth = NULL; if (depth && depth->ptr) { if (depth->ptr2) { ID3D11DepthStencilView_Release((ID3D11DepthStencilView*)depth->ptr2); depth->ptr2 = NULL; } ID3D11Device_CreateDepthStencilView(pD3DDev11, depth->ptr, NULL, &dsv); } else dsv = NULL; ID3D11DeviceContext_OMSetRenderTargets(d3ddevctx, i, rtv, dsv); for (i = 0; i < sizeof(textures)/sizeof(textures[0]); i++) if (rtv[i]) ID3D11RenderTargetView_Release(rtv[i]); if (dsv) { ID3D11DeviceContext_ClearDepthStencilView(d3ddevctx, dsv, D3D11_CLEAR_DEPTH, 1, 0); //is it faster to clear the stencil too? ID3D11DepthStencilView_Release(dsv); } } #ifndef WINRT //winrt crap has its own non-hwnd window crap, after years of microsoft forcing everyone to use hwnds for everything. I wonder why they don't have that many winrt apps. static void D3DVID_UpdateWindowStatus (HWND hWnd) { POINT p; RECT nr; int window_width, window_height; GetClientRect(hWnd, &nr); // Sys_Printf("Update: %i %i %i %i\n", nr.left, nr.top, nr.right, nr.bottom); //if its bad then we're probably minimised if (nr.right <= nr.left) return; if (nr.bottom <= nr.top) return; p.x = 0; p.y = 0; ClientToScreen(hWnd, &p); window_x = p.x; window_y = p.y; window_width = nr.right - nr.left; window_height = nr.bottom - nr.top; // vid.pixelwidth = window_width; // vid.pixelheight = window_height; window_rect.left = window_x; window_rect.top = window_y; window_rect.right = window_x + window_width; window_rect.bottom = window_y + window_height; window_center_x = (window_rect.left + window_rect.right) / 2; window_center_y = (window_rect.top + window_rect.bottom) / 2; // Sys_Printf("Window: %i %i %i %i\n", window_x, window_y, window_width, window_height); INS_UpdateClipCursor (); } static qboolean D3D11AppActivate(BOOL fActive, BOOL minimize) /**************************************************************************** * * Function: AppActivate * Parameters: fActive - True if app is activating * * Description: If the application is activating, then swap the system * into SYSPAL_NOSTATIC mode so that our palettes will display * correctly. * ****************************************************************************/ { static BOOL sound_active; if (vid.activeapp == fActive && Minimized == minimize) return false; //so windows doesn't crash us over and over again. vid.activeapp = fActive; Minimized = minimize; // enable/disable sound on focus gain/loss if (!vid.activeapp && sound_active) { S_BlockSound (); sound_active = false; } else if (vid.activeapp && !sound_active) { S_UnblockSound (); sound_active = true; } INS_UpdateGrabs(modestate != MS_WINDOWED, vid.activeapp); return true; } #ifndef FUCKDXGI static void D3D11_DoResize(void) { d3d_resized = true; D3DVID_UpdateWindowStatus(mainwindow); if (d3dscreen) { //seriously? this is disgusting. DXGI_OUTPUT_DESC desc; IDXGIOutput_GetDesc(d3dscreen, &desc); vid.pixelwidth = desc.DesktopCoordinates.right - desc.DesktopCoordinates.left; vid.pixelheight = desc.DesktopCoordinates.bottom - desc.DesktopCoordinates.top; } else { vid.pixelwidth = window_rect.right - window_rect.left; vid.pixelheight = window_rect.bottom - window_rect.top; } // Con_Printf("Resizing buffer to %i*%i\n", vid.pixelwidth, vid.pixelheight); released3dbackbuffer(); IDXGISwapChain_ResizeBuffers(d3dswapchain, 0, vid.pixelwidth, vid.pixelheight, DXGI_FORMAT_UNKNOWN, DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH); D3D11BE_Reset(true); resetd3dbackbuffer(vid.pixelwidth, vid.pixelheight); D3D11BE_Reset(false); } #endif static void ClearAllStates (void) { int i; // send an up event for each key, to make sure the server clears them all for (i=0 ; i<256 ; i++) { Key_Event (0, i, 0, false); } Key_ClearStates (); INS_ClearStates (); } static LRESULT WINAPI D3D11_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LONG lRet = 0; int temp; extern unsigned int uiWheelMessage; #ifndef FUCKDXGI extern qboolean keydown[K_MAX]; #endif if ( uMsg == uiWheelMessage ) uMsg = WM_MOUSEWHEEL; switch (uMsg) { #if 1 case WM_KILLFOCUS: if (modestate == MS_FULLWINDOW) ShowWindow(mainwindow, SW_SHOWMINNOACTIVE); D3D11AppActivate(false, false); break; case WM_SETFOCUS: if (modestate == MS_FULLWINDOW) ShowWindow(mainwindow, SW_SHOWMAXIMIZED); D3D11AppActivate(true, false); if (modestate == MS_FULLSCREEN && d3dswapchain) IDXGISwapChain_SetFullscreenState(d3dswapchain, vid.activeapp, (vid.activeapp)?d3dscreen:NULL); Cvar_ForceCallback(&v_gamma); ClearAllStates (); break; // case WM_CREATE: // break; case WM_MOVE: D3DVID_UpdateWindowStatus (hWnd); lRet = DefWindowProc (hWnd, uMsg, wParam, lParam); break; case WM_KEYDOWN: case WM_SYSKEYDOWN: #if 0 if (keydown[K_LALT] && wParam == '\r') { if (d3dscreen) { IDXGIOutput_Release(d3dscreen); d3dscreen = NULL; } if (modestate == MS_FULLSCREEN) modestate = MS_WINDOWED; else { RECT rect; extern cvar_t vid_width, vid_height; int width = vid_width.ival; int height = vid_height.ival; if (!width || !height) { DXGI_OUTPUT_DESC desc; IDXGISwapChain_GetContainingOutput(d3dswapchain, &d3dscreen); IDXGIOutput_GetDesc(d3dscreen, &desc); rect = desc.DesktopCoordinates; } else { rect.left = (GetSystemMetrics(SM_CXSCREEN) - width) / 2; rect.top = (GetSystemMetrics(SM_CYSCREEN) - height) / 2; rect.right = rect.left+width; rect.bottom = rect.top+height; } AdjustWindowRectEx(&rect, WS_OVERLAPPED, FALSE, 0); SetWindowPos(hWnd, NULL, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, SWP_SHOWWINDOW|SWP_FRAMECHANGED); modestate = MS_FULLSCREEN; } if (!d3dscreen && modestate == MS_FULLSCREEN) IDXGISwapChain_GetContainingOutput(d3dswapchain, &d3dscreen); IDXGISwapChain_SetFullscreenState(d3dswapchain, modestate == MS_FULLSCREEN, (modestate == MS_FULLSCREEN)?d3dscreen:NULL); if (modestate == MS_WINDOWED) { RECT rect; int width = 640; int height = 480; rect.left = (GetSystemMetrics(SM_CXSCREEN) - width) / 2; rect.top = (GetSystemMetrics(SM_CYSCREEN) - height) / 2; rect.right = rect.left+width; rect.bottom = rect.top+height; AdjustWindowRectEx(&rect, WS_OVERLAPPEDWINDOW, FALSE, 0); SetWindowLong(hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW); //make sure dxgi didn't break us. SetWindowPos(hWnd, HWND_TOP, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, SWP_SHOWWINDOW|SWP_FRAMECHANGED); SetForegroundWindow(hWnd); SetFocus(hWnd); //work around a windows bug by forcing all windows to be repainted. InvalidateRect(NULL, NULL, false); } D3D11_DoResize(); Cvar_ForceCallback(&v_gamma); } else #endif if (!vid_initializing) INS_TranslateKeyEvent (wParam, lParam, true, 0, false); break; case WM_KEYUP: case WM_SYSKEYUP: if (!vid_initializing) INS_TranslateKeyEvent (wParam, lParam, false, 0, false); break; case WM_APPCOMMAND: lRet = INS_AppCommand(lParam); break; case WM_SYSCHAR: // keep Alt-Space from happening break; // this is complicated because Win32 seems to pack multiple mouse events into // one update sometimes, so we always check all states and look for events case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_RBUTTONDOWN: case WM_RBUTTONUP: case WM_MBUTTONDOWN: case WM_MBUTTONUP: case WM_MOUSEMOVE: case WM_XBUTTONDOWN: case WM_XBUTTONUP: temp = 0; if (wParam & MK_LBUTTON) temp |= 1; if (wParam & MK_RBUTTON) temp |= 2; if (wParam & MK_MBUTTON) temp |= 4; if (wParam & MK_XBUTTON1) temp |= 8; if (wParam & MK_XBUTTON2) temp |= 16; if (wParam & MK_XBUTTON3) temp |= 32; if (wParam & MK_XBUTTON4) temp |= 64; if (wParam & MK_XBUTTON5) temp |= 128; if (wParam & MK_XBUTTON6) temp |= 256; if (wParam & MK_XBUTTON7) temp |= 512; if (!vid_initializing) INS_MouseEvent (temp); break; // JACK: This is the mouse wheel with the Intellimouse // Its delta is either positive or neg, and we generate the proper // Event. case WM_MOUSEWHEEL: if (!vid_initializing) { if ((short) HIWORD(wParam) > 0) { Key_Event(0, K_MWHEELUP, 0, true); Key_Event(0, K_MWHEELUP, 0, false); } else { Key_Event(0, K_MWHEELDOWN, 0, true); Key_Event(0, K_MWHEELDOWN, 0, false); } } break; case WM_INPUT: // raw input handling if (!vid_initializing) INS_RawInput_Read((HANDLE)lParam); break; case WM_DEVICECHANGE: COM_AddWork(WG_MAIN, INS_DeviceChanged, NULL, NULL, uMsg, 0); lRet = TRUE; break; case WM_SETCURSOR: //only use a custom cursor if the cursor is inside the client area switch(lParam&0xffff) { case 0: break; case HTCLIENT: if (hCustomCursor) //custom cursor enabled SetCursor(hCustomCursor); else //fallback on an arrow cursor, just so we have something visible at startup or so SetCursor(hArrowCursor); lRet = TRUE; break; default: lRet = DefWindowProcW (hWnd, uMsg, wParam, lParam); break; } break; case WM_GETMINMAXINFO: { RECT windowrect; RECT clientrect; MINMAXINFO *mmi = (MINMAXINFO *) lParam; GetWindowRect (hWnd, &windowrect); GetClientRect (hWnd, &clientrect); mmi->ptMinTrackSize.x = 320 + ((windowrect.right - windowrect.left) - (clientrect.right - clientrect.left)); mmi->ptMinTrackSize.y = 200 + ((windowrect.bottom - windowrect.top) - (clientrect.bottom - clientrect.top)); } return 0; case WM_SIZE: if (d3dswapchain) { d3d_resized = true; D3DVID_UpdateWindowStatus(mainwindow); released3dbackbuffer(); IDXGISwapChain_ResizeBuffers(d3dswapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH); D3D11BE_Reset(true); vid.pixelwidth = window_rect.right - window_rect.left; vid.pixelheight = window_rect.bottom - window_rect.top; resetd3dbackbuffer(vid.pixelwidth, vid.pixelheight); D3D11BE_Reset(false); } lRet = DefWindowProc(hWnd, uMsg, wParam, lParam); break; case WM_CLOSE: if (!vid_initializing) if (MessageBox (mainwindow, "Are you sure you want to quit?", "Confirm Exit", MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION) == IDYES) { Cbuf_AddText("\nquit\n", RESTRICT_LOCAL); } break; case WM_DESTROY: { // if (dibwindow) // DestroyWindow (dibwindow); } break; #ifdef HAVE_CDPLAYER case MM_MCINOTIFY: lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam); break; #endif #endif case WM_ERASEBKGND: return 1; default: /* pass all unhandled messages to DefWindowProc */ lRet = DefWindowProc (hWnd, uMsg, wParam, lParam); break; } /* return 1 if handled message, 0 if not */ return lRet; } #endif #if (WINVER < 0x500) && !defined(__GNUC__) typedef struct tagMONITORINFO { DWORD cbSize; RECT rcMonitor; RECT rcWork; DWORD dwFlags; } MONITORINFO, *LPMONITORINFO; #endif static void released3dbackbuffer(void) { if (d3ddevctx) ID3D11DeviceContext_OMSetRenderTargets(d3ddevctx, 0, NULL, NULL); if (fb_backbuffer) ID3D11RenderTargetView_Release(fb_backbuffer); fb_backbuffer = NULL; if (fb_backdepthstencil) ID3D11DepthStencilView_Release(fb_backdepthstencil); fb_backdepthstencil = NULL; } static qboolean resetd3dbackbuffer(int width, int height) { D3D11_TEXTURE2D_DESC t2ddesc; // D3D11_DEPTH_STENCIL_VIEW_DESC dsvd; ID3D11Texture2D *backbuftex, *depthtex; released3dbackbuffer(); //get a proper handle to the backbuffer (silly hurdles) if (FAILED(IDXGISwapChain_GetBuffer(d3dswapchain, 0, &qIID_ID3D11Texture2D, (LPVOID*)&backbuftex))) return false; if (FAILED(ID3D11Device_CreateRenderTargetView(pD3DDev11, (ID3D11Resource*)backbuftex, NULL, &fb_backbuffer))) return false; ID3D11Texture2D_Release(backbuftex); //set up a depth buffer. memset(&t2ddesc, 0, sizeof(t2ddesc)); t2ddesc.Width = width; t2ddesc.Height = height; t2ddesc.MipLevels = 1; t2ddesc.ArraySize = 1; t2ddesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; t2ddesc.SampleDesc.Count = d3d11multisample_count; t2ddesc.SampleDesc.Quality = d3d11multisample_quality; t2ddesc.Usage = D3D11_USAGE_DEFAULT; t2ddesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; t2ddesc.CPUAccessFlags = 0; t2ddesc.MiscFlags = 0; if(FAILED(ID3D11Device_CreateTexture2D(pD3DDev11, &t2ddesc, NULL, &depthtex))) return false; // dsvd.Format = t2ddesc.Format; // dsvd.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; // dsvd.Texture2D.MipSlice = 0; if(FAILED(ID3D11Device_CreateDepthStencilView(pD3DDev11, (ID3D11Resource*)depthtex, NULL/*&dsvd*/, &fb_backdepthstencil))) return false; ID3D11Texture2D_Release(depthtex); //now tell d3d which render targets to use. ID3D11DeviceContext_OMSetRenderTargets(d3ddevctx, 1, &fb_backbuffer, fb_backdepthstencil); return true; } #ifdef WINRT //winrt crap has its own non-hwnd window crap, after years of microsoft forcing everyone to use hwnds for everything. I wonder why they don't have that many winrt apps. void D3D11_DoResize(int newwidth, int newheight) { d3d_resized = true; // Con_Printf("Resizing buffer to %i*%i\n", vid.pixelwidth, vid.pixelheight); released3dbackbuffer(); if (d3dswapchain) { IDXGISwapChain_ResizeBuffers(d3dswapchain, 0, vid.pixelwidth, vid.pixelheight, DXGI_FORMAT_UNKNOWN, DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH); D3D11BE_Reset(true); resetd3dbackbuffer(vid.pixelwidth, vid.pixelheight); D3D11BE_Reset(false); } } void *RT_GetCoreWindow(int *width, int *height); static qboolean D3D11_VID_Init(rendererstate_t *info, unsigned char *palette) { static IID factiid1 = {0x770aae78, 0xf26f, 0x4dba, 0xa8, 0x29, 0x25, 0x3c, 0x83, 0xd1, 0xb3, 0x87}; static IID factiid2 = {0x50c83a1c, 0xe072, 0x4c48, 0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0}; IDXGIFactory2 *fact = NULL; HRESULT hr; D3D_FEATURE_LEVEL flevel, flevels[] = { //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 }; DXGI_SWAP_CHAIN_DESC1 scd = {0}; IUnknown *window = RT_GetCoreWindow(&info->width, &info->height); modestate = MS_FULLSCREEN; //fill scd scd.Width = info->width; scd.Height = info->height; scd.Format = info->srgb?DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:DXGI_FORMAT_B8G8R8A8_UNORM; scd.Stereo = info->stereo; scd.SampleDesc.Count = d3d11multisample_count = max(1,info->multisample); scd.SampleDesc.Quality = d3d11multisample_quality = (d3d11multisample_count>1)?~0:0; scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; scd.BufferCount = 2+info->triplebuffer; //rt only supports fullscreen, so the frontbuffer needs to be created by us. scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; scd.Flags = 0; //create d3d stuff hr = CreateDXGIFactory1(&factiid2, &fact); if (FAILED(D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, flevels, sizeof(flevels)/sizeof(flevels[0]), D3D11_SDK_VERSION, &pD3DDev11, &flevel, &d3ddevctx))) Sys_Error("D3D11CreateDevice failed\n"); else { if (FAILED(IDXGIFactory2_CreateSwapChainForCoreWindow(fact, (IUnknown*)pD3DDev11, window, &scd, NULL, &d3dswapchain))) Sys_Error("IDXGIFactory2_CreateSwapChainForCoreWindow failed\n"); else { vid.numpages = scd.BufferCount; if (!resetd3dbackbuffer(info->width, info->height)) Sys_Error("unable to reset back buffer\n"); else { if (!D3D11Shader_Init(flevel)) Con_Printf("Unable to intialise a suitable HLSL compiler, please install the DirectX runtime.\n"); else return true; } } } return false; } #else static qboolean initD3D11Device(HWND hWnd, rendererstate_t *info, PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN func, IDXGIAdapter *adapt) { UINT support; int flags = 0;//= D3D11_CREATE_DEVICE_SINGLETHREADED; D3D_DRIVER_TYPE drivertype; DXGI_SWAP_CHAIN_DESC scd; D3D_FEATURE_LEVEL flevel, flevels[] = { //D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, //FIXME: need npot. D3D_FEATURE_LEVEL_9_3, D3D_FEATURE_LEVEL_9_2, D3D_FEATURE_LEVEL_9_1 }; memset(&scd, 0, sizeof(scd)); if (!stricmp(info->subrenderer, "debug")) flags |= D3D11_CREATE_DEVICE_DEBUG; if (!stricmp(info->subrenderer, "warp")) drivertype = D3D_DRIVER_TYPE_WARP; else if (!stricmp(info->subrenderer, "ref")) drivertype = D3D_DRIVER_TYPE_REFERENCE; else if (!stricmp(info->subrenderer, "hw")) drivertype = D3D_DRIVER_TYPE_HARDWARE; else if (!stricmp(info->subrenderer, "null")) drivertype = D3D_DRIVER_TYPE_NULL; else if (!stricmp(info->subrenderer, "software")) drivertype = D3D_DRIVER_TYPE_SOFTWARE; else if (!stricmp(info->subrenderer, "unknown")) drivertype = D3D_DRIVER_TYPE_UNKNOWN; else drivertype = adapt?D3D_DRIVER_TYPE_UNKNOWN:D3D_DRIVER_TYPE_HARDWARE; //for stereo support, we would have to rewrite all of this in a way that would make us dependant upon windows 8 or 7+platform update, which would exclude vista. scd.BufferDesc.Width = info->width; scd.BufferDesc.Height = info->height; scd.BufferDesc.RefreshRate.Numerator = 0; scd.BufferDesc.RefreshRate.Denominator = 0; scd.BufferCount = 1+info->triplebuffer; //back buffer count if (info->srgb) { if (info->srgb >= 2) //fixme: detect properly. scd.BufferDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; //on nvidia, outputs linear rgb to srgb devices, which means info->srgb is effectively set else scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; } else if (info->bpp == 30) //fixme: detect properly. scd.BufferDesc.Format = DXGI_FORMAT_R10G10B10A2_UNORM; else scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; scd.OutputWindow = hWnd; scd.SampleDesc.Count = d3d11multisample_count = max(1, info->multisample); //as we're starting up windowed (and switching to fullscreen after), the frontbuffer is handled by windows. scd.SampleDesc.Quality = d3d11multisample_quality = 0; scd.Windowed = TRUE; scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;// | DXGI_SWAP_CHAIN_FLAG_NONPREROTATED; #ifdef _DEBUG // flags |= D3D11_CREATE_DEVICE_DEBUG; #endif if (drivertype == D3D_DRIVER_TYPE_UNKNOWN && adapt) { DXGI_ADAPTER_DESC adesc; IDXGIAdapter_GetDesc(adapt, &adesc); Con_Printf("D3D11 Adaptor: %S\n", adesc.Description); } else adapt = NULL; if (FAILED(func(adapt, drivertype, NULL, flags, flevels, sizeof(flevels)/sizeof(flevels[0]), D3D11_SDK_VERSION, &scd, &d3dswapchain, &pD3DDev11, &flevel, &d3ddevctx))) return false; if (!pD3DDev11) return false; Con_Printf("D3D11 Feature level: %i_%i\n", flevel>>12, (flevel>>8) & 0xf); if (!resetd3dbackbuffer(info->width, info->height)) return false; if (info->fullscreen) { } memset(&sh_config, 0, sizeof(sh_config)); sh_config.texture_non_power_of_two = flevel>=D3D_FEATURE_LEVEL_10_0; //npot MUST be supported on all d3d10+ cards. sh_config.texture_non_power_of_two_pic = true; //always supported in d3d11, supposedly, even with d3d9 devices. sh_config.texture_allow_block_padding = false; //microsoft blocks this. sh_config.npot_rounddown = false; if (flevel>=D3D_FEATURE_LEVEL_11_0) sh_config.texture2d_maxsize = 16384; else if (flevel>=D3D_FEATURE_LEVEL_10_0) sh_config.texture2d_maxsize = 8192; else if (flevel>=D3D_FEATURE_LEVEL_9_3) sh_config.texture2d_maxsize = 4096; else sh_config.texture2d_maxsize = 2048; if (flevel>=D3D_FEATURE_LEVEL_9_3) sh_config.texture2d_maxsize = 4096; else sh_config.texture2d_maxsize = 512; //11.1 formats #define DXGI_FORMAT_B4G4R4A4_UNORM 115 //why does d3d11 have no rgbx format? anyone else think that weird? if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B5G6R5_UNORM, &support))) //crippled to win8+ only. sh_config.texfmt[PTI_RGB565] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B5G5R5A1_UNORM, &support))) //crippled to win8+ only. sh_config.texfmt[PTI_ARGB1555] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B4G4R4A4_UNORM, &support))) //crippled to win8+ only. sh_config.texfmt[PTI_ARGB4444] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_R8G8B8A8_UNORM, &support))) sh_config.texfmt[PTI_RGBA8] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, &support))) sh_config.texfmt[PTI_RGBA8_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_R10G10B10A2_UNORM, &support))) sh_config.texfmt[PTI_A2BGR10] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D) && !!(support & D3D11_FORMAT_SUPPORT_RENDER_TARGET); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, &support))) sh_config.texfmt[PTI_E5BGR9] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_R16G16B16A16_FLOAT, &support))) sh_config.texfmt[PTI_RGBA16F] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D) && !!(support & D3D11_FORMAT_SUPPORT_RENDER_TARGET); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_R32G32B32A32_FLOAT, &support))) sh_config.texfmt[PTI_RGBA32F] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D) && !!(support & D3D11_FORMAT_SUPPORT_RENDER_TARGET); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B8G8R8A8_UNORM, &support))) sh_config.texfmt[PTI_BGRA8] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB, &support))) sh_config.texfmt[PTI_BGRA8_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B8G8R8X8_UNORM, &support))) sh_config.texfmt[PTI_BGRX8] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB, &support))) sh_config.texfmt[PTI_BGRX8_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); //compressed formats if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC1_UNORM, &support))) sh_config.texfmt[PTI_BC1_RGBA] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC1_UNORM_SRGB, &support))) sh_config.texfmt[PTI_BC1_RGBA_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC2_UNORM, &support))) sh_config.texfmt[PTI_BC2_RGBA] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC2_UNORM_SRGB, &support))) sh_config.texfmt[PTI_BC2_RGBA_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC3_UNORM, &support))) sh_config.texfmt[PTI_BC3_RGBA] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC3_UNORM_SRGB, &support))) sh_config.texfmt[PTI_BC3_RGBA_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC4_UNORM, &support))) sh_config.texfmt[PTI_BC4_R8] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC4_SNORM, &support))) sh_config.texfmt[PTI_BC4_R8_SNORM] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC5_UNORM, &support))) sh_config.texfmt[PTI_BC5_RG8] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC5_SNORM, &support))) sh_config.texfmt[PTI_BC5_RG8_SNORM] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC6H_UF16, &support))) sh_config.texfmt[PTI_BC6_RGB_UFLOAT] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC6H_SF16, &support))) sh_config.texfmt[PTI_BC6_RGB_SFLOAT] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC7_UNORM, &support))) sh_config.texfmt[PTI_BC7_RGBA] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); if (SUCCEEDED(ID3D11Device_CheckFormatSupport(pD3DDev11, DXGI_FORMAT_BC7_UNORM_SRGB, &support))) sh_config.texfmt[PTI_BC7_RGBA_SRGB] = !!(support & D3D11_FORMAT_SUPPORT_TEXTURE2D); //these formats are not officially supported as specified, but noone cares sh_config.texfmt[PTI_RGBX8] = sh_config.texfmt[PTI_RGBA8]; sh_config.texfmt[PTI_RGBX8_SRGB] = sh_config.texfmt[PTI_RGBA8_SRGB]; sh_config.texfmt[PTI_BC1_RGB] = sh_config.texfmt[PTI_BC1_RGBA]; sh_config.texfmt[PTI_BC1_RGB_SRGB] = sh_config.texfmt[PTI_BC1_RGBA_SRGB]; switch(scd.BufferDesc.Format) { case DXGI_FORMAT_R16G16B16A16_FLOAT: vid.flags |= VID_SRGB_FB_LINEAR|VID_FP16; //these are apparently linear already. break; case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: vid.flags |= VID_SRGB_FB_LINEAR; //effectively linear. break; default: //non-linear formats. break; } if ((vid.flags & VID_SRGB_FB) && info->srgb >= 0) vid.flags |= VID_SRGBAWARE; vid.numpages = scd.BufferCount; if (!D3D11Shader_Init(flevel)) { Con_Printf("Unable to intialise a suitable HLSL compiler, please install the DirectX runtime.\n"); return false; } return true; } static void initD3D11(HWND hWnd, rendererstate_t *info) { static dllhandle_t *dxgi; static PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN fnc; static HRESULT (WINAPI *pCreateDXGIFactory1)(IID *riid, void **ppFactory); static IID factiid = {0x770aae78, 0xf26f, 0x4dba, {0xa8, 0x29, 0x25, 0x3c, 0x83, 0xd1, 0xb3, 0x87}}; IDXGIFactory1 *fact = NULL; IDXGIAdapter *adapt = NULL; dllfunction_t d3d11funcs[] = { {(void**)&fnc, "D3D11CreateDeviceAndSwapChain"}, {NULL} }; dllfunction_t dxgifuncs[] = { {(void**)&pCreateDXGIFactory1, "CreateDXGIFactory1"}, {NULL} }; if (!dxgi) dxgi = Sys_LoadLibrary("dxgi", dxgifuncs); if (!d3d11mod) d3d11mod = Sys_LoadLibrary("d3d11", d3d11funcs); if (!d3d11mod) return; if (pCreateDXGIFactory1) { HRESULT hr; hr = pCreateDXGIFactory1(&factiid, (void**)&fact); if (FAILED(hr)) Con_Printf("CreateDXGIFactory1 failed: %s\n", D3D_NameForResult(hr)); if (fact) { IDXGIFactory1_EnumAdapters(fact, 0, &adapt); } } initD3D11Device(hWnd, info, fnc, adapt); if (adapt) IDXGIAdapter_Release(adapt); if (fact) { //DXGI SUCKS and fucks up alt+tab every single time. its pointless to go from fullscreen to fullscreen-with-taskbar-obscuring-half-the-window. //I'm just going to handle that stuff myself. //IDXGIFactory1_MakeWindowAssociation(fact, hWnd, DXGI_MWA_NO_WINDOW_CHANGES|DXGI_MWA_NO_ALT_ENTER|DXGI_MWA_NO_PRINT_SCREEN); IDXGIFactory1_Release(fact); } } static qboolean D3D11_VID_Init(rendererstate_t *info, unsigned char *palette) { DWORD width = info->width; DWORD height = info->height; //DWORD bpp = info->bpp; //DWORD zbpp = 16; //DWORD flags = 0; DWORD wstyle; RECT rect; MSG msg; HICON hIcon = LoadIcon (global_hInstance, MAKEINTRESOURCE (IDI_ICON1)); //DDGAMMARAMP gammaramp; //int i; char *CLASSNAME = "FTED3D11QUAKE"; WNDCLASS wc = { 0, &D3D11_WindowProc, 0, 0, NULL, hIcon, NULL, NULL, NULL, CLASSNAME }; wc.style = CS_HREDRAW | CS_VREDRAW; wc.hCursor = hArrowCursor = LoadCursor (NULL,IDC_ARROW); wc.hInstance = global_hInstance; vid_initializing = true; RegisterClass(&wc); if (info->fullscreen == 2) modestate = MS_FULLWINDOW; else if (info->fullscreen) modestate = MS_FULLSCREEN; //FIXME: I'm done with fighting dxgi. I'm just going to pick the easy method that doesn't end up with totally fucked up behaviour. else modestate = MS_WINDOWED; if (modestate == MS_FULLWINDOW) { wstyle = WS_POPUP; rect.right = GetSystemMetrics(SM_CXSCREEN); rect.bottom = GetSystemMetrics(SM_CYSCREEN); rect.left = 0; rect.top = 0; } else { wstyle = WS_OVERLAPPEDWINDOW; rect.left = (GetSystemMetrics(SM_CXSCREEN) - width) / 2; rect.top = (GetSystemMetrics(SM_CYSCREEN) - height) / 2; rect.right = rect.left+width; rect.bottom = rect.top+height; AdjustWindowRectEx(&rect, wstyle, FALSE, 0); } mainwindow = CreateWindow(CLASSNAME, "Direct3D11", wstyle, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, NULL, NULL, NULL, NULL); // Try as specified. DoDXGIDebug(); initD3D11(mainwindow, info); if (!pD3DDev11) { DoDXGIDebug(); Con_Printf("No suitable D3D11 device found\n"); return false; } vid.pixelwidth = width; vid.pixelheight = height; while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } CL_UpdateWindowTitle(); if (modestate == MS_FULLWINDOW) ShowWindow(mainwindow, SW_SHOWMAXIMIZED); else ShowWindow(mainwindow, SW_SHOWNORMAL); vid.width = vid.pixelwidth; vid.height = vid.pixelheight; if (modestate == MS_FULLSCREEN) { if (!d3dscreen) IDXGISwapChain_GetContainingOutput(d3dswapchain, &d3dscreen); IDXGISwapChain_SetFullscreenState(d3dswapchain, true, d3dscreen); } vid_initializing = false; GetWindowRect(mainwindow, &window_rect); { extern qboolean mouseactive; mouseactive = false; } rf->VID_CreateCursor = WIN_CreateCursor; rf->VID_DestroyCursor = WIN_DestroyCursor; rf->VID_SetCursor = WIN_SetCursor; return true; } #endif static void (D3D11_VID_DeInit) (void) { Image_Shutdown(); /*we cannot shut down cleanly while in fullscreen, supposedly*/ if(d3dswapchain) IDXGISwapChain_SetFullscreenState(d3dswapchain, false, NULL); released3dbackbuffer(); if(d3dswapchain) IDXGISwapChain_Release(d3dswapchain); d3dswapchain = NULL; if (pD3DDev11) ID3D11Device_Release(pD3DDev11); pD3DDev11 = NULL; if (d3ddevctx) { ID3D11DeviceContext_ClearState(d3ddevctx); ID3D11DeviceContext_Flush(d3ddevctx); ID3D11DeviceContext_Release(d3ddevctx); } d3ddevctx = NULL; #ifndef WINRT if (mainwindow) { DestroyWindow(mainwindow); mainwindow = NULL; } #endif if (d3dscreen) IUnknown_Release(d3dscreen); d3dscreen = NULL; DoDXGIDebug(); } extern float hw_blend[4]; // rgba 0.0 - 1.0 static void D3D11_BuildRamps(int points, DXGI_RGB *out) { //FIXME: repack input rather than recalculating. int i; vec3_t cshift; vec3_t c; float sc; VectorScale(hw_blend, hw_blend[3], cshift); for (i = 0; i < points; i++) { sc = i / (float)(points-1); VectorSet(c, sc, sc, sc); VectorAdd(c, cshift, c); VectorScale(c, v_contrast.value, c); out[i].Red = pow (c[0], v_gamma.value) + v_brightness.value; out[i].Green = pow (c[1], v_gamma.value) + v_brightness.value; out[i].Blue = pow (c[2], v_gamma.value) + v_brightness.value; } } static qboolean D3D11_VID_ApplyGammaRamps(unsigned int gammarampsize, unsigned short *ramps) { HRESULT hr; DXGI_GAMMA_CONTROL_CAPABILITIES caps; DXGI_GAMMA_CONTROL gam; //cache the screen, so we don't get too confused. if (!d3dscreen) return false; //don't do it when we're running windowed. if (d3dscreen) { gam.Scale.Red = 1; gam.Scale.Green = 1; gam.Scale.Blue = 1; gam.Offset.Red = 0; gam.Offset.Green = 0; gam.Offset.Blue = 0; if (FAILED(IDXGIOutput_GetGammaControlCapabilities(d3dscreen, &caps))) return false; if (caps.NumGammaControlPoints > 1025) caps.NumGammaControlPoints = 1025; D3D11_BuildRamps(caps.NumGammaControlPoints, gam.GammaCurve); hr = IDXGIOutput_SetGammaControl(d3dscreen, &gam); if (SUCCEEDED(hr)) return true; } return false; } static char *D3D11_VID_GetRGBInfo(int *bytestride, int *truevidwidth, int *truevidheight, enum uploadfmt *fmt) { //don't directly map the frontbuffer, as that can hold other things. //create a texture, copy the (gpu)backbuffer to that (cpu)texture //then map the (cpu)texture and copy out the parts we need, reordering as needed. D3D11_MAPPED_SUBRESOURCE lock; qbyte *rgb, *in, *r = NULL; unsigned int x,y; D3D11_TEXTURE2D_DESC texDesc; ID3D11Texture2D *texture; ID3D11Resource *backbuffer; texDesc.ArraySize = 1; texDesc.BindFlags = 0; texDesc.CPUAccessFlags = 0; texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; texDesc.Width = vid.pixelwidth; texDesc.Height = vid.pixelheight; texDesc.MipLevels = 1; texDesc.MiscFlags = 0; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Usage = D3D11_USAGE_STAGING; texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; if (FAILED(ID3D11Device_CreateTexture2D(pD3DDev11, &texDesc, 0, &texture))) return NULL; ID3D11RenderTargetView_GetResource(fb_backbuffer, &backbuffer); ID3D11DeviceContext_CopyResource(d3ddevctx, (ID3D11Resource*)texture, backbuffer); ID3D11Resource_Release(backbuffer); if (!FAILED(ID3D11DeviceContext_Map(d3ddevctx, (ID3D11Resource*)texture, 0, D3D11_MAP_READ, 0, &lock))) { r = rgb = BZ_Malloc(3 * vid.pixelwidth * vid.pixelheight); for (y = vid.pixelheight; y-- > 0; ) { in = lock.pData; in += y * lock.RowPitch; for (x = 0; x < vid.pixelwidth; x++, rgb+=3, in+=4) { rgb[0] = in[0]; rgb[1] = in[1]; rgb[2] = in[2]; } } ID3D11DeviceContext_Unmap(d3ddevctx, (ID3D11Resource*)texture, 0); } ID3D11Texture2D_Release(texture); *bytestride = vid.pixelwidth*3; *truevidwidth = vid.pixelwidth; *truevidheight = vid.pixelheight; *fmt = TF_RGB24; return r; } static void (D3D11_VID_SetWindowCaption) (const char *msg) { #ifndef WINRT SetWindowText(mainwindow, msg); #endif } void D3D11_Set2D (void) { // Matrix4x4_CM_Orthographic(r_refdef.m_projection, 0 + (0.5*vid.width/vid.pixelwidth), vid.width + (0.5*vid.width/vid.pixelwidth), 0 + (0.5*vid.height/vid.pixelheight), vid.height + (0.5*vid.height/vid.pixelheight), 0, 100); Matrix4x4_CM_Orthographic(r_refdef.m_projection_std, 0, vid.width, vid.height, 0, 0, 99999); Matrix4x4_Identity(r_refdef.m_view); vid.fbvwidth = vid.width; vid.fbvheight = vid.height; vid.fbpwidth = vid.pixelwidth; vid.fbpheight = vid.pixelheight; r_refdef.pxrect.x = 0; r_refdef.pxrect.y = 0; r_refdef.pxrect.width = vid.fbpwidth; r_refdef.pxrect.height = vid.fbpheight; D3D11BE_Set2D(); } static qboolean (D3D11_SCR_UpdateScreen) (void) { //extern int keydown[]; //extern cvar_t vid_conheight; #ifdef TEXTEDITOR //extern qboolean editormodal; #endif qboolean nohud, noworld; if (r_clear.ival) { float colours[4] = {(r_clear.ival&1)?1:0, (r_clear.ival&2)?1:0, (r_clear.ival&4)?1:0, 1}; ID3D11DeviceContext_ClearRenderTargetView(d3ddevctx, fb_backbuffer, colours); } if (d3d_resized) { extern cvar_t vid_conautoscale, vid_conwidth; d3d_resized = false; // force width/height to be updated //vid.pixelwidth = window_rect.right - window_rect.left; //vid.pixelheight = window_rect.bottom - window_rect.top; Cvar_ForceCallback(&vid_conautoscale); Cvar_ForceCallback(&vid_conwidth); } R2D_Font_Changed(); if (scr_disabled_for_loading) { extern float scr_disabled_time; if (Sys_DoubleTime() - scr_disabled_time > 60 || Key_Dest_Has(~kdm_game)) { scr_disabled_for_loading = false; } else { // IDirect3DDevice9_BeginScene(pD3DDev9); scr_drawloading = true; SCR_DrawLoading (true); scr_drawloading = false; if (R2D_Flush) R2D_Flush(); // IDirect3DDevice9_EndScene(pD3DDev9); D3D11_PresentOrCrash(); return true; } } if (!scr_initialized || !con_initialized) { return false; // not initialized yet } Shader_DoReload(); // d3d11error(IDirect3DDevice9_BeginScene(pD3DDev9)); /* #ifdef TEXTEDITOR if (editormodal) { Editor_Draw(); V_UpdatePalette (false); Media_RecordFrame(); R2D_BrightenScreen(); if (key_dest == key_console) Con_DrawConsole(vid_conheight.value/2, false); GL_EndRendering (); GL_DoSwap(); RSpeedEnd(RSPEED_TOTALREFRESH); return; } #endif */ // // do 3D refresh drawing, and then update the screen // SCR_SetUpToDrawConsole (); noworld = false; nohud = false; if (topmenu && topmenu->isopaque) nohud = true; #ifdef VM_CG else if (CG_Refresh()) nohud = true; #endif #ifdef CSQC_DAT else if (CSQC_DrawView()) nohud = true; #endif else if (r_worldentity.model && cls.state == ca_active) V_RenderView (nohud); else noworld = true; D3D11_Set2D(); if (!noworld) { R2D_BrightenScreen(); } scr_con_forcedraw = false; if (noworld) { if ((!Key_Dest_Has(~(kdm_game|kdm_console))) && SCR_GetLoadingStage() == LS_NONE) scr_con_current = vid.height; if (scr_con_current != vid.height) R2D_ConsoleBackground(0, vid.height, true); else scr_con_forcedraw = true; nohud = true; } SCR_DrawTwoDimensional(nohud); V_UpdatePalette (false); Media_RecordFrame(); RSpeedShow(); D3D11_PresentOrCrash(); window_center_x = (window_rect.left + window_rect.right)/2; window_center_y = (window_rect.top + window_rect.bottom)/2; INS_UpdateGrabs(modestate != MS_WINDOWED, vid.activeapp); return true; } static void D3D11_Draw_Init (void) { R2D_Init(); } static void D3D11_Draw_Shutdown (void) { R2D_Shutdown(); } static void D3D11_R_Init (void) { } static void D3D11_R_DeInit (void) { R_GAliasFlushSkinCache(true); Surf_DeInit(); D3D11BE_Shutdown(); Shader_Shutdown(); } static void D3D11_SetupViewPort(void) { int x, x2, y2, y; float fov_x, fov_y; float fovv_x, fovv_y; AngleVectors (r_refdef.viewangles, vpn, vright, vup); VectorCopy (r_refdef.vieworg, r_origin); // // set up viewpoint // x = r_refdef.vrect.x * vid.pixelwidth/(int)vid.width; x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * vid.pixelwidth/(int)vid.width; y = (r_refdef.vrect.y) * vid.pixelheight/(int)vid.height; y2 = ((int)(r_refdef.vrect.y + r_refdef.vrect.height)) * vid.pixelheight/(int)vid.height; // fudge around because of frac screen scale if (x > 0) x--; if (x2 < vid.pixelwidth) x2++; if (y < 0) y--; if (y2 < vid.pixelheight) y2++; fov_x = r_refdef.fov_x;//+sin(cl.time)*5; fov_y = r_refdef.fov_y;//-sin(cl.time+1)*5; fovv_x = r_refdef.fovv_x; fovv_y = r_refdef.fovv_y; if ((r_refdef.flags & RDF_UNDERWATER) && !(r_refdef.flags & RDF_WATERWARP)) { fov_x *= 1 + (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value); fov_y *= 1 + (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value); fovv_x *= 1 + (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value); fovv_y *= 1 + (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value); } /*view matrix*/ Matrix4x4_CM_ModelViewMatrixFromAxis(r_refdef.m_view, vpn, vright, vup, r_refdef.vieworg); if (r_refdef.maxdist) { Matrix4x4_CM_Projection_Far(r_refdef.m_projection_std, fov_x, fov_y, r_refdef.mindist, r_refdef.maxdist, false); Matrix4x4_CM_Projection_Far(r_refdef.m_projection_view, fovv_x, fovv_y, r_refdef.mindist, r_refdef.maxdist, false); } else { Matrix4x4_CM_Projection_Inf(r_refdef.m_projection_std, fov_x, fov_y, r_refdef.mindist, false); Matrix4x4_CM_Projection_Inf(r_refdef.m_projection_view, fovv_x, fovv_y, r_refdef.mindist, false); } } static void (D3D11_R_RenderView) (void) { float x, x2, y, y2; double time1 = 0, time2 = 0; qboolean dofbo = *r_refdef.rt_destcolour[0].texname || *r_refdef.rt_depth.texname; // texid_t colourrt[1]; if (!r_norefresh.value) { if (r_speeds.ival) time1 = Sys_DoubleTime(); if (dofbo) D3D11_ApplyRenderTargets(true); else ID3D11DeviceContext_ClearDepthStencilView(d3ddevctx, fb_backdepthstencil, D3D11_CLEAR_DEPTH, 1, 0); //is it faster to clear the stencil too? //check if we can do underwater warp if (cls.protocol != CP_QUAKE2) //quake2 tells us directly { if (r_viewcontents & FTECONTENTS_FLUID) r_refdef.flags |= RDF_UNDERWATER; else r_refdef.flags &= ~RDF_UNDERWATER; } if (r_refdef.flags & RDF_UNDERWATER) { extern cvar_t r_projection; if (!r_waterwarp.value || r_projection.ival) r_refdef.flags &= ~RDF_UNDERWATER; //no warp at all // else if (r_waterwarp.value > 0 && scenepp_waterwarp) // r_refdef.flags |= RDF_WATERWARP; //try fullscreen warp instead if we can } D3D11_SetupViewPort(); //unlike gl, we clear colour beforehand, because that seems more sane. //always clear depth x = (r_refdef.vrect.x * (int)vid.pixelwidth)/(int)vid.width; x2 = (r_refdef.vrect.x + r_refdef.vrect.width) * (int)vid.pixelwidth/(int)vid.width; y = (r_refdef.vrect.y * (int)vid.pixelheight)/(int)vid.height; y2 = (r_refdef.vrect.y + r_refdef.vrect.height) * (int)vid.pixelheight/(int)vid.height; r_refdef.pxrect.x = floor(x); r_refdef.pxrect.y = floor(y); r_refdef.pxrect.width = (int)ceil(x2) - r_refdef.pxrect.x; r_refdef.pxrect.height = (int)ceil(y2) - r_refdef.pxrect.y; Surf_SetupFrame(); //fixme: waterwarp fov R_SetFrustum (r_refdef.m_projection_std, r_refdef.m_view); RQ_BeginFrame(); // if (!(r_refdef.flags & Q2RDF_NOWORLDMODEL)) // { // if (cl.worldmodel) // P_DrawParticles (); // } if (!(r_refdef.flags & RDF_NOWORLDMODEL)) if (!r_worldentity.model || r_worldentity.model->loadstate != MLS_LOADED || !cl.worldmodel) { D3D11_Set2D (); R2D_ImageColours(0, 0, 0, 1); R2D_FillBlock(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height); R2D_ImageColours(1, 1, 1, 1); if (dofbo) D3D11_ApplyRenderTargets(false); return; } Surf_DrawWorld(); RQ_RenderBatchClear(); if (r_speeds.ival) { time2 = Sys_DoubleTime(); RQuantAdd(RQUANT_MSECS, (int)((time2-time1)*1000000)); } if (dofbo) D3D11_ApplyRenderTargets(false); } D3D11_Set2D (); } void D3D11BE_RenderToTextureUpdate2d(qboolean destchanged) { if (destchanged) { if (*r_refdef.rt_destcolour[0].texname) D3D11_ApplyRenderTargets(false); else ID3D11DeviceContext_OMSetRenderTargets(d3ddevctx, 1, &fb_backbuffer, fb_backdepthstencil); D3D11_Set2D(); } else { // shaderstate.tex_sourcecol = R2D_RT_GetTexture(r_refdef.rt_sourcecolour.texname, &width, &height); // shaderstate.tex_sourcedepth = R2D_RT_GetTexture(r_refdef.rt_depth.texname, &width, &height); } } rendererinfo_t d3d11rendererinfo = { "Direct3D11", { "D3D11", "Direct3d11", "DirectX11", "DX11" }, QR_DIRECT3D11, D3D11_Draw_Init, D3D11_Draw_Shutdown, D3D11_UpdateFiltering, D3D11_LoadTextureMips, D3D11_DestroyTexture, /* D3D11_LoadTexture, D3D11_LoadTexture8Pal24, D3D11_LoadTexture8Pal32, D3D11_LoadCompressed, D3D11_FindTexture, D3D11_AllocNewTexture, D3D11_Upload, D3D11_DestroyTexture, */ D3D11_R_Init, D3D11_R_DeInit, D3D11_R_RenderView, D3D11_VID_Init, D3D11_VID_DeInit, D3D11_PresentOrCrash, D3D11_VID_ApplyGammaRamps, NULL, NULL, NULL, D3D11_VID_SetWindowCaption, D3D11_VID_GetRGBInfo, D3D11_SCR_UpdateScreen, D3D11BE_SelectMode, D3D11BE_DrawMesh_List, D3D11BE_DrawMesh_Single, D3D11BE_SubmitBatch, D3D11BE_GetTempBatch, D3D11BE_DrawWorld, D3D11BE_Init, D3D11BE_GenBrushModelVBO, D3D11BE_ClearVBO, D3D11BE_UploadAllLightmaps, D3D11BE_SelectEntity, D3D11BE_SelectDLight, D3D11BE_Scissor, D3D11BE_LightCullModel, D3D11BE_VBO_Begin, D3D11BE_VBO_Data, D3D11BE_VBO_Finish, D3D11BE_VBO_Destroy, D3D11BE_RenderToTextureUpdate2d, "no more" }; #endif