Commit 87029a3f6979c79c65f9828bf886d01dcd94b936 - DiligentCore

+2

-1

CMakeLists.txt less more

198	198	# For msvc, enable level 4 warnings except for
199	199	# - w4100 - unreferenced formal parameter
200	200	# - w4505 - unreferenced local function has been removed
201		target_compile_options(Diligent-BuildSettings INTERFACE /W4 /wd4100 /wd4505)
	201	# - w4201 - nonstandard extension used: nameless struct/union
	202	target_compile_options(Diligent-BuildSettings INTERFACE /W4 /wd4100 /wd4505 /wd4201)
202	203	# In all release modes also:
203	204	# - disable w4189 - local variable is initialized but not referenced
204	205	# - Disable RTTI (/GR-)

+27

-20

Graphics/GraphicsEngine/interface/LoadEngineDll.h less more

29	29	/// \file
30	30	/// Helper function to load engine DLL on Windows
31	31
32		#include <sstream>
	32	#include <stdlib.h>
	33	#include <stdio.h>
	34
	35	#include "../../../Primitives/interface/CommonDefinitions.h"
33	36
34	37	#if PLATFORM_UNIVERSAL_WINDOWS
35		# include "../../../Common/interface/StringTools.h"
	38	# include "../../../Common/interface/StringTools.hpp"
36	39	#endif
37	40
38	41	#ifndef NOMINMAX

40	43	#endif
41	44	#include <Windows.h>
42	45
43		namespace Diligent
44		{
	46	DILIGENT_BEGIN_NAMESPACE(Diligent)
45	47
46	48	inline FARPROC LoadEngineDll(const char* EngineName, const char* GetFactoryFuncName)
47	49	{
48		std::string LibName = EngineName;
	50	const size_t StringBufferSize = 4096;
	51	char* LibName = (char*)malloc(StringBufferSize);
	52	FARPROC GetFactoryFunc = NULL;
	53	HMODULE hModule = NULL;
49	54
	55	// clang-format off
50	56	#if _WIN64
51		LibName += "_64";
	57	const char* Arch = "_64";
52	58	#else
53		LibName += "_32";
	59	const char* Arch = "_32";
54	60	#endif
55	61
56	62	#ifdef _DEBUG
57		LibName += "d";
	63	const char* Conf = "d";
58	64	#else
59		LibName += "r";
	65	const char* Conf = "r";
60	66	#endif
61	67
62		LibName += ".dll";
	68	sprintf_s(LibName, StringBufferSize, "%s%s%s.dll", EngineName, Conf, Arch);
63	69
64	70	#if PLATFORM_WIN32
65		auto hModule = LoadLibraryA(LibName.c_str());
	71	hModule = LoadLibraryA(LibName);
66	72	#elif PLATFORM_UNIVERSAL_WINDOWS
67		auto hModule = LoadPackagedLibrary(WidenString(LibName).c_str(), 0);
	73	hModule = LoadPackagedLibrary(WidenString(LibName).c_str(), 0);
68	74	#else
69	75	# error Unexpected platform
70	76	#endif
	77	// clang-format on
71	78
72	79	if (hModule == NULL)
73	80	{
74		std::stringstream ss;
75		ss << "Failed to load " << LibName << " library.\n";
76		OutputDebugStringA(ss.str().c_str());
	81	printf("Failed to load %s library.\n", LibName);
	82	OutputDebugStringA("Failed to load engine DLL");
	83	free(LibName);
77	84	return NULL;
78	85	}
79	86
80		auto GetFactoryFunc = GetProcAddress(hModule, GetFactoryFuncName);
	87	GetFactoryFunc = GetProcAddress(hModule, GetFactoryFuncName);
81	88	if (GetFactoryFunc == NULL)
82	89	{
83		std::stringstream ss;
84		ss << "Failed to load " << GetFactoryFuncName << " function from " << LibName << " library.\n";
85		OutputDebugStringA(ss.str().c_str());
	90	printf("Failed to load %s function from %s library.\n", GetFactoryFuncName, LibName);
	91	OutputDebugStringA("Failed to load engine factory function from library");
86	92	FreeLibrary(hModule);
87	93	}
88	94
	95	free(LibName);
89	96	return GetFactoryFunc;
90	97	}
91	98
92		} // namespace Diligent
	99	DILIGENT_END_NAMESPACE // namespace Diligent

+30

-4

Graphics/GraphicsEngineD3D11/interface/BufferD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/Buffer.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {4A696D2E-44BB-4C4B-9DE2-3AF7C94DCFC0}
38		static constexpr INTERFACE_ID IID_BufferD3D11 =
	37	static const struct INTERFACE_ID IID_BufferD3D11 =
39	38	{0x4a696d2e, 0x44bb, 0x4c4b, {0x9d, 0xe2, 0x3a, 0xf7, 0xc9, 0x4d, 0xcf, 0xc0}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a buffer object.
42	43	class IBufferD3D11 : public IBuffer

49	50	virtual ID3D11Buffer* GetD3D11Buffer() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53	#else
	54
	55	struct IBufferD3D11Methods
	56	{
	57	ID3D11Buffer* (*GetD3D11Buffer)();
	58	};
	59
	60
	61	struct IBufferD3D11Vtbl
	62	{
	63	struct IObjectMethods Object;
	64	struct IDeviceObjectMethods DeviceObject;
	65	struct IBufferMethods Buffer;
	66	struct IBufferD3D11Methods BufferD3D11;
	67	};
	68
	69	struct IBufferD3D11
	70	{
	71	struct IBufferD3D11Vtbl* pVtbl;
	72	};
	73
	74	# define IBufferD3D11_GetD3D11Buffer(This) (This)->pVtbl->BufferD3D11.GetD3D11Buffer((struct IBufferD3D11*)(This))
	75
	76	#endif
	77
	78	DILIGENT_END_NAMESPACE // namespace Diligent

+30

-4

Graphics/GraphicsEngineD3D11/interface/BufferViewD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/BufferView.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
	35
	36	#if DILIGENT_CPP_INTERFACE
36	37
37	38	// {6ABA95FC-CD7D-4C03-8CAE-AFC45F9696B7}
38		static constexpr INTERFACE_ID IID_BufferViewD3D11 =
	39	static const struct INTERFACE_ID IID_BufferViewD3D11 =
39	40	{0x6aba95fc, 0xcd7d, 0x4c03, {0x8c, 0xae, 0xaf, 0xc4, 0x5f, 0x96, 0x96, 0xb7}};
40	41
41	42	/// Exposes Direct3D11-specific functionality of a buffer view object.

49	50	virtual ID3D11View* GetD3D11View() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53	#else
	54
	55	struct IBufferViewD3D11Methods
	56	{
	57	ID3D11View* (*GetD3D11View)();
	58	};
	59
	60
	61	struct IBufferViewD3D11Vtbl
	62	{
	63	struct IObjectMethods Object;
	64	struct IDeviceObjectMethods DeviceObject;
	65	struct IBufferViewMethods BufferView;
	66	struct IBufferViewD3D11Methods BufferViewD3D11;
	67	};
	68
	69	struct IBufferViewD3D11
	70	{
	71	struct IBufferViewD3D11Vtbl* pVtbl;
	72	};
	73
	74	# define IBufferViewD3D11_GetD3D11View(This) (This)->pVtbl->BufferViewD3D11.GetD3D11View((struct IBufferViewD3D11*)(This))
	75
	76	#endif
	77
	78	DILIGENT_END_NAMESPACE // namespace Diligent

+29

-4

Graphics/GraphicsEngineD3D11/interface/DeviceContextD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/DeviceContext.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {F0EE0335-C8AB-4EC1-BB15-B8EE5F003B99}
38		static constexpr INTERFACE_ID IID_DeviceContextD3D11 =
	37	static const struct INTERFACE_ID IID_DeviceContextD3D11 =
39	38	{0xf0ee0335, 0xc8ab, 0x4ec1, {0xbb, 0x15, 0xb8, 0xee, 0x5f, 0x0, 0x3b, 0x99}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a device context.
42	43	class IDeviceContextD3D11 : public IDeviceContext

49	50	virtual ID3D11DeviceContext* GetD3D11DeviceContext() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53	#else
	54
	55	struct IDeviceContextD3D11Methods
	56	{
	57	ID3D11DeviceContext* (*GetD3D11DeviceContext)();
	58	};
	59
	60	struct IDeviceContextD3D11Vtbl
	61	{
	62	struct IObjectMethods Object;
	63	struct IDeviceObjectMethods DeviceObject;
	64	struct IDeviceContextMethods DeviceContext;
	65	struct IDeviceContextD3D11Methods DeviceContextD3D11;
	66	};
	67
	68	struct IDeviceContextD3D11
	69	{
	70	struct IDeviceContextD3D11Vtbl* pVtbl;
	71	};
	72
	73	# define IDeviceContextD3D11_GetD3D11DeviceContext(This) (This)->pVtbl->DeviceContextD3D11.GetD3D11DeviceContext((struct IDeviceContextD3D11*)(This))
	74
	75	#endif
	76
	77	DILIGENT_END_NAMESPACE // namespace Diligent

+77

-12

Graphics/GraphicsEngineD3D11/interface/EngineFactoryD3D11.h less more

38	38	# include "../../GraphicsEngine/interface/LoadEngineDll.h"
39	39	#endif
40	40
41		namespace Diligent
42		{
	41	DILIGENT_BEGIN_NAMESPACE(Diligent)
43	42
44	43	// {62663A30-AAF0-4A9A-9729-9EAC6BF789F2}
45		static const INTERFACE_ID IID_EngineFactoryD3D11 =
	44	static const struct INTERFACE_ID IID_EngineFactoryD3D11 =
46	45	{0x62663a30, 0xaaf0, 0x4a9a, {0x97, 0x29, 0x9e, 0xac, 0x6b, 0xf7, 0x89, 0xf2}};
	46
	47	#if DILIGENT_CPP_INTERFACE
47	48
48	49	/// Engine factory for Direct3D11 rendering backend.
49	50	class IEngineFactoryD3D11 : public IEngineFactory

141	142	DisplayModeAttribs* DisplayModes) = 0;
142	143	};
143	144
	145	#else
	146
	147	struct IEngineFactoryD3D11;
	148
	149	struct IEngineFactoryD3D11Methods
	150	{
	151	void (CreateDeviceAndContextsD3D11)(struct IEngineFactoryD3D11,
	152	const struct EngineD3D11CreateInfo* EngineCI,
	153	class IRenderDevice** ppDevice,
	154	class IDeviceContext** ppContexts);
	155
	156	void (CreateSwapChainD3D11)(struct IEngineFactoryD3D11,
	157	class IRenderDevice* pDevice,
	158	class IDeviceContext* pImmediateContext,
	159	const struct SwapChainDesc* SCDesc,
	160	const struct FullScreenModeDesc* FSDesc,
	161	void* pNativeWndHandle,
	162	class ISwapChain** ppSwapChain);
	163
	164	void (AttachToD3D11Device)(struct IEngineFactoryD3D11,
	165	void* pd3d11NativeDevice,
	166	void* pd3d11ImmediateContext,
	167	const struct EngineD3D11CreateInfo* EngineCI,
	168	class IRenderDevice** ppDevice,
	169	class IDeviceContext** ppContexts);
	170
	171	void (EnumerateAdapters)(struct IEngineFactoryD3D11,
	172	DIRECT3D_FEATURE_LEVEL MinFeatureLevel,
	173	Uint32* NumAdapters,
	174	struct AdapterAttribs* Adapters);
	175
	176
	177	void (EnumerateDisplayModes)(struct IEngineFactoryD3D11,
	178	DIRECT3D_FEATURE_LEVEL MinFeatureLevel,
	179	Uint32 AdapterId,
	180	Uint32 OutputId,
	181	TEXTURE_FORMAT Format,
	182	Uint32* NumDisplayModes,
	183	struct DisplayModeAttribs* DisplayModes);
	184	};
	185
	186	struct IEngineFactoryD3D11Vtbl
	187	{
	188	struct IObjectMethods Object;
	189	struct IEngineFactoryMethods EngineFactory;
	190	struct IEngineFactoryD3D11Methods EngineFactoryD3D11;
	191	};
	192
	193	struct IEngineFactoryD3D11
	194	{
	195	struct IEngineFactoryD3D11Vtbl* pVtbl;
	196	};
	197
	198	// clang-format off
	199
	200	# define IEngineFactoryD3D11_CreateDeviceAndContextsD3D11(This, ...) (This)->pVtbl->EngineFactoryD3D11.CreateDeviceAndContextsD3D11((struct IEngineFactoryD3D11*)(This), __VA_ARGS__)
	201	# define IEngineFactoryD3D11_CreateSwapChainD3D11(This, ...) (This)->pVtbl->EngineFactoryD3D11.CreateSwapChainD3D11 ((struct IEngineFactoryD3D11*)(This), __VA_ARGS__)
	202	# define IEngineFactoryD3D11_AttachToD3D11Device(This, ...) (This)->pVtbl->EngineFactoryD3D11.AttachToD3D11Device ((struct IEngineFactoryD3D11*)(This), __VA_ARGS__)
	203	# define IEngineFactoryD3D11_EnumerateAdapters(This, ...) (This)->pVtbl->EngineFactoryD3D11.EnumerateAdapters ((struct IEngineFactoryD3D11*)(This), __VA_ARGS__)
	204	# define IEngineFactoryD3D11_EnumerateDisplayModes(This, ...) (This)->pVtbl->EngineFactoryD3D11.EnumerateDisplayModes ((struct IEngineFactoryD3D11*)(This), __VA_ARGS__)
	205
	206	// clang-format on
	207
	208	#endif
	209
	210
144	211	#if ENGINE_DLL
145	212
146		using GetEngineFactoryD3D11Type = IEngineFactoryD3D11* (*)();
147
148		static bool LoadGraphicsEngineD3D11(GetEngineFactoryD3D11Type& GetFactoryFunc)
149		{
150		auto ProcAddress = LoadEngineDll("GraphicsEngineD3D11", "GetEngineFactoryD3D11");
151		GetFactoryFunc = reinterpret_cast<GetEngineFactoryD3D11Type>(ProcAddress);
152		return GetFactoryFunc != nullptr;
	213	typedef class IEngineFactoryD3D11* (*GetEngineFactoryD3D11Type)();
	214
	215	inline GetEngineFactoryD3D11Type LoadGraphicsEngineD3D11()
	216	{
	217	return (GetEngineFactoryD3D11Type)LoadEngineDll("GraphicsEngineD3D11", "GetEngineFactoryD3D11");
153	218	}
154	219
155	220	#else
156	221
157		IEngineFactoryD3D11* GetEngineFactoryD3D11();
	222	class IEngineFactoryD3D11* DILIGENT_GLOBAL_FUNCTION(GetEngineFactoryD3D11)();
158	223
159	224	#endif
160	225
161		} // namespace Diligent
	226	DILIGENT_END_NAMESPACE // namespace Diligent

+25

-4

Graphics/GraphicsEngineD3D11/interface/FenceD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/Fence.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {45F2BE28-652B-4180-B6E4-E75F83F63CC7}
38		static constexpr INTERFACE_ID IID_FenceD3D11 =
	37	static const struct INTERFACE_ID IID_FenceD3D11 =
39	38	{0x45f2be28, 0x652b, 0x4180, {0xb6, 0xe4, 0xe7, 0x5f, 0x83, 0xf6, 0x3c, 0xc7}};
40	39
	40	#if DILIGENT_CPP_INTERFACE
41	41
42	42	/// Exposes Direct3D11-specific functionality of a fence object.
43	43	class IFenceD3D11 : public IFence
44	44	{
45	45	};
46	46
47		} // namespace Diligent
	47	#else
	48
	49	//struct IFenceD3D11Methods
	50	//{
	51	//};
	52
	53	struct IFenceD3D11Vtbl
	54	{
	55	struct IObjectMethods Object;
	56	struct IDeviceObjectMethods DeviceObject;
	57	struct IFenceMethods Fence;
	58	//struct IFenceD3D11Methods FenceD3D11;
	59	};
	60
	61	struct IFenceD3D11
	62	{
	63	struct IFenceD3D11Vtbl* pVtbl;
	64	};
	65
	66	#endif
	67
	68	DILIGENT_END_NAMESPACE // namespace Diligent

+57

-4

Graphics/GraphicsEngineD3D11/interface/PipelineStateD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/PipelineState.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {3EA6E3F4-9966-47FC-8CE8-0EB3E2273061}
38		static constexpr INTERFACE_ID IID_PipelineStateD3D11 =
	37	static const struct INTERFACE_ID IID_PipelineStateD3D11 =
39	38	{0x3ea6e3f4, 0x9966, 0x47fc, {0x8c, 0xe8, 0xe, 0xb3, 0xe2, 0x27, 0x30, 0x61}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a pipeline state object.
42	43	class IPipelineStateD3D11 : public IPipelineState

106	107	virtual ID3D11ComputeShader* GetD3D11ComputeShader() = 0;
107	108	};
108	109
109		} // namespace Diligent
	110	#else
	111
	112	// clang-format off
	113
	114	struct IPipelineStateD3D11;
	115
	116	struct IPipelineStateD3D11Methods
	117	{
	118	ID3D11BlendState* (GetD3D11BlendState) (struct IPipelineStateD3D11);
	119	ID3D11RasterizerState* (GetD3D11RasterizerState) (struct IPipelineStateD3D11);
	120	ID3D11DepthStencilState(GetD3D11DepthStencilState)(struct IPipelineStateD3D11*);
	121	ID3D11InputLayout* (GetD3D11InputLayout) (struct IPipelineStateD3D11);
	122	ID3D11VertexShader* (GetD3D11VertexShader) (struct IPipelineStateD3D11);
	123	ID3D11PixelShader* (GetD3D11PixelShader) (struct IPipelineStateD3D11);
	124	ID3D11GeometryShader* (GetD3D11GeometryShader) (struct IPipelineStateD3D11);
	125	ID3D11DomainShader* (GetD3D11DomainShader) (struct IPipelineStateD3D11);
	126	ID3D11HullShader* (GetD3D11HullShader) (struct IPipelineStateD3D11);
	127	ID3D11ComputeShader* (GetD3D11ComputeShader) (struct IPipelineStateD3D11);
	128	};
	129
	130	// clang-format on
	131
	132	struct IPipelineStateD3D11Vtbl
	133	{
	134	struct IObjectMethods Object;
	135	struct IDeviceObjectMethods DeviceObject;
	136	struct IPipelineStateMethods PipelineState;
	137	struct IPipelineStateD3D11Methods PipelineStateD3D11;
	138	};
	139
	140	struct IPipelineStateD3D11
	141	{
	142	struct IPipelineStateD3D11Vtbl* pVtbl;
	143	};
	144
	145	// clang-format off
	146
	147	# define IPipelineStateD3D11_GetD3D11BlendState(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11BlendState ((struct IPipelineStateD3D11*)(This))
	148	# define IPipelineStateD3D11_GetD3D11RasterizerState(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11RasterizerState ((struct IPipelineStateD3D11*)(This))
	149	# define IPipelineStateD3D11_GetD3D11DepthStencilState(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11DepthStencilState((struct IPipelineStateD3D11*)(This))
	150	# define IPipelineStateD3D11_GetD3D11InputLayout(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11InputLayout ((struct IPipelineStateD3D11*)(This))
	151	# define IPipelineStateD3D11_GetD3D11VertexShader(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11VertexShader ((struct IPipelineStateD3D11*)(This))
	152	# define IPipelineStateD3D11_GetD3D11PixelShader(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11PixelShader ((struct IPipelineStateD3D11*)(This))
	153	# define IPipelineStateD3D11_GetD3D11GeometryShader(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11GeometryShader ((struct IPipelineStateD3D11*)(This))
	154	# define IPipelineStateD3D11_GetD3D11DomainShader(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11DomainShader ((struct IPipelineStateD3D11*)(This))
	155	# define IPipelineStateD3D11_GetD3D11HullShader(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11HullShader ((struct IPipelineStateD3D11*)(This))
	156	# define IPipelineStateD3D11_GetD3D11ComputeShader(This) (This)->pVtbl->PipelineStateD3D11.GetD3D11ComputeShader ((struct IPipelineStateD3D11*)(This))
	157
	158	// clang-format on
	159
	160	#endif
	161
	162	DILIGENT_END_NAMESPACE // namespace Diligent

+29

-4

Graphics/GraphicsEngineD3D11/interface/QueryD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/Query.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {77D95EAA-D16E-43F4-B0EB-BEBCD2EC8C57}
38		static constexpr INTERFACE_ID IID_QueryD3D11 =
	37	static const struct INTERFACE_ID IID_QueryD3D11 =
39	38	{0x77d95eaa, 0xd16e, 0x43f4, {0xb0, 0xeb, 0xbe, 0xbc, 0xd2, 0xec, 0x8c, 0x57}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a Query object.
42	43	class IQueryD3D11 : public IQuery

45	46	virtual ID3D11Query* GetD3D11Query() = 0;
46	47	};
47	48
48		} // namespace Diligent
	49	#else
	50
	51	struct IQueryD3D11Methods
	52	{
	53	ID3D11Query* (*GetD3D11Query)();
	54	};
	55
	56	struct IQueryD3D11Vtbl
	57	{
	58	struct IObjectMethods Object;
	59	struct IDeviceObjectMethods DeviceObject;
	60	struct IQueryMethods Query;
	61	struct IQueryD3D11Methods QueryD3D11;
	62	};
	63
	64	struct IQueryD3D11
	65	{
	66	struct IQueryD3D11Vtbl* pVtbl;
	67	};
	68
	69	# define IQueryD3D11_GetD3D11Query(This) (This)->pVtbl->QueryD3D11.GetD3D11Query((struct IQueryD3D11*)(This))
	70
	71	#endif
	72
	73	DILIGENT_END_NAMESPACE // namespace Diligent

+11

-4

Graphics/GraphicsEngineD3D11/interface/RenderDeviceD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/RenderDevice.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {05B1CBB8-FCAD-49EE-BADA-7801223EC3FE}
38		static constexpr INTERFACE_ID IID_RenderDeviceD3D11 =
	37	static const struct INTERFACE_ID IID_RenderDeviceD3D11 =
39	38	{0x5b1cbb8, 0xfcad, 0x49ee, {0xba, 0xda, 0x78, 0x1, 0x22, 0x3e, 0xc3, 0xfe}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a render device.
42	43	class IRenderDeviceD3D11 : public IRenderDevice

102	103	ITexture** ppTexture) = 0;
103	104	};
104	105
105		} // namespace Diligent
	106	#else
	107
	108
	109
	110	#endif
	111
	112	DILIGENT_END_NAMESPACE // namespace Diligent

+29

-4

Graphics/GraphicsEngineD3D11/interface/SamplerD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/Sampler.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {31A3BFAF-738E-4D8C-AD18-B021C5D948DD}
38		static constexpr INTERFACE_ID IID_SamplerD3D11 =
	37	static const struct INTERFACE_ID IID_SamplerD3D11 =
39	38	{0x31a3bfaf, 0x738e, 0x4d8c, {0xad, 0x18, 0xb0, 0x21, 0xc5, 0xd9, 0x48, 0xdd}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a sampler object.
42	43	class ISamplerD3D11 : public ISampler

49	50	virtual ID3D11SamplerState* GetD3D11SamplerState() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53	#else
	54
	55	struct ISamplerD3D11Methods
	56	{
	57	ID3D11SamplerState* (*GetD3D11Sampler)();
	58	};
	59
	60	struct ISamplerD3D11Vtbl
	61	{
	62	struct IObjectMethods Object;
	63	struct IDeviceObjectMethods DeviceObject;
	64	//struct ISamplerMethods Sampler;
	65	struct ISamplerD3D11Methods SamplerD3D11;
	66	};
	67
	68	struct ISamplerD3D11
	69	{
	70	struct ISamplerD3D11Vtbl* pVtbl;
	71	};
	72
	73	# define ISamplerD3D11_GetD3D11Sampler(This) (This)->pVtbl->SamplerD3D11.GetD3D11Sampler((struct ISamplerD3D11*)(This))
	74
	75	#endif
	76
	77	DILIGENT_END_NAMESPACE // namespace Diligent

+29

-4

Graphics/GraphicsEngineD3D11/interface/ShaderD3D11.h less more

31	31
32	32	#include "../../GraphicsEngineD3DBase/interface/ShaderD3D.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {C513E83E-B037-405B-8B49-BF8F5C220DEE}
38		static constexpr INTERFACE_ID IID_ShaderD3D11 =
	37	static const struct INTERFACE_ID IID_ShaderD3D11 =
39	38	{0xc513e83e, 0xb037, 0x405b, {0x8b, 0x49, 0xbf, 0x8f, 0x5c, 0x22, 0xd, 0xee}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a shader object.
42	43	class IShaderD3D11 : public IShaderD3D

49	50	virtual ID3D11DeviceChild* GetD3D11Shader() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53	#else
	54
	55	struct IShaderD3D11Methods
	56	{
	57	ID3D11DeviceChild* (*GetD3D11Shader)();
	58	};
	59
	60	struct IShaderD3D11Vtbl
	61	{
	62	struct IObjectMethods Object;
	63	struct IDeviceObjectMethods DeviceObject;
	64	struct IShaderMethods Shader;
	65	struct IShaderD3D11Methods ShaderD3D11;
	66	};
	67
	68	struct IShaderD3D11
	69	{
	70	struct IShaderD3D11Vtbl* pVtbl;
	71	};
	72
	73	# define IShaderD3D11_GetD3D11Shader(This) (This)->pVtbl->ShaderD3D11.GetD3D11Shader((struct IShaderD3D11*)(This))
	74
	75	#endif
	76
	77	DILIGENT_END_NAMESPACE // namespace Diligent

+9

-4

Graphics/GraphicsEngineD3D11/interface/ShaderResourceBindingD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/ShaderResourceBinding.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
36	35
37	36	// {97A6D4AC-D4AF-4AA9-B46C-67417B89026A}
38		static constexpr INTERFACE_ID IID_ShaderResourceBindingD3D11 =
	37	static const struct INTERFACE_ID IID_ShaderResourceBindingD3D11 =
39	38	{0x97a6d4ac, 0xd4af, 0x4aa9, {0xb4, 0x6c, 0x67, 0x41, 0x7b, 0x89, 0x2, 0x6a}};
	39
	40	#if DILIGENT_CPP_INTERFACE
40	41
41	42	/// Exposes Direct3D11-specific functionality of a shader resource binding object.
42	43	class IShaderResourceBindingD3D11 : public IShaderResourceBinding
43	44	{
44	45	};
45	46
46		} // namespace Diligent
	47	#else
	48
	49	#endif
	50
	51	DILIGENT_END_NAMESPACE // namespace Diligent

+9

-4

Graphics/GraphicsEngineD3D11/interface/SwapChainD3D11.h less more

32	32	#include "../../GraphicsEngine/interface/SwapChain.h"
33	33	#include "TextureViewD3D11.h"
34	34
35		namespace Diligent
36		{
	35	DILIGENT_BEGIN_NAMESPACE(Diligent)
37	36
38	37	// {4DAF2E76-9204-4DC4-A53A-B00097412D3A}
39		static constexpr INTERFACE_ID IID_SwapChainD3D11 =
	38	static const struct INTERFACE_ID IID_SwapChainD3D11 =
40	39	{0x4daf2e76, 0x9204, 0x4dc4, {0xa5, 0x3a, 0xb0, 0x0, 0x97, 0x41, 0x2d, 0x3a}};
	40
	41	#if DILIGENT_CPP_INTERFACE
41	42
42	43	/// Exposes Direct3D11-specific functionality of a swap chain.
43	44	class ISwapChainD3D11 : public ISwapChain

56	57	virtual IDXGISwapChain* GetDXGISwapChain() = 0;
57	58	};
58	59
59		} // namespace Diligent
	60	#else
	61
	62	#endif
	63
	64	DILIGENT_END_NAMESPACE // namespace Diligent

+29

-3

Graphics/GraphicsEngineD3D11/interface/TextureD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/Texture.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
	35
	36	#if DILIGENT_CPP_INTERFACE
36	37
37	38	// {F3A84CC2-E485-4E72-A08A-437D7FFBA3AB}
38	39	static constexpr INTERFACE_ID IID_TextureD3D11 =

49	50	virtual ID3D11Resource* GetD3D11Texture() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53	#else
	54
	55	struct ITextureD3D11Methods
	56	{
	57	ID3D11Resource* (*GetD3D11Texture)();
	58	};
	59
	60
	61	struct ITextureD3D11Vtbl
	62	{
	63	struct IObjectMethods Object;
	64	struct IDeviceObjectMethods DeviceObject;
	65	struct ITextureMethods Texture;
	66	struct ITextureD3D11Methods TextureD3D11;
	67	};
	68
	69	struct ITextureD3D11
	70	{
	71	struct ITextureD3D11Vtbl* pVtbl;
	72	};
	73
	74	# define ITextureD3D11_GetD3D11Texture(This) (This)->pVtbl->TextureD3D11.GetD3D11Texture((struct ITextureD3D11*)(This))
	75
	76	#endif
	77
	78	DILIGENT_END_NAMESPACE // namespace Diligent

+30

-3

Graphics/GraphicsEngineD3D11/interface/TextureViewD3D11.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/TextureView.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
	35
	36	#if DILIGENT_CPP_INTERFACE
36	37
37	38	// {0767EBE4-AD47-4E70-9B65-38C6B9CAC37D}
38	39	static constexpr INTERFACE_ID IID_TextureViewD3D11 =

49	50	virtual ID3D11View* GetD3D11View() = 0;
50	51	};
51	52
52		} // namespace Diligent
	53
	54	#else
	55
	56	struct ITextureViewD3D11Methods
	57	{
	58	ID3D11View* (*GetD3D11View)();
	59	};
	60
	61
	62	struct ITextureViewD3D11Vtbl
	63	{
	64	struct IObjectMethods Object;
	65	struct IDeviceObjectMethods DeviceObject;
	66	struct ITextureViewMethods TextureView;
	67	struct ITextureViewD3D11Methods TextureViewD3D11;
	68	};
	69
	70	struct ITextureViewD3D11
	71	{
	72	struct ITextureViewD3D11Vtbl* pVtbl;
	73	};
	74
	75	# define ITextureViewD3D11_GetD3D11View(This) (This)->pVtbl->TextureViewD3D11.GetD3D11View((struct ITextureViewD3D11*)(This))
	76
	77	#endif
	78
	79	DILIGENT_END_NAMESPACE // namespace Diligent

+1

-2

Graphics/GraphicsEngineD3D11/readme.md less more

18	18
19	19	// Get pointer to the function that returns the factory
20	20	#if ENGINE_DLL
21		GetEngineFactoryD3D11Type GetEngineFactoryD3D11 = nullptr;
22	21	// Load the dll and import GetEngineFactoryD3D11() function
23		LoadGraphicsEngineD3D11(GetEngineFactoryD3D11);
	22	auto GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();
24	23	#endif
25	24	auto* pFactoryD3D11 = GetEngineFactoryD3D11();
26	25

+9

-1

Graphics/GraphicsEngineD3D11/src/EngineFactoryD3D11.cpp less more

323	323	/// x86 \| GraphicsEngineD3D11_32d.dll \| GraphicsEngineD3D11_32r.dll
324	324	/// x64 \| GraphicsEngineD3D11_64d.dll \| GraphicsEngineD3D11_64r.dll
325	325	///
326		void LoadGraphicsEngineD3D11(GetEngineFactoryD3D11Type& GetFactoryFunc)
	326	GetEngineFactoryD3D11Type LoadGraphicsEngineD3D11()
327	327	{
328	328	// This function is only required because DoxyGen refuses to generate documentation for a static function when SHOW_FILES==NO
329	329	# error This function must never be compiled;

337	337	}
338	338
339	339	} // namespace Diligent
	340
	341	extern "C"
	342	{
	343	Diligent::IEngineFactoryD3D11* Diligent_GetEngineFactoryD3D11()
	344	{
	345	return Diligent::GetEngineFactoryD3D11();
	346	}
	347	}

+17

-7

Graphics/GraphicsEngineD3DBase/interface/ShaderD3D.h less more

31	31
32	32	#include "../../GraphicsEngine/interface/Shader.h"
33	33
34		namespace Diligent
35		{
	34	DILIGENT_BEGIN_NAMESPACE(Diligent)
	35
36	36
37	37	// {1EA0898C-1612-457F-B74E-808843D2CBE3}
38		static constexpr INTERFACE_ID IID_ShaderD3D =
	38	static const struct INTERFACE_ID IID_ShaderD3D =
39	39	{0x1ea0898c, 0x1612, 0x457f, {0xb7, 0x4e, 0x80, 0x88, 0x43, 0xd2, 0xcb, 0xe3}};
40	40
41	41
	42	// clang-format off
	43
42	44	/// HLSL resource description
43		struct HLSLShaderResourceDesc : ShaderResourceDesc
44		{
45		Uint32 ShaderRegister = 0;
	45	struct HLSLShaderResourceDesc DILIGENT_DERIVE(ShaderResourceDesc)
	46
	47	Uint32 ShaderRegister DEFAULT_INITIALIZER(0);
46	48	};
	49
	50	// clang-format on
	51
	52	#if DILIGENT_CPP_INTERFACE
47	53
48	54	/// Exposes Direct3D-specific functionality of a shader object.
49	55	class IShaderD3D : public IShader

53	59	virtual HLSLShaderResourceDesc GetHLSLResource(Uint32 Index) const = 0;
54	60	};
55	61
56		} // namespace Diligent
	62	#else
	63
	64	#endif
	65
	66	DILIGENT_END_NAMESPACE // namespace Diligent

+5

-0

Primitives/interface/CommonDefinitions.h less more

52	52
53	53	# define DEFAULT_INITIALIZER(x)
54	54
	55	# define DILIGENT_GLOBAL_FUNCTION(FuncName) Diligent_##FuncName
	56
55	57	#else
56	58
57	59	# define DILIGENT_BEGIN_NAMESPACE(Name) \
58	60	namespace Name \
59	61	{
	62
60	63	# define DILIGENT_END_NAMESPACE }
61	64
62	65	# define DILIGENT_TYPED_ENUM(EnumName, EnumType) enum EnumName : EnumType

65	68	{
66	69
67	70	# define DEFAULT_INITIALIZER(x) = x
	71
	72	# define DILIGENT_GLOBAL_FUNCTION(FuncName) FuncName
68	73
69	74	#endif
70	75

+1

-2

Tests/DiligentCoreAPITest/src/TestingEnvironment.cpp less more

122	122	case RENDER_DEVICE_TYPE_D3D11:
123	123	{
124	124	# if ENGINE_DLL
125		GetEngineFactoryD3D11Type GetEngineFactoryD3D11 = nullptr;
126	125	// Load the dll and import GetEngineFactoryD3D11() function
127		LoadGraphicsEngineD3D11(GetEngineFactoryD3D11);
	126	auto GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();
128	127	if (GetEngineFactoryD3D11 == nullptr)
129	128	{
130	129	LOG_ERROR_AND_THROW("Failed to load the engine");

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/BufferD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/BufferD3D11.h"
	29
	30	void TestBufferD3D11_CInterface(struct IBufferD3D11* pBuffer)
	31	{
	32	ID3D11Buffer* pd3d11Buffer = IBufferD3D11_GetD3D11Buffer(pBuffer);
	33	(void)pd3d11Buffer;
	34	}

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/BufferViewD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/BufferViewD3D11.h"
	29
	30	void TestBufferViewD3D11_CInterface(struct IBufferViewD3D11* pView)
	31	{
	32	ID3D11View* pd3d11View = IBufferViewD3D11_GetD3D11View(pView);
	33	(void)pd3d11View;
	34	}

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/DeviceContextD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/DeviceContextD3D11.h"
	29
	30	void TestDeviceContextD3D11_CInterface(struct IDeviceContextD3D11* pView)
	31	{
	32	ID3D11DeviceContext* pd3d11Ctx = IDeviceContextD3D11_GetD3D11DeviceContext(pView);
	33	(void)pd3d11Ctx;
	34	}

+65

-0

Tests/IncludeTest/GraphicsEngineD3D11/EngineFactoryD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#ifndef NOMINMAX
	28	# define NOMINMAX
	29	#endif
	30	#include <Windows.h>
	31
	32	#ifndef ENGINE_DLL
	33	# define ENGINE_DLL 1
	34	#endif
	35
	36	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/EngineFactoryD3D11.h"
	37
	38	void TestEngineFactoryD3D11CInterface()
	39	{
	40	GetEngineFactoryD3D11Type GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();
	41	class IEngineFactoryD3D11* pFactory = GetEngineFactoryD3D11();
	42	struct EngineD3D11CreateInfo EngineCI = {0};
	43	class IRenderDevice* pDevice = NULL;
	44	class IDeviceContext* pCtx = NULL;
	45	IEngineFactoryD3D11_CreateDeviceAndContextsD3D11(pFactory, &EngineCI, &pDevice, &pCtx);
	46
	47	struct SwapChainDesc SCDesc = {0};
	48	struct FullScreenModeDesc FSDes = {0};
	49	void* pNativeWndHandle = NULL;
	50	class ISwapChain* pSwapChain = NULL;
	51	IEngineFactoryD3D11_CreateSwapChainD3D11(pFactory, pDevice, pCtx, &SCDesc, &FSDes, pNativeWndHandle, &pSwapChain);
	52
	53	void* pd3d11NativeDevice = NULL;
	54	void* pd3d11ImmediateContext = NULL;
	55	IEngineFactoryD3D11_AttachToD3D11Device(pFactory, pd3d11NativeDevice, pd3d11ImmediateContext, &EngineCI, &pDevice, &pCtx);
	56
	57	Uint32 NumAdapters = 0;
	58	struct AdapterAttribs* Adapters = NULL;
	59	IEngineFactoryD3D11_EnumerateAdapters(pFactory, DIRECT3D_FEATURE_LEVEL_11_0, &NumAdapters, Adapters);
	60
	61	Uint32 NumDisplayModes = 0;
	62	struct DisplayModeAttribs* DisplayModes = NULL;
	63	IEngineFactoryD3D11_EnumerateDisplayModes(pFactory, DIRECT3D_FEATURE_LEVEL_11_0, 0, 0, TEX_FORMAT_RGBA8_UNORM, &NumDisplayModes, DisplayModes);
	64	}

+29

-0

Tests/IncludeTest/GraphicsEngineD3D11/FenceD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/FenceD3D11.h"

+53

-0

Tests/IncludeTest/GraphicsEngineD3D11/PipelineStateD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/PipelineStateD3D11.h"
	29
	30	void TestPipelineStateD3D11CInterface(struct IPipelineStateD3D11* pPSO)
	31	{
	32	ID3D11BlendState* pBlendState = IPipelineStateD3D11_GetD3D11BlendState(pPSO);
	33	ID3D11RasterizerState* pRasterizerState = IPipelineStateD3D11_GetD3D11RasterizerState(pPSO);
	34	ID3D11DepthStencilState* pDepthStencilState = IPipelineStateD3D11_GetD3D11DepthStencilState(pPSO);
	35	ID3D11InputLayout* pInputLayot = IPipelineStateD3D11_GetD3D11InputLayout(pPSO);
	36	ID3D11VertexShader* pVS = IPipelineStateD3D11_GetD3D11VertexShader(pPSO);
	37	ID3D11PixelShader* pPS = IPipelineStateD3D11_GetD3D11PixelShader(pPSO);
	38	ID3D11GeometryShader* pGS = IPipelineStateD3D11_GetD3D11GeometryShader(pPSO);
	39	ID3D11DomainShader* pDS = IPipelineStateD3D11_GetD3D11DomainShader(pPSO);
	40	ID3D11HullShader* pHS = IPipelineStateD3D11_GetD3D11HullShader(pPSO);
	41	ID3D11ComputeShader* pCS = IPipelineStateD3D11_GetD3D11ComputeShader(pPSO);
	42	(void)pBlendState;
	43	(void)pRasterizerState;
	44	(void)pDepthStencilState;
	45	(void)pInputLayot;
	46	(void)pVS;
	47	(void)pPS;
	48	(void)pGS;
	49	(void)pDS;
	50	(void)pHS;
	51	(void)pCS;
	52	}

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/QueryD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/QueryD3D11.h"
	29
	30	void TestQueryD3D11_CInterface(struct IQueryD3D11* pQuery)
	31	{
	32	ID3D11Query* pd3d11Query = IQueryD3D11_GetD3D11Query(pQuery);
	33	(void)pd3d11Query;
	34	}

+29

-0

Tests/IncludeTest/GraphicsEngineD3D11/QueryD3D11H_test.cpp less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/QueryD3D11.h"

+29

-0

Tests/IncludeTest/GraphicsEngineD3D11/RenderDeviceD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/RenderDeviceD3D11.h"

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/SamplerD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26
	27	#include <d3d11.h>
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/SamplerD3D11.h"
	29
	30	void TestSamplerD3D11_CInterface(struct ISamplerD3D11* pSampler)
	31	{
	32	ID3D11SamplerState* pd3d11Sampler = ISamplerD3D11_GetD3D11Sampler(pSampler);
	33	(void)pd3d11Sampler;
	34	}

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/ShaderD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26	#include <d3d11.h>
	27
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/ShaderD3D11.h"
	29
	30	void TestShaderD3D11_CInterface(struct IShaderD3D11* pShader)
	31	{
	32	ID3D11DeviceChild* pd3d11Shader = IShaderD3D11_GetD3D11Shader(pShader);
	33	(void)pd3d11Shader;
	34	}

+29

-0

Tests/IncludeTest/GraphicsEngineD3D11/ShaderResourceBindingD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26	#include <d3d11.h>
	27
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/ShaderResourceBindingD3D11.h"

+28

-0

Tests/IncludeTest/GraphicsEngineD3D11/SwapChainD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26	#include <d3d11.h>
	27	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/SwapChainD3D11.h"⏎

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/TextureD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26	#include <d3d11.h>
	27
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/TextureD3D11.h"
	29
	30	void TestTextureD3D11_CInterface(struct ITextureD3D11* pTexture)
	31	{
	32	ID3D11Resource* pd3d11Texture = ITextureD3D11_GetD3D11Texture(pTexture);
	33	(void)pd3d11Texture;
	34	}

+35

-0

Tests/IncludeTest/GraphicsEngineD3D11/TextureViewD3D11H_test.c less more

	0	/*
	1	* Copyright 2019-2020 Diligent Graphics LLC
	2	* Copyright 2015-2019 Egor Yusov
	3	*
	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
	15	*
	16	* In no event and under no legal theory, whether in tort (including negligence),
	17	* contract, or otherwise, unless required by applicable law (such as deliberate
	18	* and grossly negligent acts) or agreed to in writing, shall any Contributor be
	19	* liable for any damages, including any direct, indirect, special, incidental,
	20	* or consequential damages of any character arising as a result of this License or
	21	* out of the use or inability to use the software (including but not limited to damages
	22	* for loss of goodwill, work stoppage, computer failure or malfunction, or any and
	23	* all other commercial damages or losses), even if such Contributor has been advised
	24	* of the possibility of such damages.
	25	*/
	26	#include <d3d11.h>
	27
	28	#include "DiligentCore/Graphics/GraphicsEngineD3D11/interface/TextureViewD3D11.h"
	29
	30	void TestTextureViewD3D11_CInterface(struct ITextureViewD3D11* pView)
	31	{
	32	struct ID3D11View* pd3d11View = ITextureViewD3D11_GetD3D11View(pView);
	33	(void)pd3d11View;
	34	}