ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

various fixes for CXX_BUILD.

This commit is contained in:
aliaspider 2018-02-04 20:03:27 +01:00
parent ac22a9ce20
commit 700fce3bd2
18 changed files with 421 additions and 1599 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gfx/common/d3d10_common.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <gfx/scaler/pixconv.h> #include <gfx/scaler/pixconv.h>
#include "d3d10_common.h" #include "d3d10_common.h"

1517
gfx/common/d3d10_common.h
View File

File diff suppressed because it is too large Load Diff

8
gfx/common/d3d11_common.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <string.h> #include <string.h>
#include "d3d11_common.h" #include "d3d11_common.h"
@ -122,9 +124,9 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
void d3d11_update_texture( void d3d11_update_texture(
D3D11DeviceContext ctx, D3D11DeviceContext ctx,
int width, unsigned width,
int height, unsigned height,
int pitch, unsigned pitch,
DXGI_FORMAT format, DXGI_FORMAT format,
const void* data, const void* data,
d3d11_texture_t* texture) d3d11_texture_t* texture)

9
gfx/common/d3d11_common.h
View File

@ -18,6 +18,9 @@
#include <retro_inline.h> #include <retro_inline.h>
#include "dxgi_common.h" #include "dxgi_common.h"
#ifdef CINTERFACE
#define D3D11_NO_HELPERS
#endif
#include <d3d11.h> #include <d3d11.h>
typedef const ID3D11ShaderResourceView* D3D11ShaderResourceViewRef; typedef const ID3D11ShaderResourceView* D3D11ShaderResourceViewRef;
@ -2578,9 +2581,9 @@ static INLINE void d3d11_release_texture(d3d11_texture_t* texture)
void d3d11_update_texture( void d3d11_update_texture(
D3D11DeviceContext ctx, D3D11DeviceContext ctx,
int width, unsigned width,
int height, unsigned height,
int pitch, unsigned pitch,
DXGI_FORMAT format, DXGI_FORMAT format,
const void* data, const void* data,
d3d11_texture_t* texture); d3d11_texture_t* texture);

269
gfx/common/d3d12_common.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include "d3d12_common.h" #include "d3d12_common.h"
#include "dxgi_common.h" #include "dxgi_common.h"
#include "d3dcompiler_common.h" #include "d3dcompiler_common.h"
@ -25,7 +27,11 @@
#ifdef __MINGW32__ #ifdef __MINGW32__
/* clang-format off */ /* clang-format off */
#ifdef __cplusplus
#define DEFINE_GUIDW(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) EXTERN_C const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
#else
#define DEFINE_GUIDW(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 DEFINE_GUIDW(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 } }
#endif
DEFINE_GUIDW(IID_ID3D12PipelineState, 0x765a30f3, 0xf624, 0x4c6f, 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45); DEFINE_GUIDW(IID_ID3D12PipelineState, 0x765a30f3, 0xf624, 0x4c6f, 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45);
DEFINE_GUIDW(IID_ID3D12RootSignature, 0xc54a6b66, 0x72df, 0x4ee8, 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14); DEFINE_GUIDW(IID_ID3D12RootSignature, 0xc54a6b66, 0x72df, 0x4ee8, 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14);
@ -64,7 +70,7 @@ static const char* d3d12_dll_name = "d3d12.dll";
HRESULT WINAPI D3D12CreateDevice( HRESULT WINAPI D3D12CreateDevice(
IUnknown* pAdapter, D3D_FEATURE_LEVEL MinimumFeatureLevel, REFIID riid, void** ppDevice) IUnknown* pAdapter, D3D_FEATURE_LEVEL MinimumFeatureLevel, REFIID riid, void** ppDevice)
{ {
static PFN_D3D12_CREATE_DEVICE fp; static PFN_D3D12_CREATE_DEVICE fp;
if (!d3d12_dll) if (!d3d12_dll)
d3d12_dll = dylib_load(d3d12_dll_name); d3d12_dll = dylib_load(d3d12_dll_name);
@ -75,7 +81,7 @@ HRESULT WINAPI D3D12CreateDevice(
fp = (PFN_D3D12_CREATE_DEVICE)dylib_proc(d3d12_dll, "D3D12CreateDevice"); fp = (PFN_D3D12_CREATE_DEVICE)dylib_proc(d3d12_dll, "D3D12CreateDevice");
if (fp) if (fp)
return fp(pAdapter, MinimumFeatureLevel, riid, ppDevice); return fp(pAdapter, MinimumFeatureLevel, riid, ppDevice);
error: error:
return TYPE_E_CANTLOADLIBRARY; return TYPE_E_CANTLOADLIBRARY;
@ -88,13 +94,13 @@ HRESULT WINAPI D3D12GetDebugInterface(REFIID riid, void** ppvDebug)
d3d12_dll = dylib_load(d3d12_dll_name); d3d12_dll = dylib_load(d3d12_dll_name);
if (!d3d12_dll) if (!d3d12_dll)
goto error; goto error;
if (!fp) if (!fp)
fp = (PFN_D3D12_GET_DEBUG_INTERFACE)dylib_proc(d3d12_dll, "D3D12GetDebugInterface"); fp = (PFN_D3D12_GET_DEBUG_INTERFACE)dylib_proc(d3d12_dll, "D3D12GetDebugInterface");
if (fp) if (fp)
return fp(riid, ppvDebug); return fp(riid, ppvDebug);
error: error:
return TYPE_E_CANTLOADLIBRARY; return TYPE_E_CANTLOADLIBRARY;
@ -114,8 +120,7 @@ HRESULT WINAPI D3D12SerializeRootSignature(
goto error; goto error;
if (!fp) if (!fp)
fp = (PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)dylib_proc( fp = (PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)dylib_proc(d3d12_dll, "D3D12SerializeRootSignature");
d3d12_dll, "D3D12SerializeRootSignature");
if (fp) if (fp)
return fp(pRootSignature, Version, ppBlob, ppErrorBlob); return fp(pRootSignature, Version, ppBlob, ppErrorBlob);
@ -138,10 +143,10 @@ HRESULT WINAPI D3D12SerializeVersionedRootSignature(
if (!fp) if (!fp)
fp = (PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)dylib_proc( fp = (PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)dylib_proc(
d3d12_dll, "D3D12SerializeRootSignature"); d3d12_dll, "D3D12SerializeRootSignature");
if (fp) if (fp)
return fp(pRootSignature, ppBlob, ppErrorBlob); return fp(pRootSignature, ppBlob, ppErrorBlob);
error: error:
return TYPE_E_CANTLOADLIBRARY; return TYPE_E_CANTLOADLIBRARY;
@ -179,10 +184,8 @@ bool d3d12_init_base(d3d12_video_t* d3d12)
bool d3d12_init_queue(d3d12_video_t* d3d12) bool d3d12_init_queue(d3d12_video_t* d3d12)
{ {
{ {
static const D3D12_COMMAND_QUEUE_DESC desc = { static const D3D12_COMMAND_QUEUE_DESC desc = { D3D12_COMMAND_LIST_TYPE_DIRECT, 0,
.Type = D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_QUEUE_FLAG_NONE, 0 };
.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE,
};
D3D12CreateCommandQueue( D3D12CreateCommandQueue(
d3d12->device, (D3D12_COMMAND_QUEUE_DESC*)&desc, &d3d12->queue.handle); d3d12->device, (D3D12_COMMAND_QUEUE_DESC*)&desc, &d3d12->queue.handle);
} }
@ -206,26 +209,25 @@ bool d3d12_init_queue(d3d12_video_t* d3d12)
bool d3d12_init_swapchain(d3d12_video_t* d3d12, int width, int height, HWND hwnd) bool d3d12_init_swapchain(d3d12_video_t* d3d12, int width, int height, HWND hwnd)
{ {
{ {
DXGI_SWAP_CHAIN_DESC desc = { DXGI_SWAP_CHAIN_DESC desc = { 0 };
.BufferCount = countof(d3d12->chain.renderTargets), desc.BufferCount = countof(d3d12->chain.renderTargets);
.BufferDesc.Width = width, desc.BufferDesc.Width = width;
.BufferDesc.Height = height, desc.BufferDesc.Height = height;
.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM, desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
.SampleDesc.Count = 1, desc.SampleDesc.Count = 1;
#if 0 #if 0
.BufferDesc.RefreshRate.Numerator = 60, desc.BufferDesc.RefreshRate.Numerator = 60;
.BufferDesc.RefreshRate.Denominator = 1, desc.BufferDesc.RefreshRate.Denominator = 1;
.SampleDesc.Quality = 0, desc.SampleDesc.Quality = 0;
#endif #endif
.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT, desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
.OutputWindow = hwnd, desc.OutputWindow = hwnd;
.Windowed = TRUE, desc.Windowed = TRUE;
#if 0 #if 0
.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
#else #else
.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD, desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
#endif #endif
};
DXGICreateSwapChain(d3d12->factory, d3d12->queue.handle, &desc, &d3d12->chain.handle); DXGICreateSwapChain(d3d12->factory, d3d12->queue.handle, &desc, &d3d12->chain.handle);
} }
@ -285,7 +287,7 @@ static void d3d12_init_sampler(
bool d3d12_init_descriptors(d3d12_video_t* d3d12) bool d3d12_init_descriptors(d3d12_video_t* d3d12)
{ {
D3D12_ROOT_SIGNATURE_DESC desc; D3D12_ROOT_SIGNATURE_DESC desc;
static const D3D12_DESCRIPTOR_RANGE srv_table[] = { static const D3D12_DESCRIPTOR_RANGE srv_table[] = {
{ {
.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV, .RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV,
@ -308,30 +310,22 @@ bool d3d12_init_descriptors(d3d12_video_t* d3d12)
}, },
}; };
D3D12_ROOT_PARAMETER rootParameters[ROOT_INDEX_MAX] = { D3D12_ROOT_PARAMETER rootParameters[ROOT_ID_MAX] = {};
{
D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE,
{{0}},
D3D12_SHADER_VISIBILITY_PIXEL,
},
{
D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE,
{{0}},
D3D12_SHADER_VISIBILITY_PIXEL,
},
{
D3D12_ROOT_PARAMETER_TYPE_CBV,
{{0}},
D3D12_SHADER_VISIBILITY_VERTEX,
}
};
rootParameters[0].DescriptorTable.NumDescriptorRanges = countof(srv_table); rootParameters[ROOT_ID_TEXTURE_T].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
rootParameters[0].DescriptorTable.pDescriptorRanges = srv_table; rootParameters[ROOT_ID_TEXTURE_T].DescriptorTable.NumDescriptorRanges = countof(srv_table);
rootParameters[1].DescriptorTable.NumDescriptorRanges = countof(sampler_table); rootParameters[ROOT_ID_TEXTURE_T].DescriptorTable.pDescriptorRanges = srv_table;
rootParameters[1].DescriptorTable.pDescriptorRanges = sampler_table; rootParameters[ROOT_ID_TEXTURE_T].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
rootParameters[2].Descriptor.RegisterSpace = 0;
rootParameters[2].Descriptor.ShaderRegister = 0; rootParameters[ROOT_ID_SAMPLER_T].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
rootParameters[ROOT_ID_SAMPLER_T].DescriptorTable.NumDescriptorRanges = countof(sampler_table);
rootParameters[ROOT_ID_SAMPLER_T].DescriptorTable.pDescriptorRanges = sampler_table;
rootParameters[ROOT_ID_SAMPLER_T].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
rootParameters[ROOT_ID_UBO].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
rootParameters[ROOT_ID_UBO].Descriptor.RegisterSpace = 0;
rootParameters[ROOT_ID_UBO].Descriptor.ShaderRegister = 0;
rootParameters[ROOT_ID_UBO].ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX;
desc.NumParameters = countof(rootParameters); desc.NumParameters = countof(rootParameters);
desc.pParameters = rootParameters; desc.pParameters = rootParameters;
@ -417,24 +411,6 @@ bool d3d12_init_pipeline(d3d12_video_t* d3d12)
.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF, .ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF,
}; };
static const D3D12_BLEND_DESC blendDesc = {
.AlphaToCoverageEnable = FALSE,
.IndependentBlendEnable = FALSE,
.RenderTarget[0] =
{
.BlendEnable = TRUE,
.LogicOpEnable = FALSE,
D3D12_BLEND_SRC_ALPHA,
D3D12_BLEND_INV_SRC_ALPHA,
D3D12_BLEND_OP_ADD,
D3D12_BLEND_SRC_ALPHA,
D3D12_BLEND_INV_SRC_ALPHA,
D3D12_BLEND_OP_ADD,
D3D12_LOGIC_OP_NOOP,
D3D12_COLOR_WRITE_ENABLE_ALL,
},
};
if (!d3d_compile(stock, sizeof(stock), NULL, "VSMain", "vs_5_0", &vs_code)) if (!d3d_compile(stock, sizeof(stock), NULL, "VSMain", "vs_5_0", &vs_code))
return false; return false;
@ -442,48 +418,44 @@ bool d3d12_init_pipeline(d3d12_video_t* d3d12)
return false; return false;
{ {
D3D12_GRAPHICS_PIPELINE_STATE_DESC psodesc = { D3D12_GRAPHICS_PIPELINE_STATE_DESC psodesc = { 0 };
.pRootSignature = d3d12->pipe.rootSignature, psodesc.pRootSignature = d3d12->pipe.rootSignature;
.VS.pShaderBytecode = D3DGetBufferPointer(vs_code), psodesc.VS.pShaderBytecode = D3DGetBufferPointer(vs_code);
.VS.BytecodeLength = D3DGetBufferSize(vs_code), psodesc.VS.BytecodeLength = D3DGetBufferSize(vs_code);
.PS.pShaderBytecode = D3DGetBufferPointer(ps_code), psodesc.PS.pShaderBytecode = D3DGetBufferPointer(ps_code);
.PS.BytecodeLength = D3DGetBufferSize(ps_code), psodesc.PS.BytecodeLength = D3DGetBufferSize(ps_code);
.BlendState.AlphaToCoverageEnable = FALSE, psodesc.BlendState.AlphaToCoverageEnable = FALSE;
.BlendState.IndependentBlendEnable = FALSE, psodesc.BlendState.IndependentBlendEnable = FALSE;
.BlendState.RenderTarget[0] = psodesc.BlendState.RenderTarget[0].BlendEnable = TRUE;
{ psodesc.BlendState.RenderTarget[0].LogicOpEnable = FALSE;
.BlendEnable = TRUE, psodesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
.LogicOpEnable = FALSE, psodesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
D3D12_BLEND_SRC_ALPHA, psodesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
D3D12_BLEND_INV_SRC_ALPHA, psodesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_SRC_ALPHA;
D3D12_BLEND_OP_ADD, psodesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
D3D12_BLEND_SRC_ALPHA, psodesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
D3D12_BLEND_INV_SRC_ALPHA, psodesc.BlendState.RenderTarget[0].LogicOp = D3D12_LOGIC_OP_NOOP;
D3D12_BLEND_OP_ADD, psodesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
D3D12_LOGIC_OP_NOOP, psodesc.SampleMask = UINT_MAX;
D3D12_COLOR_WRITE_ENABLE_ALL, psodesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
}, psodesc.RasterizerState.CullMode = D3D12_CULL_MODE_BACK;
.SampleMask = UINT_MAX, psodesc.RasterizerState.FrontCounterClockwise = FALSE;
.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID, psodesc.RasterizerState.DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
.RasterizerState.CullMode = D3D12_CULL_MODE_BACK, psodesc.RasterizerState.DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
.RasterizerState.FrontCounterClockwise = FALSE, psodesc.RasterizerState.SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
.RasterizerState.DepthBias = D3D12_DEFAULT_DEPTH_BIAS, psodesc.RasterizerState.DepthClipEnable = TRUE;
.RasterizerState.DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP, psodesc.RasterizerState.MultisampleEnable = FALSE;
.RasterizerState.SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS, psodesc.RasterizerState.AntialiasedLineEnable = FALSE;
.RasterizerState.DepthClipEnable = TRUE, psodesc.RasterizerState.ForcedSampleCount = 0;
.RasterizerState.MultisampleEnable = FALSE, psodesc.RasterizerState.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
.RasterizerState.AntialiasedLineEnable = FALSE, psodesc.DepthStencilState.DepthEnable = FALSE;
.RasterizerState.ForcedSampleCount = 0, psodesc.DepthStencilState.StencilEnable = FALSE;
.RasterizerState.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF, psodesc.InputLayout.pInputElementDescs = inputElementDesc;
.DepthStencilState.DepthEnable = FALSE, psodesc.InputLayout.NumElements = countof(inputElementDesc);
.DepthStencilState.StencilEnable = FALSE, psodesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
.InputLayout.pInputElementDescs = inputElementDesc, psodesc.NumRenderTargets = 1;
.InputLayout.NumElements = countof(inputElementDesc), psodesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE, psodesc.SampleDesc.Count = 1;
.NumRenderTargets = 1,
.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM,
.SampleDesc.Count = 1,
};
D3D12CreateGraphicsPipelineState(d3d12->device, &psodesc, &d3d12->pipe.handle); D3D12CreateGraphicsPipelineState(d3d12->device, &psodesc, &d3d12->pipe.handle);
} }
@ -497,21 +469,16 @@ bool d3d12_init_pipeline(d3d12_video_t* d3d12)
D3D12_GPU_VIRTUAL_ADDRESS D3D12_GPU_VIRTUAL_ADDRESS
d3d12_create_buffer(D3D12Device device, UINT size_in_bytes, D3D12Resource* buffer) d3d12_create_buffer(D3D12Device device, UINT size_in_bytes, D3D12Resource* buffer)
{ {
static const D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
.Type = D3D12_HEAP_TYPE_UPLOAD, D3D12_MEMORY_POOL_UNKNOWN, 1, 1 };
.CreationNodeMask = 1, D3D12_RESOURCE_DESC resource_desc = { D3D12_RESOURCE_DIMENSION_BUFFER };
.VisibleNodeMask = 1,
};
D3D12_RESOURCE_DESC resource_desc = { resource_desc.Width = size_in_bytes;
.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER, resource_desc.Height = 1;
.Width = size_in_bytes, resource_desc.DepthOrArraySize = 1;
.Height = 1, resource_desc.MipLevels = 1;
.DepthOrArraySize = 1, resource_desc.SampleDesc.Count = 1;
.MipLevels = 1, resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
.SampleDesc.Count = 1,
.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
};
D3D12CreateCommittedResource( D3D12CreateCommittedResource(
device, (D3D12_HEAP_PROPERTIES*)&heap_props, D3D12_HEAP_FLAG_NONE, &resource_desc, device, (D3D12_HEAP_PROPERTIES*)&heap_props, D3D12_HEAP_FLAG_NONE, &resource_desc,
@ -530,12 +497,14 @@ void d3d12_init_texture(
Release(texture->upload_buffer); Release(texture->upload_buffer);
{ {
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_DEFAULT, D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
D3D12_MEMORY_POOL_UNKNOWN, 1, 1 };
texture->desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; texture->desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
texture->desc.DepthOrArraySize = 1; texture->desc.DepthOrArraySize = 1;
texture->desc.MipLevels = 1; texture->desc.MipLevels = 1;
texture->desc.SampleDesc.Count = 1; texture->desc.SampleDesc.Count = 1;
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_DEFAULT, 0, 0, 1, 1 };
D3D12CreateCommittedResource( D3D12CreateCommittedResource(
device, &heap_props, D3D12_HEAP_FLAG_NONE, &texture->desc, device, &heap_props, D3D12_HEAP_FLAG_NONE, &texture->desc,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, NULL, &texture->handle); D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, NULL, &texture->handle);
@ -546,16 +515,16 @@ void d3d12_init_texture(
&texture->row_size_in_bytes, &texture->total_bytes); &texture->row_size_in_bytes, &texture->total_bytes);
{ {
D3D12_RESOURCE_DESC buffer_desc = { D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER, D3D12_MEMORY_POOL_UNKNOWN, 1, 1 };
.Width = texture->total_bytes, D3D12_RESOURCE_DESC buffer_desc = { D3D12_RESOURCE_DIMENSION_BUFFER };
.Height = 1,
.DepthOrArraySize = 1, buffer_desc.Width = texture->total_bytes;
.MipLevels = 1, buffer_desc.Height = 1;
.SampleDesc.Count = 1, buffer_desc.DepthOrArraySize = 1;
.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR, buffer_desc.MipLevels = 1;
}; buffer_desc.SampleDesc.Count = 1;
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, 0, 0, 1, 1 }; buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
D3D12CreateCommittedResource( D3D12CreateCommittedResource(
device, &heap_props, D3D12_HEAP_FLAG_NONE, &buffer_desc, device, &heap_props, D3D12_HEAP_FLAG_NONE, &buffer_desc,
@ -563,15 +532,15 @@ void d3d12_init_texture(
} }
{ {
D3D12_CPU_DESCRIPTOR_HANDLE handle; D3D12_CPU_DESCRIPTOR_HANDLE handle;
D3D12_SHADER_RESOURCE_VIEW_DESC view_desc = { 0 }; D3D12_SHADER_RESOURCE_VIEW_DESC view_desc = { DXGI_FORMAT_UNKNOWN };
view_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; view_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
view_desc.Format = texture->desc.Format; view_desc.Format = texture->desc.Format;
view_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; view_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
view_desc.Texture2D.MipLevels = texture->desc.MipLevels; view_desc.Texture2D.MipLevels = texture->desc.MipLevels;
handle.ptr = heap->cpu.ptr + heap_index * heap->stride; handle.ptr = heap->cpu.ptr + heap_index * heap->stride;
D3D12CreateShaderResourceView(device, texture->handle, &view_desc, handle); D3D12CreateShaderResourceView(device, texture->handle, &view_desc, handle);
texture->gpu_descriptor.ptr = heap->gpu.ptr + heap_index * heap->stride; texture->gpu_descriptor.ptr = heap->gpu.ptr + heap_index * heap->stride;
@ -583,9 +552,9 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd, d3d12_texture_t* texture
D3D12_TEXTURE_COPY_LOCATION src = { 0 }; D3D12_TEXTURE_COPY_LOCATION src = { 0 };
D3D12_TEXTURE_COPY_LOCATION dst = { 0 }; D3D12_TEXTURE_COPY_LOCATION dst = { 0 };
src.pResource = texture->upload_buffer; src.pResource = texture->upload_buffer;
src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
src.PlacedFootprint = texture->layout; src.PlacedFootprint = texture->layout;
dst.pResource = texture->handle; dst.pResource = texture->handle;
dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
@ -631,10 +600,10 @@ void d3d12_create_fullscreen_quad_vbo(
DXGI_FORMAT d3d12_get_closest_match( DXGI_FORMAT d3d12_get_closest_match(
D3D12Device device, DXGI_FORMAT desired_format, D3D12_FORMAT_SUPPORT1 desired_format_support) D3D12Device device, DXGI_FORMAT desired_format, D3D12_FORMAT_SUPPORT1 desired_format_support)
{ {
DXGI_FORMAT default_list[] = {desired_format, DXGI_FORMAT_UNKNOWN}; DXGI_FORMAT default_list[] = { desired_format, DXGI_FORMAT_UNKNOWN };
DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired_format); DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired_format);
if(!format) if (!format)
format = default_list; format = default_list;
while (*format != DXGI_FORMAT_UNKNOWN) while (*format != DXGI_FORMAT_UNKNOWN)

12
gfx/common/d3d12_common.h
View File

@ -1365,10 +1365,10 @@ typedef struct
enum enum
{ {
ROOT_INDEX_TEXTURE_TABLE = 0, ROOT_ID_TEXTURE_T = 0,
ROOT_INDEX_SAMPLER_TABLE, ROOT_ID_SAMPLER_T,
ROOT_INDEX_UBO, ROOT_ID_UBO,
ROOT_INDEX_MAX, ROOT_ID_MAX,
} root_signature_parameter_index_t; } root_signature_parameter_index_t;
typedef enum { typedef enum {
@ -1420,13 +1420,13 @@ static INLINE void d3d12_resource_transition(
static INLINE void d3d12_set_texture(D3D12GraphicsCommandList cmd, const d3d12_texture_t* texture) static INLINE void d3d12_set_texture(D3D12GraphicsCommandList cmd, const d3d12_texture_t* texture)
{ {
D3D12SetGraphicsRootDescriptorTable(cmd, ROOT_INDEX_TEXTURE_TABLE, texture->gpu_descriptor); D3D12SetGraphicsRootDescriptorTable(cmd, ROOT_ID_TEXTURE_T, texture->gpu_descriptor);
} }
static INLINE void static INLINE void
d3d12_set_sampler(D3D12GraphicsCommandList cmd, D3D12_GPU_DESCRIPTOR_HANDLE sampler) d3d12_set_sampler(D3D12GraphicsCommandList cmd, D3D12_GPU_DESCRIPTOR_HANDLE sampler)
{ {
D3D12SetGraphicsRootDescriptorTable(cmd, ROOT_INDEX_SAMPLER_TABLE, sampler); D3D12SetGraphicsRootDescriptorTable(cmd, ROOT_ID_SAMPLER_T, sampler);
} }
static INLINE void d3d12_update_texture( static INLINE void d3d12_update_texture(

2
gfx/common/d3dcompiler_common.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <stdio.h> #include <stdio.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H

4
gfx/common/dxgi_common.c
View File

@ -143,8 +143,8 @@ DXGI_FORMAT* dxgi_get_format_fallback_list(DXGI_FORMAT format)
((src_bs == dst_bs && src_bb == dst_bb) || !dst_bb) && \ ((src_bs == dst_bs && src_bb == dst_bb) || !dst_bb) && \
((src_as == dst_as && src_ab == dst_ab) || !dst_ab)) \ ((src_as == dst_as && src_ab == dst_ab) || !dst_ab)) \
{ \ { \
const UINT8* in = src_data; \ const UINT8* in = (const UINT8*)src_data; \
UINT8* out = dst_data; \ UINT8* out = (UINT8*)dst_data; \
for (i = 0; i < height; i++) \ for (i = 0; i < height; i++) \
{ \ { \
memcpy(out, in, width * sizeof(src_type)); \ memcpy(out, in, width * sizeof(src_type)); \

10
gfx/common/dxgi_common.h
View File

@ -247,17 +247,9 @@
#endif #endif
#endif #endif
#if !defined(__cplusplus) || defined(CINTERFACE)
#ifndef COM_RELEASE_DECLARED #ifndef COM_RELEASE_DECLARED
#define COM_RELEASE_DECLARED #define COM_RELEASE_DECLARED
#if defined(__cplusplus) && !defined(CINTERFACE)
static INLINE ULONG Release(IUnknown* object)
{
if (object)
return object->Release();
return 0;
}
#else
static INLINE ULONG Release(void* object) static INLINE ULONG Release(void* object)
{ {
if (object) if (object)

2
gfx/display_servers/dispserv_win32.c
View File

@ -85,7 +85,7 @@ static void* win32_display_server_init(void)
if (!SUCCEEDED(hr)) if (!SUCCEEDED(hr))
{ {
g_taskbarList = false; g_taskbarList = NULL;
RARCH_ERR("[dispserv]: CoCreateInstance of ITaskbarList3 failed.\n"); RARCH_ERR("[dispserv]: CoCreateInstance of ITaskbarList3 failed.\n");
} }
#endif #endif

2
gfx/drivers/d3d10.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <assert.h> #include <assert.h>
#include <string/stdstring.h> #include <string/stdstring.h>

137
gfx/drivers/d3d11.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <assert.h> #include <assert.h>
#include <string/stdstring.h> #include <string/stdstring.h>
@ -39,7 +41,7 @@
static void d3d11_set_filtering(void* data, unsigned index, bool smooth) static void d3d11_set_filtering(void* data, unsigned index, bool smooth)
{ {
unsigned i; unsigned i;
d3d11_video_t* d3d11 = (d3d11_video_t*)data; d3d11_video_t* d3d11 = (d3d11_video_t*)data;
for (i = 0; i < RARCH_WRAP_MAX; i++) for (i = 0; i < RARCH_WRAP_MAX; i++)
@ -141,8 +143,9 @@ static void d3d11_free_shader_preset(d3d11_video_t* d3d11)
static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path) static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path)
{ {
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS) #if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
unsigned i; unsigned i;
d3d11_video_t* d3d11 = (d3d11_video_t*)data; d3d11_texture_t* source;
d3d11_video_t* d3d11 = (d3d11_video_t*)data;
if (!d3d11) if (!d3d11)
return false; return false;
@ -171,8 +174,7 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
video_shader_resolve_relative(d3d11->shader_preset, path); video_shader_resolve_relative(d3d11->shader_preset, path);
d3d11_texture_t* source = &d3d11->frame.texture[0]; source = &d3d11->frame.texture[0];
for (i = 0; i < d3d11->shader_preset->passes; source = &d3d11->pass[i++].rt) for (i = 0; i < d3d11->shader_preset->passes; source = &d3d11->pass[i++].rt)
{ {
unsigned j; unsigned j;
@ -219,16 +221,16 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
/* clang-format on */ /* clang-format on */
if (!slang_process( if (!slang_process(
d3d11->shader_preset, i, RARCH_SHADER_HLSL, 50, &semantics_map, d3d11->shader_preset, i, RARCH_SHADER_HLSL, 50, &semantics_map,
&d3d11->pass[i].semantics)) &d3d11->pass[i].semantics))
goto error; goto error;
{ {
static const D3D11_INPUT_ELEMENT_DESC desc[] = { static const D3D11_INPUT_ELEMENT_DESC desc[] = {
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d11_vertex_t, position), { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d11_vertex_t, position),
D3D11_INPUT_PER_VERTEX_DATA, 0 }, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d11_vertex_t, texcoord), { "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d11_vertex_t, texcoord),
D3D11_INPUT_PER_VERTEX_DATA, 0 }, D3D11_INPUT_PER_VERTEX_DATA, 0 },
}; };
#ifdef DEBUG #ifdef DEBUG
bool save_hlsl = true; bool save_hlsl = true;
@ -253,13 +255,13 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
strncpy(ps_path + base_len, ps_ext, sizeof(ps_ext)); strncpy(ps_path + base_len, ps_ext, sizeof(ps_ext));
if (!d3d11_init_shader( if (!d3d11_init_shader(
d3d11->device, vs_src, 0, vs_path, "main", NULL, NULL, desc, countof(desc), d3d11->device, vs_src, 0, vs_path, "main", NULL, NULL, desc, countof(desc),
&d3d11->pass[i].shader)) &d3d11->pass[i].shader))
save_hlsl = true; save_hlsl = true;
if (!d3d11_init_shader( if (!d3d11_init_shader(
d3d11->device, ps_src, 0, ps_path, NULL, "main", NULL, NULL, 0, d3d11->device, ps_src, 0, ps_path, NULL, "main", NULL, NULL, 0,
&d3d11->pass[i].shader)) &d3d11->pass[i].shader))
save_hlsl = true; save_hlsl = true;
if (save_hlsl) if (save_hlsl)
@ -342,7 +344,7 @@ error:
static void d3d11_gfx_free(void* data) static void d3d11_gfx_free(void* data)
{ {
unsigned i; unsigned i;
d3d11_video_t* d3d11 = (d3d11_video_t*)data; d3d11_video_t* d3d11 = (d3d11_video_t*)data;
if (!d3d11) if (!d3d11)
@ -400,7 +402,7 @@ static void d3d11_gfx_free(void* data)
static void* static void*
d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** input_data) d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** input_data)
{ {
unsigned i; unsigned i;
WNDCLASSEX wndclass = { 0 }; WNDCLASSEX wndclass = { 0 };
MONITORINFOEX current_mon; MONITORINFOEX current_mon;
HMONITOR hm_to_use; HMONITOR hm_to_use;
@ -436,25 +438,25 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
{ {
UINT flags = 0; UINT flags = 0;
D3D_FEATURE_LEVEL requested_feature_level = D3D_FEATURE_LEVEL_11_0; D3D_FEATURE_LEVEL requested_feature_level = D3D_FEATURE_LEVEL_11_0;
DXGI_SWAP_CHAIN_DESC desc = { DXGI_SWAP_CHAIN_DESC desc = { 0 };
.BufferCount = 1,
.BufferDesc.Width = d3d11->vp.full_width, desc.BufferCount = 1;
.BufferDesc.Height = d3d11->vp.full_height, desc.BufferDesc.Width = d3d11->vp.full_width;
.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM, desc.BufferDesc.Height = d3d11->vp.full_height;
.BufferDesc.RefreshRate.Numerator = 60, desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
.BufferDesc.RefreshRate.Denominator = 1, desc.BufferDesc.RefreshRate.Numerator = 60;
.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT, desc.BufferDesc.RefreshRate.Denominator = 1;
.OutputWindow = main_window.hwnd, desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
.SampleDesc.Count = 1, desc.OutputWindow = main_window.hwnd;
.SampleDesc.Quality = 0, desc.SampleDesc.Count = 1;
.Windowed = TRUE, desc.SampleDesc.Quality = 0;
.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL, desc.Windowed = TRUE;
desc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
#if 0 #if 0
.SwapEffect = DXGI_SWAP_EFFECT_DISCARD, desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL, desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD, desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
#endif #endif
};
#ifdef DEBUG #ifdef DEBUG
flags |= D3D11_CREATE_DEVICE_DEBUG; flags |= D3D11_CREATE_DEVICE_DEBUG;
@ -508,12 +510,12 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
d3d11_gfx_set_rotation(d3d11, 0); d3d11_gfx_set_rotation(d3d11, 0);
{ {
D3D11_SAMPLER_DESC desc = { D3D11_SAMPLER_DESC desc = { D3D11_FILTER_MIN_MAG_MIP_POINT };
.MaxAnisotropy = 1, desc.MaxAnisotropy = 1;
.ComparisonFunc = D3D11_COMPARISON_NEVER, desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
.MinLOD = -D3D11_FLOAT32_MAX, desc.MinLOD = -D3D11_FLOAT32_MAX;
.MaxLOD = D3D11_FLOAT32_MAX, desc.MaxLOD = D3D11_FLOAT32_MAX;
};
/* Initialize samplers */ /* Initialize samplers */
for (i = 0; i < RARCH_WRAP_MAX; i++) for (i = 0; i < RARCH_WRAP_MAX; i++)
{ {
@ -557,11 +559,11 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
}; };
{ {
D3D11_BUFFER_DESC desc = { D3D11_BUFFER_DESC desc = { 0 };
.Usage = D3D11_USAGE_IMMUTABLE, desc.Usage = D3D11_USAGE_IMMUTABLE;
.ByteWidth = sizeof(vertices), desc.ByteWidth = sizeof(vertices);
.BindFlags = D3D11_BIND_VERTEX_BUFFER, desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
};
D3D11_SUBRESOURCE_DATA vertexData = { vertices }; D3D11_SUBRESOURCE_DATA vertexData = { vertices };
D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->frame.vbo); D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->frame.vbo);
desc.Usage = D3D11_USAGE_DYNAMIC; desc.Usage = D3D11_USAGE_DYNAMIC;
@ -691,21 +693,18 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
} }
{ {
D3D11_BLEND_DESC blend_desc = { D3D11_BLEND_DESC blend_desc = { 0 };
.AlphaToCoverageEnable = FALSE,
.IndependentBlendEnable = FALSE, blend_desc.AlphaToCoverageEnable = FALSE;
.RenderTarget[0] = blend_desc.IndependentBlendEnable = FALSE;
{ blend_desc.RenderTarget[0].BlendEnable = TRUE;
.BlendEnable = TRUE, blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
D3D11_BLEND_SRC_ALPHA, blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
D3D11_BLEND_INV_SRC_ALPHA, blend_desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
D3D11_BLEND_OP_ADD, blend_desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
D3D11_BLEND_SRC_ALPHA, blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
D3D11_BLEND_INV_SRC_ALPHA, blend_desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
D3D11_BLEND_OP_ADD, blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
D3D11_COLOR_WRITE_ENABLE_ALL,
},
};
D3D11CreateBlendState(d3d11->device, &blend_desc, &d3d11->blend_enable); D3D11CreateBlendState(d3d11->device, &blend_desc, &d3d11->blend_enable);
blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
@ -716,10 +715,11 @@ d3d11_gfx_init(const video_info_t* video, const input_driver_t** input, void** i
D3D11CreateBlendState(d3d11->device, &blend_desc, &d3d11->blend_disable); D3D11CreateBlendState(d3d11->device, &blend_desc, &d3d11->blend_disable);
} }
{ {
D3D11_RASTERIZER_DESC desc = { D3D11_RASTERIZER_DESC desc = { 0 };
.FillMode = D3D11_FILL_SOLID,
.CullMode = D3D11_CULL_NONE, desc.FillMode = D3D11_FILL_SOLID;
}; desc.CullMode = D3D11_CULL_NONE;
D3D11CreateRasterizerState(d3d11->device, &desc, &d3d11->state); D3D11CreateRasterizerState(d3d11->device, &desc, &d3d11->state);
} }
D3D11SetState(d3d11->context, d3d11->state); D3D11SetState(d3d11->context, d3d11->state);
@ -873,8 +873,8 @@ static bool d3d11_gfx_frame(
const char* msg, const char* msg,
video_frame_info_t* video_info) video_frame_info_t* video_info)
{ {
unsigned i; unsigned i;
d3d11_texture_t* texture = NULL; d3d11_texture_t* texture = NULL;
d3d11_video_t* d3d11 = (d3d11_video_t*)data; d3d11_video_t* d3d11 = (d3d11_video_t*)data;
D3D11DeviceContext context = d3d11->context; D3D11DeviceContext context = d3d11->context;
@ -883,7 +883,7 @@ static bool d3d11_gfx_frame(
D3D11Texture2D backBuffer; D3D11Texture2D backBuffer;
Release(d3d11->renderTargetView); Release(d3d11->renderTargetView);
DXGIResizeBuffers(d3d11->swapChain, 0, 0, 0, 0, 0); DXGIResizeBuffers(d3d11->swapChain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
DXGIGetSwapChainBufferD3D11(d3d11->swapChain, 0, &backBuffer); DXGIGetSwapChainBufferD3D11(d3d11->swapChain, 0, &backBuffer);
D3D11CreateTexture2DRenderTargetView( D3D11CreateTexture2DRenderTargetView(
@ -1176,8 +1176,9 @@ static bool d3d11_gfx_read_viewport(void* data, uint8_t* buffer, bool is_idle)
static void d3d11_set_menu_texture_frame( static void d3d11_set_menu_texture_frame(
void* data, const void* frame, bool rgb32, unsigned width, unsigned height, float alpha) void* data, const void* frame, bool rgb32, unsigned width, unsigned height, float alpha)
{ {
d3d11_video_t* d3d11 = (d3d11_video_t*)data; d3d11_video_t* d3d11 = (d3d11_video_t*)data;
DXGI_FORMAT format = rgb32 ? DXGI_FORMAT_B8G8R8A8_UNORM : DXGI_FORMAT_EX_A4R4G4B4_UNORM; DXGI_FORMAT format =
rgb32 ? DXGI_FORMAT_B8G8R8A8_UNORM : (DXGI_FORMAT)DXGI_FORMAT_EX_A4R4G4B4_UNORM;
if (d3d11->menu.texture.desc.Width != width || d3d11->menu.texture.desc.Height != height) if (d3d11->menu.texture.desc.Width != width || d3d11->menu.texture.desc.Height != height)
{ {
@ -1247,7 +1248,7 @@ static uintptr_t d3d11_gfx_load_texture(
if (!d3d11) if (!d3d11)
return 0; return 0;
texture = (d3d11_texture_t*)calloc(1, sizeof(*texture)); texture = (d3d11_texture_t*)calloc(1, sizeof(*texture));
if (!texture) if (!texture)
return 0; return 0;

6
gfx/drivers/d3d12.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <assert.h> #include <assert.h>
#include <string/stdstring.h> #include <string/stdstring.h>
@ -236,7 +238,7 @@ static bool d3d12_gfx_frame(
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, &d3d12->frame.scissorRect); D3D12RSSetScissorRects(d3d12->queue.cmd, 1, &d3d12->frame.scissorRect);
D3D12SetGraphicsRootConstantBufferView( D3D12SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, ROOT_INDEX_UBO, d3d12->frame.ubo_view.BufferLocation); d3d12->queue.cmd, ROOT_ID_UBO, d3d12->frame.ubo_view.BufferLocation);
d3d12_set_texture(d3d12->queue.cmd, &d3d12->frame.texture); d3d12_set_texture(d3d12->queue.cmd, &d3d12->frame.texture);
d3d12_set_sampler(d3d12->queue.cmd, d3d12->frame.sampler); d3d12_set_sampler(d3d12->queue.cmd, d3d12->frame.sampler);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->frame.vbo_view); D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->frame.vbo_view);
@ -248,7 +250,7 @@ static bool d3d12_gfx_frame(
d3d12_upload_texture(d3d12->queue.cmd, &d3d12->menu.texture); d3d12_upload_texture(d3d12->queue.cmd, &d3d12->menu.texture);
D3D12SetGraphicsRootConstantBufferView( D3D12SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, ROOT_INDEX_UBO, d3d12->ubo_view.BufferLocation); d3d12->queue.cmd, ROOT_ID_UBO, d3d12->ubo_view.BufferLocation);
if (d3d12->menu.fullscreen) if (d3d12->menu.fullscreen)
{ {

2
gfx/drivers_font/d3d11_font.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <malloc.h> #include <malloc.h>

1
libretro-common/streams/file_stream.c
View File

@ -31,6 +31,7 @@
#endif #endif
#include <streams/file_stream.h> #include <streams/file_stream.h>
#define VFS_FRONTEND
#include <vfs/vfs_implementation.h> #include <vfs/vfs_implementation.h>
static const int64_t vfs_error_return_value = -1; static const int64_t vfs_error_return_value = -1;

28
menu/drivers_display/menu_display_d3d11.c
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>. * If not, see <http://www.gnu.org/licenses/>.
*/ */
#define CINTERFACE
#include <retro_miscellaneous.h> #include <retro_miscellaneous.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
@ -80,12 +82,12 @@ static void menu_display_d3d11_draw(void* data)
{ {
D3D11_MAPPED_SUBRESOURCE mapped_vbo; D3D11_MAPPED_SUBRESOURCE mapped_vbo;
d3d11_sprite_t *v = NULL; d3d11_sprite_t* v = NULL;
D3D11MapBuffer( D3D11MapBuffer(
d3d11->context, d3d11->sprites.vbo, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped_vbo); d3d11->context, d3d11->sprites.vbo, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped_vbo);
v = (d3d11_sprite_t*)mapped_vbo.pData + d3d11->sprites.offset; v = (d3d11_sprite_t*)mapped_vbo.pData + d3d11->sprites.offset;
v->pos.x = draw->x / (float)d3d11->viewport.Width; v->pos.x = draw->x / (float)d3d11->viewport.Width;
v->pos.y = (d3d11->viewport.Height - draw->y - draw->height) / (float)d3d11->viewport.Height; v->pos.y = (d3d11->viewport.Height - draw->y - draw->height) / (float)d3d11->viewport.Height;
@ -139,15 +141,15 @@ static void menu_display_d3d11_draw_pipeline(void* data)
case VIDEO_SHADER_MENU: case VIDEO_SHADER_MENU:
case VIDEO_SHADER_MENU_2: case VIDEO_SHADER_MENU_2:
{ {
video_coord_array_t *ca = menu_display_get_coords_array(); video_coord_array_t* ca = menu_display_get_coords_array();
if (!d3d11->menu_pipeline_vbo) if (!d3d11->menu_pipeline_vbo)
{ {
D3D11_BUFFER_DESC desc = { D3D11_BUFFER_DESC desc = { 0 };
.Usage = D3D11_USAGE_IMMUTABLE, desc.Usage = D3D11_USAGE_IMMUTABLE;
.ByteWidth = ca->coords.vertices * 2 * sizeof(float), desc.ByteWidth = ca->coords.vertices * 2 * sizeof(float);
.BindFlags = D3D11_BIND_VERTEX_BUFFER, desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
};
D3D11_SUBRESOURCE_DATA vertexData = { ca->coords.vertex }; D3D11_SUBRESOURCE_DATA vertexData = { ca->coords.vertex };
D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->menu_pipeline_vbo); D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->menu_pipeline_vbo);
} }
@ -199,12 +201,12 @@ static bool menu_display_d3d11_font_init_first(
float font_size, float font_size,
bool is_threaded) bool is_threaded)
{ {
font_data_t** handle = (font_data_t**)font_handle; font_data_t** handle = (font_data_t**)font_handle;
font_data_t *new_handle = font_driver_init_first( font_data_t* new_handle = font_driver_init_first(
video_data, font_path, font_size, true, is_threaded, FONT_DRIVER_RENDER_D3D11_API); video_data, font_path, font_size, true, is_threaded, FONT_DRIVER_RENDER_D3D11_API);
if (!new_handle) if (!new_handle)
return false; return false;
*handle = new_handle; *handle = new_handle;
return true; return true;
} }

4
network/netplay/netplay_sync.c
View File

@ -426,8 +426,8 @@ bool netplay_resolve_input(netplay_t *netplay, size_t sim_ptr, bool resim)
{ {
/* Merge them */ /* Merge them */
/* Most devices have all the digital parts in the first word. */ /* Most devices have all the digital parts in the first word. */
static const uint32_t digital_common[3] = {-1, 0, 0}; static const uint32_t digital_common[3] = {~0u, 0u, 0u};
static const uint32_t digital_keyboard[5] = {-1, -1, -1, -1, -1}; static const uint32_t digital_keyboard[5] = {~0u, ~0u, ~0u, ~0u, ~0u};
const uint32_t *digital; const uint32_t *digital;
if (dtype == RETRO_DEVICE_KEYBOARD) if (dtype == RETRO_DEVICE_KEYBOARD)
digital = digital_keyboard; digital = digital_keyboard;

5
tasks/task_autodetect.c
View File

@ -50,8 +50,11 @@
#include <setupapi.h> #include <setupapi.h>
#include <hidsdi.h> #include <hidsdi.h>
#ifndef __cplusplus
/* Why doesn't including cguid.h work to get a GUID_NULL instead? */ /* Why doesn't including cguid.h work to get a GUID_NULL instead? */
#ifdef __cplusplus
EXTERN_C __attribute__((weak))
const GUID GUID_NULL = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
#else
__attribute__((weak)) __attribute__((weak))
const GUID GUID_NULL = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}}; const GUID GUID_NULL = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
#endif #endif