/****************************************************************************** Copyright (C) 2013 by Hugh Bailey This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . ******************************************************************************/ #include "util/base.h" #include "util/platform.h" #include "graphics/matrix3.h" #include "d3d11-subsystem.hpp" static const IID dxgiFactory2 = {0x50c83a1c, 0xe072, 0x4c48, {0x87, 0xb0, 0x36, 0x30, 0xfa, 0x36, 0xa6, 0xd0}}; static inline void make_swap_desc(DXGI_SWAP_CHAIN_DESC &desc, gs_init_data *data) { memset(&desc, 0, sizeof(desc)); desc.BufferCount = data->num_backbuffers; desc.BufferDesc.Format = ConvertGSTextureFormat(data->format); desc.BufferDesc.Width = data->cx; desc.BufferDesc.Height = data->cy; desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; desc.OutputWindow = (HWND)data->window.hwnd; desc.SampleDesc.Count = 1; desc.Windowed = true; } void gs_swap_chain::InitTarget(uint32_t cx, uint32_t cy) { HRESULT hr; target.width = cx; target.height = cy; hr = swap->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)target.texture.Assign()); if (FAILED(hr)) throw HRError("Failed to get swap buffer texture", hr); hr = device->device->CreateRenderTargetView(target.texture, NULL, target.renderTarget[0].Assign()); if (FAILED(hr)) throw HRError("Failed to create swap render target view", hr); } void gs_swap_chain::InitZStencilBuffer(uint32_t cx, uint32_t cy) { zs.width = cx; zs.height = cy; if (zs.format != GS_ZS_NONE && cx != 0 && cy != 0) { zs.InitBuffer(); } else { zs.texture.Clear(); zs.view.Clear(); } } void gs_swap_chain::Resize(uint32_t cx, uint32_t cy) { RECT clientRect; HRESULT hr; target.texture.Clear(); target.renderTarget[0].Clear(); zs.texture.Clear(); zs.view.Clear(); if (cx == 0 || cy == 0) { GetClientRect(hwnd, &clientRect); if (cx == 0) cx = clientRect.right; if (cy == 0) cy = clientRect.bottom; } hr = swap->ResizeBuffers(numBuffers, cx, cy, target.dxgiFormat, 0); if (FAILED(hr)) throw HRError("Failed to resize swap buffers", hr); InitTarget(cx, cy); InitZStencilBuffer(cx, cy); } void gs_swap_chain::Init(gs_init_data *data) { target.device = device; target.isRenderTarget = true; target.format = data->format; target.dxgiFormat = ConvertGSTextureFormat(data->format); InitTarget(data->cx, data->cy); zs.device = device; zs.format = data->zsformat; zs.dxgiFormat = ConvertGSZStencilFormat(data->zsformat); InitZStencilBuffer(data->cx, data->cy); } gs_swap_chain::gs_swap_chain(gs_device *device, gs_init_data *data) : device (device), numBuffers (data->num_backbuffers), hwnd ((HWND)data->window.hwnd) { HRESULT hr; DXGI_SWAP_CHAIN_DESC swapDesc; make_swap_desc(swapDesc, data); hr = device->factory->CreateSwapChain(device->device, &swapDesc, swap.Assign()); if (FAILED(hr)) throw HRError("Failed to create swap chain", hr); Init(data); } void gs_device::InitFactory(uint32_t adapterIdx, IDXGIAdapter1 **padapter) { HRESULT hr; IID factoryIID = (GetWinVer() >= 0x602) ? dxgiFactory2 : __uuidof(IDXGIFactory1); hr = CreateDXGIFactory1(factoryIID, (void**)factory.Assign()); if (FAILED(hr)) throw HRError("Failed to create DXGIFactory", hr); hr = factory->EnumAdapters1(adapterIdx, padapter); if (FAILED(hr)) throw HRError("Failed to enumerate DXGIAdapter", hr); } const static D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3, }; void gs_device::InitDevice(gs_init_data *data, IDXGIAdapter *adapter) { wstring adapterName; DXGI_SWAP_CHAIN_DESC swapDesc; DXGI_ADAPTER_DESC desc; D3D_FEATURE_LEVEL levelUsed; HRESULT hr; make_swap_desc(swapDesc, data); uint32_t createFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT; #ifdef _DEBUG //createFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif adapterName = (adapter->GetDesc(&desc) == S_OK) ? desc.Description : L""; char *adapterNameUTF8; os_wcs_to_utf8(adapterName.c_str(), 0, &adapterNameUTF8); blog(LOG_INFO, "Loading up D3D11 on adapter %s", adapterNameUTF8); bfree(adapterNameUTF8); hr = D3D11CreateDeviceAndSwapChain(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, createFlags, featureLevels, sizeof(featureLevels) / sizeof(D3D_FEATURE_LEVEL), D3D11_SDK_VERSION, &swapDesc, defaultSwap.swap.Assign(), device.Assign(), &levelUsed, context.Assign()); if (FAILED(hr)) throw HRError("Failed to create device and swap chain", hr); blog(LOG_INFO, "D3D11 loaded sucessfully, feature level used: %u", (uint32_t)levelUsed); defaultSwap.device = this; defaultSwap.hwnd = (HWND)data->window.hwnd; defaultSwap.numBuffers = data->num_backbuffers; defaultSwap.Init(data); } static inline void ConvertStencilSide(D3D11_DEPTH_STENCILOP_DESC &desc, const StencilSide &side) { desc.StencilFunc = ConvertGSDepthTest(side.test); desc.StencilFailOp = ConvertGSStencilOp(side.fail); desc.StencilDepthFailOp = ConvertGSStencilOp(side.zfail); desc.StencilPassOp = ConvertGSStencilOp(side.zpass); } ID3D11DepthStencilState *gs_device::AddZStencilState() { HRESULT hr; D3D11_DEPTH_STENCIL_DESC dsd; SavedZStencilState savedState(zstencilState); ID3D11DepthStencilState *state; dsd.DepthEnable = zstencilState.depthEnabled; dsd.DepthFunc = ConvertGSDepthTest(zstencilState.depthFunc); dsd.DepthWriteMask = zstencilState.depthWriteEnabled ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; dsd.StencilEnable = zstencilState.stencilEnabled; dsd.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; dsd.StencilWriteMask = zstencilState.stencilWriteEnabled ? D3D11_DEFAULT_STENCIL_WRITE_MASK : 0; ConvertStencilSide(dsd.FrontFace, zstencilState.stencilFront); ConvertStencilSide(dsd.BackFace, zstencilState.stencilBack); hr = device->CreateDepthStencilState(&dsd, savedState.state.Assign()); if (FAILED(hr)) throw HRError("Failed to create depth stencil state", hr); state = savedState.state; zstencilStates.push_back(savedState); return state; } ID3D11RasterizerState *gs_device::AddRasterState() { HRESULT hr; D3D11_RASTERIZER_DESC rd; SavedRasterState savedState(rasterState); ID3D11RasterizerState *state; memset(&rd, 0, sizeof(rd)); /* use CCW to convert to a right-handed coordinate system */ rd.FrontCounterClockwise = true; rd.FillMode = D3D11_FILL_SOLID; rd.CullMode = ConvertGSCullMode(rasterState.cullMode); rd.DepthClipEnable = true; rd.ScissorEnable = rasterState.scissorEnabled; hr = device->CreateRasterizerState(&rd, savedState.state.Assign()); if (FAILED(hr)) throw HRError("Failed to create rasterizer state", hr); state = savedState.state; rasterStates.push_back(savedState); return state; } ID3D11BlendState *gs_device::AddBlendState() { HRESULT hr; D3D11_BLEND_DESC bd; SavedBlendState savedState(blendState); ID3D11BlendState *state; memset(&bd, 0, sizeof(bd)); for (int i = 0; i < 8; i++) { bd.RenderTarget[i].BlendEnable = blendState.blendEnabled; bd.RenderTarget[i].BlendOp = D3D11_BLEND_OP_ADD; bd.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP_ADD; bd.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND_ONE; bd.RenderTarget[i].DestBlendAlpha = D3D11_BLEND_ZERO; bd.RenderTarget[i].SrcBlend = ConvertGSBlendType(blendState.srcFactor); bd.RenderTarget[i].DestBlend = ConvertGSBlendType(blendState.destFactor); bd.RenderTarget[i].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; } hr = device->CreateBlendState(&bd, savedState.state.Assign()); if (FAILED(hr)) throw HRError("Failed to create disabled blend state", hr); state = savedState.state; blendStates.push_back(savedState); return state; } void gs_device::UpdateZStencilState() { ID3D11DepthStencilState *state = NULL; if (!zstencilStateChanged) return; for (size_t i = 0; i < zstencilStates.size(); i++) { SavedZStencilState &s = zstencilStates[i]; if (memcmp(&s, &zstencilState, sizeof(zstencilState)) == 0) { state = s.state; break; } } if (!state) state = AddZStencilState(); if (state != curDepthStencilState) { context->OMSetDepthStencilState(state, 0); curDepthStencilState = state; } zstencilStateChanged = false; } void gs_device::UpdateRasterState() { ID3D11RasterizerState *state = NULL; if (!rasterStateChanged) return; for (size_t i = 0; i < rasterStates.size(); i++) { SavedRasterState &s = rasterStates[i]; if (memcmp(&s, &rasterState, sizeof(rasterState)) == 0) { state = s.state; break; } } if (!state) state = AddRasterState(); if (state != curRasterState) { context->RSSetState(state); curRasterState = state; } rasterStateChanged = false; } void gs_device::UpdateBlendState() { ID3D11BlendState *state = NULL; if (!blendStateChanged) return; for (size_t i = 0; i < blendStates.size(); i++) { SavedBlendState &s = blendStates[i]; if (memcmp(&s, &blendState, sizeof(blendState)) == 0) { state = s.state; break; } } if (!state) state = AddBlendState(); if (state != curBlendState) { float f[4] = {1.0f, 1.0f, 1.0f, 1.0f}; context->OMSetBlendState(state, f, 0xFFFFFFFF); curBlendState = state; } blendStateChanged = false; } void gs_device::UpdateViewProjMatrix() { matrix3 cur_matrix; gs_matrix_get(&cur_matrix); matrix4_from_matrix3(&curViewMatrix, &cur_matrix); /* negate Z col of the view matrix for right-handed coordinate system */ curViewMatrix.x.z = -curViewMatrix.x.z; curViewMatrix.y.z = -curViewMatrix.y.z; curViewMatrix.z.z = -curViewMatrix.z.z; curViewMatrix.t.z = -curViewMatrix.t.z; matrix4_mul(&curViewProjMatrix, &curViewMatrix, &curProjMatrix); matrix4_transpose(&curViewProjMatrix, &curViewProjMatrix); if (curVertexShader->viewProj) shader_setmatrix4(curVertexShader, curVertexShader->viewProj, &curViewProjMatrix); } gs_device::gs_device(gs_init_data *data) : curRenderTarget (NULL), curZStencilBuffer (NULL), curRenderSide (0), curIndexBuffer (NULL), curVertexBuffer (NULL), curVertexShader (NULL), curPixelShader (NULL), curSwapChain (&defaultSwap), zstencilStateChanged (true), rasterStateChanged (true), blendStateChanged (true), curDepthStencilState (NULL), curRasterState (NULL), curBlendState (NULL), curToplogy (D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED) { ComPtr adapter; matrix4_identity(&curProjMatrix); matrix4_identity(&curViewMatrix); matrix4_identity(&curViewProjMatrix); memset(&viewport, 0, sizeof(viewport)); for (size_t i = 0; i < GS_MAX_TEXTURES; i++) { curTextures[i] = NULL; curSamplers[i] = NULL; } InitFactory(data->adapter, adapter.Assign()); InitDevice(data, adapter); device_setrendertarget(this, NULL, NULL); } gs_device *device_create(gs_init_data *data) { gs_device *device = NULL; try { device = new gs_device(data); } catch (HRError error) { blog(LOG_ERROR, "device_create (D3D11): %s (%08lX)", error.str, error.hr); } return device; } void device_destroy(device_t device) { delete device; } void device_entercontext(device_t device) { /* does nothing */ } void device_leavecontext(device_t device) { /* does nothing */ } swapchain_t device_create_swapchain(device_t device, struct gs_init_data *data) { gs_swap_chain *swap = NULL; try { swap = new gs_swap_chain(device, data); } catch (HRError error) { blog(LOG_ERROR, "device_create_swapchain (D3D11): %s (%08lX)", error.str, error.hr); } return swap; } void device_resize(device_t device, uint32_t cx, uint32_t cy) { try { ID3D11RenderTargetView *renderView = NULL; ID3D11DepthStencilView *depthView = NULL; int i = device->curRenderSide; device->context->OMSetRenderTargets(1, &renderView, depthView); device->curSwapChain->Resize(cx, cy); if (device->curRenderTarget) renderView = device->curRenderTarget->renderTarget[i]; if (device->curZStencilBuffer) depthView = device->curZStencilBuffer->view; device->context->OMSetRenderTargets(1, &renderView, depthView); } catch (HRError error) { blog(LOG_ERROR, "device_resize (D3D11): %s (%08lX)", error.str, error.hr); } } void device_getsize(device_t device, uint32_t *cx, uint32_t *cy) { *cx = device->curSwapChain->target.width; *cy = device->curSwapChain->target.height; } uint32_t device_getwidth(device_t device) { return device->curSwapChain->target.width; } uint32_t device_getheight(device_t device) { return device->curSwapChain->target.height; } texture_t device_create_texture(device_t device, uint32_t width, uint32_t height, enum gs_color_format color_format, uint32_t levels, const void **data, uint32_t flags) { gs_texture *texture = NULL; try { texture = new gs_texture_2d(device, width, height, color_format, levels, data, flags, GS_TEXTURE_2D, false, false); } catch (HRError error) { blog(LOG_ERROR, "device_create_texture (D3D11): %s (%08lX)", error.str, error.hr); } catch (const char *error) { blog(LOG_ERROR, "device_create_texture (D3D11): %s", error); } return texture; } texture_t device_create_cubetexture(device_t device, uint32_t size, enum gs_color_format color_format, uint32_t levels, const void **data, uint32_t flags) { gs_texture *texture = NULL; try { texture = new gs_texture_2d(device, size, size, color_format, levels, data, flags, GS_TEXTURE_CUBE, false, false); } catch (HRError error) { blog(LOG_ERROR, "device_create_cubetexture (D3D11): %s " "(%08lX)", error.str, error.hr); } catch (const char *error) { blog(LOG_ERROR, "device_create_cubetexture (D3D11): %s", error); } return texture; } texture_t device_create_volumetexture(device_t device, uint32_t width, uint32_t height, uint32_t depth, enum gs_color_format color_format, uint32_t levels, const void **data, uint32_t flags) { /* TODO */ return NULL; } zstencil_t device_create_zstencil(device_t device, uint32_t width, uint32_t height, enum gs_zstencil_format format) { gs_zstencil_buffer *zstencil = NULL; try { zstencil = new gs_zstencil_buffer(device, width, height, format); } catch (HRError error) { blog(LOG_ERROR, "device_create_zstencil (D3D11): %s (%08lX)", error.str, error.hr); } return zstencil; } stagesurf_t device_create_stagesurface(device_t device, uint32_t width, uint32_t height, enum gs_color_format color_format) { gs_stage_surface *surf = NULL; try { surf = new gs_stage_surface(device, width, height, color_format); } catch (HRError error) { blog(LOG_ERROR, "device_create_stagesurface (D3D11): %s " "(%08lX)", error.str, error.hr); } return surf; } samplerstate_t device_create_samplerstate(device_t device, struct gs_sampler_info *info) { gs_sampler_state *ss = NULL; try { ss = new gs_sampler_state(device, info); } catch (HRError error) { blog(LOG_ERROR, "device_create_samplerstate (D3D11): %s " "(%08lX)", error.str, error.hr); } return ss; } shader_t device_create_vertexshader(device_t device, const char *shader_string, const char *file, char **error_string) { gs_vertex_shader *shader = NULL; try { shader = new gs_vertex_shader(device, file, shader_string); } catch (HRError error) { blog(LOG_ERROR, "device_create_vertexshader (D3D11): %s " "(%08lX)", error.str, error.hr); } catch (ShaderError error) { const char *buf = (const char*)error.errors->GetBufferPointer(); if (error_string) *error_string = bstrdup(buf); blog(LOG_ERROR, "device_create_vertexshader (D3D11): " "Compile warnings/errors for %s:\n%s", file, buf); } catch (const char *error) { blog(LOG_ERROR, "device_create_vertexshader (D3D11): %s", error); } return shader; } shader_t device_create_pixelshader(device_t device, const char *shader_string, const char *file, char **error_string) { gs_pixel_shader *shader = NULL; try { shader = new gs_pixel_shader(device, file, shader_string); } catch (HRError error) { blog(LOG_ERROR, "device_create_pixelshader (D3D11): %s " "(%08lX)", error.str, error.hr); } catch (ShaderError error) { const char *buf = (const char*)error.errors->GetBufferPointer(); if (error_string) *error_string = bstrdup(buf); blog(LOG_ERROR, "device_create_pixelshader (D3D11): " "Compiler warnings/errors for %s:\n%s", file, buf); } catch (const char *error) { blog(LOG_ERROR, "device_create_pixelshader (D3D11): %s", error); } return shader; } vertbuffer_t device_create_vertexbuffer(device_t device, struct vb_data *data, uint32_t flags) { gs_vertex_buffer *buffer = NULL; try { buffer = new gs_vertex_buffer(device, data, flags); } catch (HRError error) { blog(LOG_ERROR, "device_create_vertexbuffer (D3D11): %s " "(%08lX)", error.str, error.hr); } catch (const char *error) { blog(LOG_ERROR, "device_create_vertexbuffer (D3D11): %s", error); } return buffer; } indexbuffer_t device_create_indexbuffer(device_t device, enum gs_index_type type, void *indices, size_t num, uint32_t flags) { gs_index_buffer *buffer = NULL; try { buffer = new gs_index_buffer(device, type, indices, num, flags); } catch (HRError error) { blog(LOG_ERROR, "device_create_indexbuffer (D3D11): %s (%08lX)", error.str, error.hr); } return buffer; } enum gs_texture_type device_gettexturetype(device_t device, texture_t texture) { return texture->type; } void device_load_vertexbuffer(device_t device, vertbuffer_t vertbuffer) { if (device->curVertexBuffer == vertbuffer) return; device->curVertexBuffer = vertbuffer; if (!device->curVertexShader) return; vector buffers; vector strides; vector offsets; if (vertbuffer) { vertbuffer->MakeBufferList(device->curVertexShader, buffers, strides); } else { size_t buffersToClear = device->curVertexShader->NumBuffersExpected(); buffers.resize(buffersToClear); strides.resize(buffersToClear); } offsets.resize(buffers.size()); device->context->IASetVertexBuffers(0, (UINT)buffers.size(), buffers.data(), strides.data(), offsets.data()); } void device_load_indexbuffer(device_t device, indexbuffer_t indexbuffer) { DXGI_FORMAT format; ID3D11Buffer *buffer; if (device->curIndexBuffer == indexbuffer) return; if (indexbuffer) { switch (indexbuffer->indexSize) { case 2: format = DXGI_FORMAT_R16_UINT; break; case 4: format = DXGI_FORMAT_R32_UINT; break; } buffer = indexbuffer->indexBuffer; } else { buffer = NULL; format = DXGI_FORMAT_R32_UINT; } device->curIndexBuffer = indexbuffer; device->context->IASetIndexBuffer(buffer, format, 0); } void device_load_texture(device_t device, texture_t tex, int unit) { ID3D11ShaderResourceView *view = NULL; if (device->curTextures[unit] == tex) return; if (tex) view = tex->shaderRes; device->curTextures[unit] = tex; device->context->PSSetShaderResources(unit, 1, &view); } void device_load_samplerstate(device_t device, samplerstate_t samplerstate, int unit) { ID3D11SamplerState *state = NULL; if (device->curSamplers[unit] == samplerstate) return; if (samplerstate) state = samplerstate->state; device->curSamplers[unit] = samplerstate; device->context->PSSetSamplers(unit, 1, &state); } void device_load_vertexshader(device_t device, shader_t vertshader) { ID3D11VertexShader *shader = NULL; ID3D11InputLayout *layout = NULL; ID3D11Buffer *constants = NULL; if (device->curVertexShader == vertshader) return; gs_vertex_shader *vs = static_cast(vertshader); gs_vertex_buffer *curVB = device->curVertexBuffer; if (vertshader) { if (vertshader->type != SHADER_VERTEX) { blog(LOG_ERROR, "device_load_vertexshader (D3D11): " "Specified shader is not a vertex " "shader"); return; } if (curVB) device_load_vertexbuffer(device, NULL); shader = vs->shader; layout = vs->layout; constants = vs->constants; } device->curVertexShader = vs; device->context->VSSetShader(shader, NULL, 0); device->context->IASetInputLayout(layout); device->context->VSSetConstantBuffers(0, 1, &constants); if (vertshader && curVB) device_load_vertexbuffer(device, curVB); } static inline void clear_textures(device_t device) { ID3D11ShaderResourceView *views[GS_MAX_TEXTURES]; memset(views, 0, sizeof(views)); memset(device->curTextures, 0, sizeof(device->curTextures)); device->context->PSSetShaderResources(0, GS_MAX_TEXTURES, views); } void device_load_pixelshader(device_t device, shader_t pixelshader) { ID3D11PixelShader *shader = NULL; ID3D11Buffer *constants = NULL; ID3D11SamplerState *states[GS_MAX_TEXTURES]; if (device->curPixelShader == pixelshader) return; gs_pixel_shader *ps = static_cast(pixelshader); if (pixelshader) { if (pixelshader->type != SHADER_PIXEL) { blog(LOG_ERROR, "device_load_pixelshader (D3D11): " "Specified shader is not a pixel " "shader"); return; } shader = ps->shader; constants = ps->constants; ps->GetSamplerStates(states); } else { memset(states, 0, sizeof(states)); } clear_textures(device); device->curPixelShader = ps; device->context->PSSetShader(shader, NULL, 0); device->context->PSSetConstantBuffers(0, 1, &constants); device->context->PSSetSamplers(0, GS_MAX_TEXTURES, states); } void device_load_defaultsamplerstate(device_t device, bool b_3d, int unit) { /* TODO */ } shader_t device_getvertexshader(device_t device) { return device->curVertexShader; } shader_t device_getpixelshader(device_t device) { return device->curPixelShader; } texture_t device_getrendertarget(device_t device) { if (device->curRenderTarget == &device->curSwapChain->target) return NULL; return device->curRenderTarget; } zstencil_t device_getzstenciltarget(device_t device) { if (device->curZStencilBuffer == &device->curSwapChain->zs) return NULL; return device->curZStencilBuffer; } void device_setrendertarget(device_t device, texture_t tex, zstencil_t zstencil) { if (!tex) tex = &device->curSwapChain->target; if (!zstencil) zstencil = &device->curSwapChain->zs; if (device->curRenderTarget == tex && device->curZStencilBuffer == zstencil) return; if (tex->type != GS_TEXTURE_2D) { blog(LOG_ERROR, "device_setrendertarget (D3D11): " "texture is not a 2D texture"); return; } gs_texture_2d *tex2d = static_cast(tex); if (!tex2d->renderTarget[0]) { blog(LOG_ERROR, "device_setrendertarget (D3D11): " "texture is not a render target"); return; } ID3D11RenderTargetView *rt = tex2d->renderTarget[0]; device->curRenderTarget = tex2d; device->curRenderSide = 0; device->curZStencilBuffer = zstencil; device->context->OMSetRenderTargets(1, &rt, zstencil->view); } void device_setcuberendertarget(device_t device, texture_t tex, int side, zstencil_t zstencil) { if (!tex) { tex = &device->curSwapChain->target; side = 0; } if (!zstencil) zstencil = &device->curSwapChain->zs; if (device->curRenderTarget == tex && device->curRenderSide == side && device->curZStencilBuffer == zstencil) return; if (tex->type != GS_TEXTURE_CUBE) { blog(LOG_ERROR, "device_setcuberendertarget (D3D11): " "texture is not a cube texture"); return; } gs_texture_2d *tex2d = static_cast(tex); if (!tex2d->renderTarget[side]) { blog(LOG_ERROR, "device_setcuberendertarget (D3D11): " "texture is not a render target"); return; } ID3D11RenderTargetView *rt = tex2d->renderTarget[0]; device->curRenderTarget = tex2d; device->curRenderSide = side; device->curZStencilBuffer = zstencil; device->context->OMSetRenderTargets(1, &rt, zstencil->view); } inline void gs_device::CopyTex(ID3D11Texture2D *dst, texture_t src) { if (src->type != GS_TEXTURE_2D) throw "Source texture must be a 2D texture"; gs_texture_2d *tex2d = static_cast(src); context->CopyResource(dst, tex2d->texture); } void device_copy_texture(device_t device, texture_t dst, texture_t src) { try { gs_texture_2d *src2d = static_cast(src); gs_texture_2d *dst2d = static_cast(dst); if (!src) throw "Source texture is NULL"; if (!dst) throw "Destination texture is NULL"; if (src->type != GS_TEXTURE_2D || dst->type != GS_TEXTURE_2D) throw "Source and destination textures must be a 2D " "textures"; if (dst->format != src->format) throw "Source and destination formats do not match"; if (dst2d->width != src2d->width || dst2d->height != src2d->height) throw "Source and destination must have the same " "dimensions"; gs_texture_2d *tex2d = static_cast(dst); device->CopyTex(tex2d->texture, src); } catch (const char *error) { blog(LOG_ERROR, "device_copy_texture (D3D11): %s", error); } } void device_stage_texture(device_t device, stagesurf_t dst, texture_t src) { try { gs_texture_2d *src2d = static_cast(src); if (!src) throw "Source texture is NULL"; if (src->type != GS_TEXTURE_2D) throw "Source texture must be a 2D texture"; if (!dst) throw "Destination surface is NULL"; if (dst->format != src->format) throw "Source and destination formats do not match"; if (dst->width != src2d->width || dst->height != src2d->height) throw "Source and destination must have the same " "dimensions"; device->CopyTex(dst->texture, src); } catch (const char *error) { blog(LOG_ERROR, "device_copy_texture (D3D11): %s", error); } } void device_beginscene(device_t device) { clear_textures(device); } void device_draw(device_t device, enum gs_draw_mode draw_mode, uint32_t start_vert, uint32_t num_verts) { try { if (!device->curVertexShader) throw "No vertex shader specified"; if (!device->curPixelShader) throw "No pixel shader specified"; if (!device->curVertexBuffer) throw "No vertex buffer specified"; effect_t effect = gs_geteffect(); if (effect) effect_updateparams(effect); device->UpdateBlendState(); device->UpdateRasterState(); device->UpdateZStencilState(); device->UpdateViewProjMatrix(); device->curVertexShader->UploadParams(); device->curPixelShader->UploadParams(); } catch (const char *error) { blog(LOG_ERROR, "device_draw (D3D11): %s", error); return; } catch (HRError error) { blog(LOG_ERROR, "device_draw (D3D11): %s (%08lX)", error.str, error.hr); return; } D3D11_PRIMITIVE_TOPOLOGY newTopology = ConvertGSTopology(draw_mode); if (device->curToplogy != newTopology) { device->context->IASetPrimitiveTopology(newTopology); device->curToplogy = newTopology; } if (device->curIndexBuffer) { if (num_verts == 0) num_verts = (uint32_t)device->curIndexBuffer->num; device->context->DrawIndexed(num_verts, start_vert, 0); } else { if (num_verts == 0) num_verts = (uint32_t)device->curVertexBuffer->numVerts; device->context->Draw(num_verts, start_vert); } } void device_endscene(device_t device) { /* does nothing in D3D11 */ } void device_load_swapchain(device_t device, swapchain_t swapchain) { texture_t target = device->curRenderTarget; zstencil_t zs = device->curZStencilBuffer; bool is_cube = device->curRenderTarget->type == GS_TEXTURE_CUBE; if (target == &device->curSwapChain->target) target = NULL; if (zs == &device->curSwapChain->zs) zs = NULL; if (swapchain == NULL) swapchain = &device->defaultSwap; device->curSwapChain = swapchain; if (is_cube) device_setcuberendertarget(device, target, device->curRenderSide, zs); else device_setrendertarget(device, target, zs); } void device_clear(device_t device, uint32_t clear_flags, struct vec4 *color, float depth, uint8_t stencil) { int side = device->curRenderSide; if ((clear_flags & GS_CLEAR_COLOR) != 0 && device->curRenderTarget) device->context->ClearRenderTargetView( device->curRenderTarget->renderTarget[side], color->ptr); if (device->curZStencilBuffer) { uint32_t flags = 0; if ((clear_flags & GS_CLEAR_DEPTH) != 0) flags |= D3D11_CLEAR_DEPTH; if ((clear_flags & GS_CLEAR_STENCIL) != 0) flags |= D3D11_CLEAR_STENCIL; if (flags && device->curZStencilBuffer->view) device->context->ClearDepthStencilView( device->curZStencilBuffer->view, flags, depth, stencil); } } void device_present(device_t device) { device->curSwapChain->swap->Present(0, 0); } void device_setcullmode(device_t device, enum gs_cull_mode mode) { if (mode == device->rasterState.cullMode) return; device->rasterState.cullMode = mode; device->rasterStateChanged = true; } enum gs_cull_mode device_getcullmode(device_t device) { return device->rasterState.cullMode; } void device_enable_blending(device_t device, bool enable) { if (enable == device->blendState.blendEnabled) return; device->blendState.blendEnabled = enable; device->blendStateChanged = true; } void device_enable_depthtest(device_t device, bool enable) { if (enable == device->zstencilState.depthEnabled) return; device->zstencilState.depthEnabled = enable; device->zstencilStateChanged = true; } void device_enable_stenciltest(device_t device, bool enable) { if (enable == device->zstencilState.stencilEnabled) return; device->zstencilState.stencilEnabled = enable; device->zstencilStateChanged = true; } void device_enable_stencilwrite(device_t device, bool enable) { if (enable == device->zstencilState.stencilWriteEnabled) return; device->zstencilState.stencilWriteEnabled = enable; device->zstencilStateChanged = true; } void device_enable_color(device_t device, bool red, bool green, bool blue, bool alpha) { if (device->blendState.redEnabled == red && device->blendState.greenEnabled == green && device->blendState.blueEnabled == blue && device->blendState.alphaEnabled == alpha) return; device->blendState.redEnabled = red; device->blendState.greenEnabled = green; device->blendState.blueEnabled = blue; device->blendState.alphaEnabled = alpha; device->blendStateChanged = true; } void device_blendfunction(device_t device, enum gs_blend_type src, enum gs_blend_type dest) { if (device->blendState.srcFactor == src && device->blendState.destFactor == dest) return; device->blendState.srcFactor = src; device->blendState.destFactor = dest; device->blendStateChanged = true; } void device_depthfunction(device_t device, enum gs_depth_test test) { if (device->zstencilState.depthFunc == test) return; device->zstencilState.depthFunc = test; device->zstencilStateChanged = true; } static inline void update_stencilside_test(device_t device, StencilSide &side, gs_depth_test test) { if (side.test == test) return; side.test = test; device->zstencilStateChanged = true; } void device_stencilfunction(device_t device, enum gs_stencil_side side, enum gs_depth_test test) { int sideVal = (int)side; if (sideVal & GS_STENCIL_FRONT) update_stencilside_test(device, device->zstencilState.stencilFront, test); if (sideVal & GS_STENCIL_BACK) update_stencilside_test(device, device->zstencilState.stencilBack, test); } static inline void update_stencilside_op(device_t device, StencilSide &side, enum gs_stencil_op fail, enum gs_stencil_op zfail, enum gs_stencil_op zpass) { if (side.fail == fail && side.zfail == zfail && side.zpass == zpass) return; side.fail = fail; side.zfail = zfail; side.zpass = zpass; device->zstencilStateChanged = true; } void device_stencilop(device_t device, enum gs_stencil_side side, enum gs_stencil_op fail, enum gs_stencil_op zfail, enum gs_stencil_op zpass) { int sideVal = (int)side; if (sideVal & GS_STENCIL_FRONT) update_stencilside_op(device, device->zstencilState.stencilFront, fail, zfail, zpass); if (sideVal & GS_STENCIL_BACK) update_stencilside_op(device, device->zstencilState.stencilBack, fail, zfail, zpass); } void device_enable_fullscreen(device_t device, bool enable) { /* TODO */ } int device_fullscreen_enabled(device_t device) { /* TODO */ return 0; } void device_setdisplaymode(device_t device, const struct gs_display_mode *mode) { /* TODO */ } void device_getdisplaymode(device_t device, struct gs_display_mode *mode) { /* TODO */ } void device_setcolorramp(device_t device, float gamma, float brightness, float contrast) { /* TODO */ } void device_setviewport(device_t device, int x, int y, int width, int height) { D3D11_VIEWPORT vp; memset(&vp, 0, sizeof(vp)); vp.MaxDepth = 1.0f; vp.TopLeftX = (float)x; vp.TopLeftY = (float)y; vp.Width = (float)width; vp.Height = (float)height; device->context->RSSetViewports(1, &vp); device->viewport.x = x; device->viewport.y = y; device->viewport.cx = width; device->viewport.cy = height; } void device_getviewport(device_t device, struct gs_rect *rect) { memcpy(rect, &device->viewport, sizeof(gs_rect)); } void device_setscissorrect(device_t device, struct gs_rect *rect) { D3D11_RECT d3drect; d3drect.left = rect->x; d3drect.top = rect->y; d3drect.right = rect->x + rect->cx; d3drect.bottom = rect->y + rect->cy; device->context->RSSetScissorRects(1, &d3drect); } void device_ortho(device_t device, float left, float right, float top, float bottom, float zNear, float zFar) { matrix4 *dst = &device->curProjMatrix; float rml = right-left; float bmt = bottom-top; float fmn = zFar-zNear; vec4_zero(&dst->x); vec4_zero(&dst->y); vec4_zero(&dst->z); vec4_zero(&dst->t); dst->x.x = 2.0f / rml; dst->t.x = (left+right) / -rml; dst->y.y = 2.0f / -bmt; dst->t.y = (bottom+top) / bmt; dst->z.z = 1.0f / fmn; dst->t.z = zNear / -fmn; dst->t.w = 1.0f; } void device_frustum(device_t device, float left, float right, float top, float bottom, float zNear, float zFar) { matrix4 *dst = &device->curProjMatrix; float rml = right-left; float bmt = bottom-top; float fmn = zFar-zNear; float nearx2 = 2.0f*zNear; vec4_zero(&dst->x); vec4_zero(&dst->y); vec4_zero(&dst->z); vec4_zero(&dst->t); dst->x.x = nearx2 / rml; dst->z.x = (left+right) / -rml; dst->y.y = nearx2 / -bmt; dst->z.y = (bottom+top) / bmt; dst->z.z = zFar / fmn; dst->t.z = (zNear*zFar) / -fmn; dst->z.w = 1.0f; } void device_projection_push(device_t device) { mat4float mat; memcpy(&mat, &device->curProjMatrix, sizeof(matrix4)); device->projStack.push_back(mat); } void device_projection_pop(device_t device) { if (!device->projStack.size()) return; mat4float *mat = device->projStack.data(); size_t end = device->projStack.size()-1; /* XXX - does anyone know a better way of doing this? */ memcpy(&device->curProjMatrix, mat+end, sizeof(matrix4)); device->projStack.pop_back(); } void swapchain_destroy(swapchain_t swapchain) { if (!swapchain) return; gs_device *device = swapchain->device; if (device->curSwapChain == swapchain) device->curSwapChain = &device->defaultSwap; delete swapchain; } void texture_destroy(texture_t tex) { delete tex; } uint32_t texture_getwidth(texture_t tex) { if (tex->type != GS_TEXTURE_2D) return 0; return static_cast(tex)->width; } uint32_t texture_getheight(texture_t tex) { if (tex->type != GS_TEXTURE_2D) return 0; return static_cast(tex)->height; } enum gs_color_format texture_getcolorformat(texture_t tex) { if (tex->type != GS_TEXTURE_2D) return GS_UNKNOWN; return static_cast(tex)->format; } bool texture_map(texture_t tex, void **ptr, uint32_t *row_bytes) { HRESULT hr; if (tex->type != GS_TEXTURE_2D) return false; gs_texture_2d *tex2d = static_cast(tex); D3D11_MAPPED_SUBRESOURCE map; hr = tex2d->device->context->Map(tex2d->texture, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); if (FAILED(hr)) return false; *ptr = map.pData; *row_bytes = map.RowPitch; return true; } void texture_unmap(texture_t tex) { if (tex->type != GS_TEXTURE_2D) return; gs_texture_2d *tex2d = static_cast(tex); tex2d->device->context->Unmap(tex2d->texture, 0); } void cubetexture_destroy(texture_t cubetex) { delete cubetex; } uint32_t cubetexture_getsize(texture_t cubetex) { if (cubetex->type != GS_TEXTURE_CUBE) return 0; gs_texture_2d *tex = static_cast(cubetex); return tex->width; } enum gs_color_format cubetexture_getcolorformat(texture_t cubetex) { if (cubetex->type != GS_TEXTURE_CUBE) return GS_UNKNOWN; gs_texture_2d *tex = static_cast(cubetex); return tex->format; } void volumetexture_destroy(texture_t voltex) { delete voltex; } uint32_t volumetexture_getwidth(texture_t voltex) { /* TODO */ return 0; } uint32_t volumetexture_getheight(texture_t voltex) { /* TODO */ return 0; } uint32_t volumetexture_getdepth(texture_t voltex) { /* TODO */ return 0; } enum gs_color_format volumetexture_getcolorformat(texture_t voltex) { /* TODO */ return GS_UNKNOWN; } void stagesurface_destroy(stagesurf_t stagesurf) { delete stagesurf; } uint32_t stagesurface_getwidth(stagesurf_t stagesurf) { return stagesurf->width; } uint32_t stagesurface_getheight(stagesurf_t stagesurf) { return stagesurf->height; } enum gs_color_format stagesurface_getcolorformat(stagesurf_t stagesurf) { return stagesurf->format; } bool stagesurface_map(stagesurf_t stagesurf, const void **data, uint32_t *row_bytes) { D3D11_MAPPED_SUBRESOURCE map; if (FAILED(stagesurf->device->context->Map(stagesurf->texture, 0, D3D11_MAP_READ, 0, &map))) return false; *data = map.pData; *row_bytes = map.RowPitch; return true; } void stagesurface_unmap(stagesurf_t stagesurf) { stagesurf->device->context->Unmap(stagesurf->texture, 0); } void zstencil_destroy(zstencil_t zstencil) { delete zstencil; } void samplerstate_destroy(samplerstate_t samplerstate) { delete samplerstate; } void vertexbuffer_destroy(vertbuffer_t vertbuffer) { delete vertbuffer; } void vertexbuffer_flush(vertbuffer_t vertbuffer, bool rebuild) { if (!vertbuffer->dynamic) { blog(LOG_WARNING, "vertexbuffer_flush: vertex buffer is " "not dynamic"); return; } vertbuffer->FlushBuffer(vertbuffer->vertexBuffer, vertbuffer->vbd.data->points, sizeof(vec3)); if (vertbuffer->normalBuffer) vertbuffer->FlushBuffer(vertbuffer->normalBuffer, vertbuffer->vbd.data->normals, sizeof(vec3)); if (vertbuffer->tangentBuffer) vertbuffer->FlushBuffer(vertbuffer->tangentBuffer, vertbuffer->vbd.data->tangents, sizeof(vec3)); if (vertbuffer->colorBuffer) vertbuffer->FlushBuffer(vertbuffer->colorBuffer, vertbuffer->vbd.data->colors, sizeof(uint32_t)); for (size_t i = 0; i < vertbuffer->uvBuffers.size(); i++) { tvertarray &tv = vertbuffer->vbd.data->tvarray[i]; vertbuffer->FlushBuffer(vertbuffer->uvBuffers[i], tv.array, tv.width*sizeof(float)); } } struct vb_data *vertexbuffer_getdata(vertbuffer_t vertbuffer) { return vertbuffer->vbd.data; } void indexbuffer_destroy(indexbuffer_t indexbuffer) { delete indexbuffer; } void indexbuffer_flush(indexbuffer_t indexbuffer) { HRESULT hr; if (!indexbuffer->dynamic) return; D3D11_MAPPED_SUBRESOURCE map; hr = indexbuffer->device->context->Map(indexbuffer->indexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); if (FAILED(hr)) return; memcpy(map.pData, indexbuffer->indices.data, indexbuffer->num * indexbuffer->indexSize); indexbuffer->device->context->Unmap(indexbuffer->indexBuffer, 0); } void *indexbuffer_getdata(indexbuffer_t indexbuffer) { return indexbuffer->indices.data; } size_t indexbuffer_numindices(indexbuffer_t indexbuffer) { return indexbuffer->num; } enum gs_index_type indexbuffer_gettype(indexbuffer_t indexbuffer) { return indexbuffer->type; }