git.s-ol.nu forks/DiligentCore / 87029a3
Implemented D3D11 engine C interface (mostly) assiduous 3 years ago
36 changed file(s) with 1027 addition(s) and 95 deletion(s). Raw diff Collapse all Expand all
198198 # For msvc, enable level 4 warnings except for
199199 # - w4100 - unreferenced formal parameter
200200 # - 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)
202203 # In all release modes also:
203204 # - disable w4189 - local variable is initialized but not referenced
204205 # - Disable RTTI (/GR-)
2929 /// \file
3030 /// Helper function to load engine DLL on Windows
3131
32 #include <sstream>
32 #include <stdlib.h>
33 #include <stdio.h>
34
35 #include "../../../Primitives/interface/CommonDefinitions.h"
3336
3437 #if PLATFORM_UNIVERSAL_WINDOWS
35 # include "../../../Common/interface/StringTools.h"
38 # include "../../../Common/interface/StringTools.hpp"
3639 #endif
3740
3841 #ifndef NOMINMAX
4043 #endif
4144 #include <Windows.h>
4245
43 namespace Diligent
44 {
46 DILIGENT_BEGIN_NAMESPACE(Diligent)
4547
4648 inline FARPROC LoadEngineDll(const char* EngineName, const char* GetFactoryFuncName)
4749 {
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;
4954
55 // clang-format off
5056 #if _WIN64
51 LibName += "_64";
57 const char* Arch = "_64";
5258 #else
53 LibName += "_32";
59 const char* Arch = "_32";
5460 #endif
5561
5662 #ifdef _DEBUG
57 LibName += "d";
63 const char* Conf = "d";
5864 #else
59 LibName += "r";
65 const char* Conf = "r";
6066 #endif
6167
62 LibName += ".dll";
68 sprintf_s(LibName, StringBufferSize, "%s%s%s.dll", EngineName, Conf, Arch);
6369
6470 #if PLATFORM_WIN32
65 auto hModule = LoadLibraryA(LibName.c_str());
71 hModule = LoadLibraryA(LibName);
6672 #elif PLATFORM_UNIVERSAL_WINDOWS
67 auto hModule = LoadPackagedLibrary(WidenString(LibName).c_str(), 0);
73 hModule = LoadPackagedLibrary(WidenString(LibName).c_str(), 0);
6874 #else
6975 # error Unexpected platform
7076 #endif
77 // clang-format on
7178
7279 if (hModule == NULL)
7380 {
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);
7784 return NULL;
7885 }
7986
80 auto GetFactoryFunc = GetProcAddress(hModule, GetFactoryFuncName);
87 GetFactoryFunc = GetProcAddress(hModule, GetFactoryFuncName);
8188 if (GetFactoryFunc == NULL)
8289 {
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");
8692 FreeLibrary(hModule);
8793 }
8894
95 free(LibName);
8996 return GetFactoryFunc;
9097 }
9198
92 } // namespace Diligent
99 DILIGENT_END_NAMESPACE // namespace Diligent
3131
3232 #include "../../GraphicsEngine/interface/Buffer.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {4A696D2E-44BB-4C4B-9DE2-3AF7C94DCFC0}
38 static constexpr INTERFACE_ID IID_BufferD3D11 =
37 static const struct INTERFACE_ID IID_BufferD3D11 =
3938 {0x4a696d2e, 0x44bb, 0x4c4b, {0x9d, 0xe2, 0x3a, 0xf7, 0xc9, 0x4d, 0xcf, 0xc0}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a buffer object.
4243 class IBufferD3D11 : public IBuffer
4950 virtual ID3D11Buffer* GetD3D11Buffer() = 0;
5051 };
5152
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
3131
3232 #include "../../GraphicsEngine/interface/BufferView.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
35
36 #if DILIGENT_CPP_INTERFACE
3637
3738 // {6ABA95FC-CD7D-4C03-8CAE-AFC45F9696B7}
38 static constexpr INTERFACE_ID IID_BufferViewD3D11 =
39 static const struct INTERFACE_ID IID_BufferViewD3D11 =
3940 {0x6aba95fc, 0xcd7d, 0x4c03, {0x8c, 0xae, 0xaf, 0xc4, 0x5f, 0x96, 0x96, 0xb7}};
4041
4142 /// Exposes Direct3D11-specific functionality of a buffer view object.
4950 virtual ID3D11View* GetD3D11View() = 0;
5051 };
5152
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
3131
3232 #include "../../GraphicsEngine/interface/DeviceContext.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {F0EE0335-C8AB-4EC1-BB15-B8EE5F003B99}
38 static constexpr INTERFACE_ID IID_DeviceContextD3D11 =
37 static const struct INTERFACE_ID IID_DeviceContextD3D11 =
3938 {0xf0ee0335, 0xc8ab, 0x4ec1, {0xbb, 0x15, 0xb8, 0xee, 0x5f, 0x0, 0x3b, 0x99}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a device context.
4243 class IDeviceContextD3D11 : public IDeviceContext
4950 virtual ID3D11DeviceContext* GetD3D11DeviceContext() = 0;
5051 };
5152
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
3838 # include "../../GraphicsEngine/interface/LoadEngineDll.h"
3939 #endif
4040
41 namespace Diligent
42 {
41 DILIGENT_BEGIN_NAMESPACE(Diligent)
4342
4443 // {62663A30-AAF0-4A9A-9729-9EAC6BF789F2}
45 static const INTERFACE_ID IID_EngineFactoryD3D11 =
44 static const struct INTERFACE_ID IID_EngineFactoryD3D11 =
4645 {0x62663a30, 0xaaf0, 0x4a9a, {0x97, 0x29, 0x9e, 0xac, 0x6b, 0xf7, 0x89, 0xf2}};
46
47 #if DILIGENT_CPP_INTERFACE
4748
4849 /// Engine factory for Direct3D11 rendering backend.
4950 class IEngineFactoryD3D11 : public IEngineFactory
141142 DisplayModeAttribs* DisplayModes) = 0;
142143 };
143144
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
144211 #if ENGINE_DLL
145212
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");
153218 }
154219
155220 #else
156221
157 IEngineFactoryD3D11* GetEngineFactoryD3D11();
222 class IEngineFactoryD3D11* DILIGENT_GLOBAL_FUNCTION(GetEngineFactoryD3D11)();
158223
159224 #endif
160225
161 } // namespace Diligent
226 DILIGENT_END_NAMESPACE // namespace Diligent
3131
3232 #include "../../GraphicsEngine/interface/Fence.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {45F2BE28-652B-4180-B6E4-E75F83F63CC7}
38 static constexpr INTERFACE_ID IID_FenceD3D11 =
37 static const struct INTERFACE_ID IID_FenceD3D11 =
3938 {0x45f2be28, 0x652b, 0x4180, {0xb6, 0xe4, 0xe7, 0x5f, 0x83, 0xf6, 0x3c, 0xc7}};
4039
40 #if DILIGENT_CPP_INTERFACE
4141
4242 /// Exposes Direct3D11-specific functionality of a fence object.
4343 class IFenceD3D11 : public IFence
4444 {
4545 };
4646
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
3131
3232 #include "../../GraphicsEngine/interface/PipelineState.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {3EA6E3F4-9966-47FC-8CE8-0EB3E2273061}
38 static constexpr INTERFACE_ID IID_PipelineStateD3D11 =
37 static const struct INTERFACE_ID IID_PipelineStateD3D11 =
3938 {0x3ea6e3f4, 0x9966, 0x47fc, {0x8c, 0xe8, 0xe, 0xb3, 0xe2, 0x27, 0x30, 0x61}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a pipeline state object.
4243 class IPipelineStateD3D11 : public IPipelineState
106107 virtual ID3D11ComputeShader* GetD3D11ComputeShader() = 0;
107108 };
108109
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
3131
3232 #include "../../GraphicsEngine/interface/Query.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {77D95EAA-D16E-43F4-B0EB-BEBCD2EC8C57}
38 static constexpr INTERFACE_ID IID_QueryD3D11 =
37 static const struct INTERFACE_ID IID_QueryD3D11 =
3938 {0x77d95eaa, 0xd16e, 0x43f4, {0xb0, 0xeb, 0xbe, 0xbc, 0xd2, 0xec, 0x8c, 0x57}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a Query object.
4243 class IQueryD3D11 : public IQuery
4546 virtual ID3D11Query* GetD3D11Query() = 0;
4647 };
4748
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
3131
3232 #include "../../GraphicsEngine/interface/RenderDevice.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {05B1CBB8-FCAD-49EE-BADA-7801223EC3FE}
38 static constexpr INTERFACE_ID IID_RenderDeviceD3D11 =
37 static const struct INTERFACE_ID IID_RenderDeviceD3D11 =
3938 {0x5b1cbb8, 0xfcad, 0x49ee, {0xba, 0xda, 0x78, 0x1, 0x22, 0x3e, 0xc3, 0xfe}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a render device.
4243 class IRenderDeviceD3D11 : public IRenderDevice
102103 ITexture** ppTexture) = 0;
103104 };
104105
105 } // namespace Diligent
106 #else
107
108
109
110 #endif
111
112 DILIGENT_END_NAMESPACE // namespace Diligent
3131
3232 #include "../../GraphicsEngine/interface/Sampler.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {31A3BFAF-738E-4D8C-AD18-B021C5D948DD}
38 static constexpr INTERFACE_ID IID_SamplerD3D11 =
37 static const struct INTERFACE_ID IID_SamplerD3D11 =
3938 {0x31a3bfaf, 0x738e, 0x4d8c, {0xad, 0x18, 0xb0, 0x21, 0xc5, 0xd9, 0x48, 0xdd}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a sampler object.
4243 class ISamplerD3D11 : public ISampler
4950 virtual ID3D11SamplerState* GetD3D11SamplerState() = 0;
5051 };
5152
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
3131
3232 #include "../../GraphicsEngineD3DBase/interface/ShaderD3D.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {C513E83E-B037-405B-8B49-BF8F5C220DEE}
38 static constexpr INTERFACE_ID IID_ShaderD3D11 =
37 static const struct INTERFACE_ID IID_ShaderD3D11 =
3938 {0xc513e83e, 0xb037, 0x405b, {0x8b, 0x49, 0xbf, 0x8f, 0x5c, 0x22, 0xd, 0xee}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a shader object.
4243 class IShaderD3D11 : public IShaderD3D
4950 virtual ID3D11DeviceChild* GetD3D11Shader() = 0;
5051 };
5152
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
3131
3232 #include "../../GraphicsEngine/interface/ShaderResourceBinding.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
3635
3736 // {97A6D4AC-D4AF-4AA9-B46C-67417B89026A}
38 static constexpr INTERFACE_ID IID_ShaderResourceBindingD3D11 =
37 static const struct INTERFACE_ID IID_ShaderResourceBindingD3D11 =
3938 {0x97a6d4ac, 0xd4af, 0x4aa9, {0xb4, 0x6c, 0x67, 0x41, 0x7b, 0x89, 0x2, 0x6a}};
39
40 #if DILIGENT_CPP_INTERFACE
4041
4142 /// Exposes Direct3D11-specific functionality of a shader resource binding object.
4243 class IShaderResourceBindingD3D11 : public IShaderResourceBinding
4344 {
4445 };
4546
46 } // namespace Diligent
47 #else
48
49 #endif
50
51 DILIGENT_END_NAMESPACE // namespace Diligent
3232 #include "../../GraphicsEngine/interface/SwapChain.h"
3333 #include "TextureViewD3D11.h"
3434
35 namespace Diligent
36 {
35 DILIGENT_BEGIN_NAMESPACE(Diligent)
3736
3837 // {4DAF2E76-9204-4DC4-A53A-B00097412D3A}
39 static constexpr INTERFACE_ID IID_SwapChainD3D11 =
38 static const struct INTERFACE_ID IID_SwapChainD3D11 =
4039 {0x4daf2e76, 0x9204, 0x4dc4, {0xa5, 0x3a, 0xb0, 0x0, 0x97, 0x41, 0x2d, 0x3a}};
40
41 #if DILIGENT_CPP_INTERFACE
4142
4243 /// Exposes Direct3D11-specific functionality of a swap chain.
4344 class ISwapChainD3D11 : public ISwapChain
5657 virtual IDXGISwapChain* GetDXGISwapChain() = 0;
5758 };
5859
59 } // namespace Diligent
60 #else
61
62 #endif
63
64 DILIGENT_END_NAMESPACE // namespace Diligent
3131
3232 #include "../../GraphicsEngine/interface/Texture.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
35
36 #if DILIGENT_CPP_INTERFACE
3637
3738 // {F3A84CC2-E485-4E72-A08A-437D7FFBA3AB}
3839 static constexpr INTERFACE_ID IID_TextureD3D11 =
4950 virtual ID3D11Resource* GetD3D11Texture() = 0;
5051 };
5152
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
3131
3232 #include "../../GraphicsEngine/interface/TextureView.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
35
36 #if DILIGENT_CPP_INTERFACE
3637
3738 // {0767EBE4-AD47-4E70-9B65-38C6B9CAC37D}
3839 static constexpr INTERFACE_ID IID_TextureViewD3D11 =
4950 virtual ID3D11View* GetD3D11View() = 0;
5051 };
5152
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
1818
1919 // Get pointer to the function that returns the factory
2020 #if ENGINE_DLL
21 GetEngineFactoryD3D11Type GetEngineFactoryD3D11 = nullptr;
2221 // Load the dll and import GetEngineFactoryD3D11() function
23 LoadGraphicsEngineD3D11(GetEngineFactoryD3D11);
22 auto GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();
2423 #endif
2524 auto* pFactoryD3D11 = GetEngineFactoryD3D11();
2625
323323 /// x86 | GraphicsEngineD3D11_32d.dll | GraphicsEngineD3D11_32r.dll
324324 /// x64 | GraphicsEngineD3D11_64d.dll | GraphicsEngineD3D11_64r.dll
325325 ///
326 void LoadGraphicsEngineD3D11(GetEngineFactoryD3D11Type& GetFactoryFunc)
326 GetEngineFactoryD3D11Type LoadGraphicsEngineD3D11()
327327 {
328328 // This function is only required because DoxyGen refuses to generate documentation for a static function when SHOW_FILES==NO
329329 # error This function must never be compiled;
337337 }
338338
339339 } // namespace Diligent
340
341 extern "C"
342 {
343 Diligent::IEngineFactoryD3D11* Diligent_GetEngineFactoryD3D11()
344 {
345 return Diligent::GetEngineFactoryD3D11();
346 }
347 }
3131
3232 #include "../../GraphicsEngine/interface/Shader.h"
3333
34 namespace Diligent
35 {
34 DILIGENT_BEGIN_NAMESPACE(Diligent)
35
3636
3737 // {1EA0898C-1612-457F-B74E-808843D2CBE3}
38 static constexpr INTERFACE_ID IID_ShaderD3D =
38 static const struct INTERFACE_ID IID_ShaderD3D =
3939 {0x1ea0898c, 0x1612, 0x457f, {0xb7, 0x4e, 0x80, 0x88, 0x43, 0xd2, 0xcb, 0xe3}};
4040
4141
42 // clang-format off
43
4244 /// 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);
4648 };
49
50 // clang-format on
51
52 #if DILIGENT_CPP_INTERFACE
4753
4854 /// Exposes Direct3D-specific functionality of a shader object.
4955 class IShaderD3D : public IShader
5359 virtual HLSLShaderResourceDesc GetHLSLResource(Uint32 Index) const = 0;
5460 };
5561
56 } // namespace Diligent
62 #else
63
64 #endif
65
66 DILIGENT_END_NAMESPACE // namespace Diligent
5252
5353 # define DEFAULT_INITIALIZER(x)
5454
55 # define DILIGENT_GLOBAL_FUNCTION(FuncName) Diligent_##FuncName
56
5557 #else
5658
5759 # define DILIGENT_BEGIN_NAMESPACE(Name) \
5860 namespace Name \
5961 {
62
6063 # define DILIGENT_END_NAMESPACE }
6164
6265 # define DILIGENT_TYPED_ENUM(EnumName, EnumType) enum EnumName : EnumType
6568 {
6669
6770 # define DEFAULT_INITIALIZER(x) = x
71
72 # define DILIGENT_GLOBAL_FUNCTION(FuncName) FuncName
6873
6974 #endif
7075
122122 case RENDER_DEVICE_TYPE_D3D11:
123123 {
124124 # if ENGINE_DLL
125 GetEngineFactoryD3D11Type GetEngineFactoryD3D11 = nullptr;
126125 // Load the dll and import GetEngineFactoryD3D11() function
127 LoadGraphicsEngineD3D11(GetEngineFactoryD3D11);
126 auto GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();
128127 if (GetEngineFactoryD3D11 == nullptr)
129128 {
130129 LOG_ERROR_AND_THROW("Failed to load the engine");
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 }
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 }
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 }
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 }
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"
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 }
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 }
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"
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"
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 }
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 }
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"
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"
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 }
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 }