1 //
2 // Copyright 2012 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 
7 // Renderer11.h: Defines a back-end specific class for the D3D11 renderer.
8 
9 #ifndef LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_
10 #define LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_
11 
12 #include "common/angleutils.h"
13 #include "common/mathutil.h"
14 #include "libANGLE/AttributeMap.h"
15 #include "libANGLE/angletypes.h"
16 #include "libANGLE/renderer/d3d/HLSLCompiler.h"
17 #include "libANGLE/renderer/d3d/ProgramD3D.h"
18 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
19 #include "libANGLE/renderer/d3d/RendererD3D.h"
20 #include "libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h"
21 #include "libANGLE/renderer/d3d/d3d11/RenderStateCache.h"
22 #include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
23 #include "libANGLE/renderer/d3d/d3d11/StateManager11.h"
24 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
25 
26 namespace gl
27 {
28 class FramebufferAttachment;
29 class ImageIndex;
30 }  // namespace gl
31 
32 namespace rx
33 {
34 class Blit11;
35 class Buffer11;
36 class Clear11;
37 class Context11;
38 class IndexDataManager;
39 struct PackPixelsParams;
40 class PixelTransfer11;
41 class RenderTarget11;
42 class StreamingIndexBufferInterface;
43 class Trim11;
44 class VertexDataManager;
45 
46 struct Renderer11DeviceCaps
47 {
48     Renderer11DeviceCaps();
49 
50     D3D_FEATURE_LEVEL featureLevel;
51     bool supportsDXGI1_2;                         // Support for DXGI 1.2
52     bool supportsClearView;                       // Support for ID3D11DeviceContext1::ClearView
53     bool supportsConstantBufferOffsets;           // Support for Constant buffer offset
54     bool supportsVpRtIndexWriteFromVertexShader;  // VP/RT can be selected in the Vertex Shader
55                                                   // stage.
56     bool supportsMultisampledDepthStencilSRVs;  // D3D feature level 10.0 no longer allows creation
57                                                 // of textures with both the bind SRV and DSV flags
58                                                 // when multisampled.  Textures will need to be
59                                                 // resolved before reading. crbug.com/656989
60     UINT B5G6R5support;     // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B5G6R5_UNORM
61     UINT B5G6R5maxSamples;  // Maximum number of samples supported by DXGI_FORMAT_B5G6R5_UNORM
62     UINT B4G4R4A4support;  // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B4G4R4A4_UNORM
63     UINT B4G4R4A4maxSamples;  // Maximum number of samples supported by DXGI_FORMAT_B4G4R4A4_UNORM
64     UINT B5G5R5A1support;  // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B5G5R5A1_UNORM
65     UINT B5G5R5A1maxSamples;  // Maximum number of samples supported by DXGI_FORMAT_B5G5R5A1_UNORM
66     Optional<LARGE_INTEGER> driverVersion;  // Four-part driver version number.
67 };
68 
69 enum
70 {
71     MAX_VERTEX_UNIFORM_VECTORS_D3D11   = 1024,
72     MAX_FRAGMENT_UNIFORM_VECTORS_D3D11 = 1024
73 };
74 
75 // Possible reasons RendererD3D initialize can fail
76 enum D3D11InitError
77 {
78     // The renderer loaded successfully
79     D3D11_INIT_SUCCESS = 0,
80     // Failed to load the ANGLE & D3D compiler libraries
81     D3D11_INIT_COMPILER_ERROR,
82     // Failed to load a necessary DLL (non-compiler)
83     D3D11_INIT_MISSING_DEP,
84     // CreateDevice returned E_INVALIDARG
85     D3D11_INIT_CREATEDEVICE_INVALIDARG,
86     // CreateDevice failed with an error other than invalid arg
87     D3D11_INIT_CREATEDEVICE_ERROR,
88     // DXGI 1.2 required but not found
89     D3D11_INIT_INCOMPATIBLE_DXGI,
90     // Other initialization error
91     D3D11_INIT_OTHER_ERROR,
92     // CreateDevice returned E_FAIL
93     D3D11_INIT_CREATEDEVICE_FAIL,
94     // CreateDevice returned E_NOTIMPL
95     D3D11_INIT_CREATEDEVICE_NOTIMPL,
96     // CreateDevice returned E_OUTOFMEMORY
97     D3D11_INIT_CREATEDEVICE_OUTOFMEMORY,
98     // CreateDevice returned DXGI_ERROR_INVALID_CALL
99     D3D11_INIT_CREATEDEVICE_INVALIDCALL,
100     // CreateDevice returned DXGI_ERROR_SDK_COMPONENT_MISSING
101     D3D11_INIT_CREATEDEVICE_COMPONENTMISSING,
102     // CreateDevice returned DXGI_ERROR_WAS_STILL_DRAWING
103     D3D11_INIT_CREATEDEVICE_WASSTILLDRAWING,
104     // CreateDevice returned DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
105     D3D11_INIT_CREATEDEVICE_NOTAVAILABLE,
106     // CreateDevice returned DXGI_ERROR_DEVICE_HUNG
107     D3D11_INIT_CREATEDEVICE_DEVICEHUNG,
108     // CreateDevice returned NULL
109     D3D11_INIT_CREATEDEVICE_NULL,
110     NUM_D3D11_INIT_ERRORS
111 };
112 
113 class Renderer11 : public RendererD3D
114 {
115   public:
116     explicit Renderer11(egl::Display *display);
117     ~Renderer11() override;
118 
119     egl::Error initialize() override;
120     bool resetDevice() override;
121 
122     egl::ConfigSet generateConfigs() override;
123     void generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const override;
124 
125     ContextImpl *createContext(const gl::State &state, gl::ErrorSet *errorSet) override;
126 
127     angle::Result flush(Context11 *context11);
128     angle::Result finish(Context11 *context11);
129 
130     bool isValidNativeWindow(EGLNativeWindowType window) const override;
131     NativeWindowD3D *createNativeWindow(EGLNativeWindowType window,
132                                         const egl::Config *config,
133                                         const egl::AttributeMap &attribs) const override;
134 
135     SwapChainD3D *createSwapChain(NativeWindowD3D *nativeWindow,
136                                   HANDLE shareHandle,
137                                   IUnknown *d3dTexture,
138                                   GLenum backBufferFormat,
139                                   GLenum depthBufferFormat,
140                                   EGLint orientation,
141                                   EGLint samples) override;
142     egl::Error getD3DTextureInfo(const egl::Config *configuration,
143                                  IUnknown *d3dTexture,
144                                  const egl::AttributeMap &attribs,
145                                  EGLint *width,
146                                  EGLint *height,
147                                  GLsizei *samples,
148                                  gl::Format *glFormat,
149                                  const angle::Format **angleFormat) const override;
150     egl::Error validateShareHandle(const egl::Config *config,
151                                    HANDLE shareHandle,
152                                    const egl::AttributeMap &attribs) const override;
153 
154     // lost device
155     bool testDeviceLost() override;
156     bool testDeviceResettable() override;
157 
158     std::string getRendererDescription() const;
159     DeviceIdentifier getAdapterIdentifier() const override;
160 
161     unsigned int getReservedVertexUniformVectors() const;
162     unsigned int getReservedFragmentUniformVectors() const;
163     gl::ShaderMap<unsigned int> getReservedShaderUniformBuffers() const;
164 
165     bool getShareHandleSupport() const;
166 
167     int getMajorShaderModel() const override;
168     int getMinorShaderModel() const override;
169     std::string getShaderModelSuffix() const override;
170 
171     // Pixel operations
172     angle::Result copyImage2D(const gl::Context *context,
173                               const gl::Framebuffer *framebuffer,
174                               const gl::Rectangle &sourceRect,
175                               GLenum destFormat,
176                               const gl::Offset &destOffset,
177                               TextureStorage *storage,
178                               GLint level) override;
179     angle::Result copyImageCube(const gl::Context *context,
180                                 const gl::Framebuffer *framebuffer,
181                                 const gl::Rectangle &sourceRect,
182                                 GLenum destFormat,
183                                 const gl::Offset &destOffset,
184                                 TextureStorage *storage,
185                                 gl::TextureTarget target,
186                                 GLint level) override;
187     angle::Result copyImage3D(const gl::Context *context,
188                               const gl::Framebuffer *framebuffer,
189                               const gl::Rectangle &sourceRect,
190                               GLenum destFormat,
191                               const gl::Offset &destOffset,
192                               TextureStorage *storage,
193                               GLint level) override;
194     angle::Result copyImage2DArray(const gl::Context *context,
195                                    const gl::Framebuffer *framebuffer,
196                                    const gl::Rectangle &sourceRect,
197                                    GLenum destFormat,
198                                    const gl::Offset &destOffset,
199                                    TextureStorage *storage,
200                                    GLint level) override;
201 
202     angle::Result copyTexture(const gl::Context *context,
203                               const gl::Texture *source,
204                               GLint sourceLevel,
205                               gl::TextureTarget srcTarget,
206                               const gl::Box &sourceBox,
207                               GLenum destFormat,
208                               GLenum destType,
209                               const gl::Offset &destOffset,
210                               TextureStorage *storage,
211                               gl::TextureTarget destTarget,
212                               GLint destLevel,
213                               bool unpackFlipY,
214                               bool unpackPremultiplyAlpha,
215                               bool unpackUnmultiplyAlpha) override;
216     angle::Result copyCompressedTexture(const gl::Context *context,
217                                         const gl::Texture *source,
218                                         GLint sourceLevel,
219                                         TextureStorage *storage,
220                                         GLint destLevel) override;
221 
222     // RenderTarget creation
223     angle::Result createRenderTarget(const gl::Context *context,
224                                      int width,
225                                      int height,
226                                      GLenum format,
227                                      GLsizei samples,
228                                      RenderTargetD3D **outRT) override;
229     angle::Result createRenderTargetCopy(const gl::Context *context,
230                                          RenderTargetD3D *source,
231                                          RenderTargetD3D **outRT) override;
232 
233     // Shader operations
234     angle::Result loadExecutable(d3d::Context *context,
235                                  const uint8_t *function,
236                                  size_t length,
237                                  gl::ShaderType type,
238                                  const std::vector<D3DVarying> &streamOutVaryings,
239                                  bool separatedOutputBuffers,
240                                  ShaderExecutableD3D **outExecutable) override;
241     angle::Result compileToExecutable(d3d::Context *context,
242                                       gl::InfoLog &infoLog,
243                                       const std::string &shaderHLSL,
244                                       gl::ShaderType type,
245                                       const std::vector<D3DVarying> &streamOutVaryings,
246                                       bool separatedOutputBuffers,
247                                       const angle::CompilerWorkaroundsD3D &workarounds,
248                                       ShaderExecutableD3D **outExectuable) override;
249     angle::Result ensureHLSLCompilerInitialized(d3d::Context *context) override;
250 
251     UniformStorageD3D *createUniformStorage(size_t storageSize) override;
252 
253     // Image operations
254     ImageD3D *createImage() override;
255     ExternalImageSiblingImpl *createExternalImageSibling(const gl::Context *context,
256                                                          EGLenum target,
257                                                          EGLClientBuffer buffer,
258                                                          const egl::AttributeMap &attribs) override;
259     angle::Result generateMipmap(const gl::Context *context,
260                                  ImageD3D *dest,
261                                  ImageD3D *source) override;
262     angle::Result generateMipmapUsingD3D(const gl::Context *context,
263                                          TextureStorage *storage,
264                                          const gl::TextureState &textureState) override;
265     angle::Result copyImage(const gl::Context *context,
266                             ImageD3D *dest,
267                             ImageD3D *source,
268                             const gl::Box &sourceBox,
269                             const gl::Offset &destOffset,
270                             bool unpackFlipY,
271                             bool unpackPremultiplyAlpha,
272                             bool unpackUnmultiplyAlpha) override;
273 
274     TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain) override;
275     TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage,
276                                                  RenderTargetD3D *renderTargetD3D) override;
277     TextureStorage *createTextureStorageExternal(
278         egl::Stream *stream,
279         const egl::Stream::GLTextureDescription &desc) override;
280     TextureStorage *createTextureStorage2D(GLenum internalformat,
281                                            bool renderTarget,
282                                            GLsizei width,
283                                            GLsizei height,
284                                            int levels,
285                                            bool hintLevelZeroOnly) override;
286     TextureStorage *createTextureStorageCube(GLenum internalformat,
287                                              bool renderTarget,
288                                              int size,
289                                              int levels,
290                                              bool hintLevelZeroOnly) override;
291     TextureStorage *createTextureStorage3D(GLenum internalformat,
292                                            bool renderTarget,
293                                            GLsizei width,
294                                            GLsizei height,
295                                            GLsizei depth,
296                                            int levels) override;
297     TextureStorage *createTextureStorage2DArray(GLenum internalformat,
298                                                 bool renderTarget,
299                                                 GLsizei width,
300                                                 GLsizei height,
301                                                 GLsizei depth,
302                                                 int levels) override;
303     TextureStorage *createTextureStorage2DMultisample(GLenum internalformat,
304                                                       GLsizei width,
305                                                       GLsizei height,
306                                                       int levels,
307                                                       int samples,
308                                                       bool fixedSampleLocations) override;
309     TextureStorage *createTextureStorage2DMultisampleArray(GLenum internalformat,
310                                                            GLsizei width,
311                                                            GLsizei height,
312                                                            GLsizei depth,
313                                                            int levels,
314                                                            int samples,
315                                                            bool fixedSampleLocations) override;
316 
317     VertexBuffer *createVertexBuffer() override;
318     IndexBuffer *createIndexBuffer() override;
319 
320     // Stream Creation
321     StreamProducerImpl *createStreamProducerD3DTexture(egl::Stream::ConsumerType consumerType,
322                                                        const egl::AttributeMap &attribs) override;
323 
324     // D3D11-renderer specific methods
getDevice()325     ID3D11Device *getDevice() { return mDevice; }
326     void *getD3DDevice() override;
getDeviceContext()327     ID3D11DeviceContext *getDeviceContext() { return mDeviceContext; }
getDeviceContext1IfSupported()328     ID3D11DeviceContext1 *getDeviceContext1IfSupported() { return mDeviceContext1; }
getDxgiFactory()329     IDXGIFactory *getDxgiFactory() { return mDxgiFactory; }
330 
331     angle::Result getBlendState(const gl::Context *context,
332                                 const d3d11::BlendStateKey &key,
333                                 const d3d11::BlendState **outBlendState);
334     angle::Result getRasterizerState(const gl::Context *context,
335                                      const gl::RasterizerState &rasterState,
336                                      bool scissorEnabled,
337                                      ID3D11RasterizerState **outRasterizerState);
338     angle::Result getDepthStencilState(const gl::Context *context,
339                                        const gl::DepthStencilState &dsState,
340                                        const d3d11::DepthStencilState **outDSState);
341     angle::Result getSamplerState(const gl::Context *context,
342                                   const gl::SamplerState &samplerState,
343                                   ID3D11SamplerState **outSamplerState);
344     UINT getSampleDescQuality(GLuint supportedSamples) const;
345 
getBlitter()346     Blit11 *getBlitter() { return mBlit; }
getClearer()347     Clear11 *getClearer() { return mClear; }
348     gl::DebugAnnotator *getAnnotator();
349 
350     // Buffer-to-texture and Texture-to-buffer copies
351     bool supportsFastCopyBufferToTexture(GLenum internalFormat) const override;
352     angle::Result fastCopyBufferToTexture(const gl::Context *context,
353                                           const gl::PixelUnpackState &unpack,
354                                           unsigned int offset,
355                                           RenderTargetD3D *destRenderTarget,
356                                           GLenum destinationFormat,
357                                           GLenum sourcePixelsType,
358                                           const gl::Box &destArea) override;
359 
360     angle::Result packPixels(const gl::Context *context,
361                              const TextureHelper11 &textureHelper,
362                              const PackPixelsParams &params,
363                              uint8_t *pixelsOut);
364 
365     bool getLUID(LUID *adapterLuid) const override;
366     VertexConversionType getVertexConversionType(angle::FormatID vertexFormatID) const override;
367     GLenum getVertexComponentType(angle::FormatID vertexFormatID) const override;
368 
369     // Warning: you should ensure binding really matches attrib.bindingIndex before using this
370     // function.
371     angle::Result getVertexSpaceRequired(const gl::Context *context,
372                                          const gl::VertexAttribute &attrib,
373                                          const gl::VertexBinding &binding,
374                                          size_t count,
375                                          GLsizei instances,
376                                          unsigned int *bytesRequiredOut) const override;
377 
378     angle::Result readFromAttachment(const gl::Context *context,
379                                      const gl::FramebufferAttachment &srcAttachment,
380                                      const gl::Rectangle &sourceArea,
381                                      GLenum format,
382                                      GLenum type,
383                                      GLuint outputPitch,
384                                      const gl::PixelPackState &pack,
385                                      uint8_t *pixels);
386 
387     angle::Result blitRenderbufferRect(const gl::Context *context,
388                                        const gl::Rectangle &readRect,
389                                        const gl::Rectangle &drawRect,
390                                        RenderTargetD3D *readRenderTarget,
391                                        RenderTargetD3D *drawRenderTarget,
392                                        GLenum filter,
393                                        const gl::Rectangle *scissor,
394                                        bool colorBlit,
395                                        bool depthBlit,
396                                        bool stencilBlit);
397 
398     bool isES3Capable() const;
getRenderer11DeviceCaps()399     const Renderer11DeviceCaps &getRenderer11DeviceCaps() const { return mRenderer11DeviceCaps; }
400 
401     RendererClass getRendererClass() const override;
getStateManager()402     StateManager11 *getStateManager() { return &mStateManager; }
403 
404     void onSwap();
405     void onBufferCreate(const Buffer11 *created);
406     void onBufferDelete(const Buffer11 *deleted);
407 
408     DeviceImpl *createEGLDevice() override;
409 
410     angle::Result drawArrays(const gl::Context *context,
411                              gl::PrimitiveMode mode,
412                              GLint firstVertex,
413                              GLsizei vertexCount,
414                              GLsizei instanceCount,
415                              GLuint baseInstance);
416     angle::Result drawElements(const gl::Context *context,
417                                gl::PrimitiveMode mode,
418                                GLint startVertex,
419                                GLsizei indexCount,
420                                gl::DrawElementsType indexType,
421                                const void *indices,
422                                GLsizei instanceCount,
423                                GLint baseVertex,
424                                GLuint baseInstance);
425     angle::Result drawArraysIndirect(const gl::Context *context, const void *indirect);
426     angle::Result drawElementsIndirect(const gl::Context *context, const void *indirect);
427 
428     // Necessary hack for default framebuffers in D3D.
429     FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override;
430 
431     angle::Result getScratchMemoryBuffer(Context11 *context11,
432                                          size_t requestedSize,
433                                          angle::MemoryBuffer **bufferOut);
434 
435     gl::Version getMaxSupportedESVersion() const override;
436     gl::Version getMaxConformantESVersion() const override;
437 
438     angle::Result dispatchCompute(const gl::Context *context,
439                                   GLuint numGroupsX,
440                                   GLuint numGroupsY,
441                                   GLuint numGroupsZ);
442     angle::Result dispatchComputeIndirect(const gl::Context *context, GLintptr indirect);
443 
444     angle::Result createStagingTexture(const gl::Context *context,
445                                        ResourceType textureType,
446                                        const d3d11::Format &formatSet,
447                                        const gl::Extents &size,
448                                        StagingAccess readAndWriteAccess,
449                                        TextureHelper11 *textureOut);
450 
451     template <typename DescT, typename ResourceT>
allocateResource(d3d::Context * context,const DescT & desc,ResourceT * resourceOut)452     angle::Result allocateResource(d3d::Context *context, const DescT &desc, ResourceT *resourceOut)
453     {
454         return mResourceManager11.allocate(context, this, &desc, nullptr, resourceOut);
455     }
456 
457     template <typename DescT, typename InitDataT, typename ResourceT>
allocateResource(d3d::Context * context,const DescT & desc,InitDataT * initData,ResourceT * resourceOut)458     angle::Result allocateResource(d3d::Context *context,
459                                    const DescT &desc,
460                                    InitDataT *initData,
461                                    ResourceT *resourceOut)
462     {
463         return mResourceManager11.allocate(context, this, &desc, initData, resourceOut);
464     }
465 
466     template <typename InitDataT, typename ResourceT>
allocateResourceNoDesc(d3d::Context * context,InitDataT * initData,ResourceT * resourceOut)467     angle::Result allocateResourceNoDesc(d3d::Context *context,
468                                          InitDataT *initData,
469                                          ResourceT *resourceOut)
470     {
471         return mResourceManager11.allocate(context, this, nullptr, initData, resourceOut);
472     }
473 
474     template <typename DescT>
allocateTexture(d3d::Context * context,const DescT & desc,const d3d11::Format & format,TextureHelper11 * textureOut)475     angle::Result allocateTexture(d3d::Context *context,
476                                   const DescT &desc,
477                                   const d3d11::Format &format,
478                                   TextureHelper11 *textureOut)
479     {
480         return allocateTexture(context, desc, format, nullptr, textureOut);
481     }
482 
483     angle::Result allocateTexture(d3d::Context *context,
484                                   const D3D11_TEXTURE2D_DESC &desc,
485                                   const d3d11::Format &format,
486                                   const D3D11_SUBRESOURCE_DATA *initData,
487                                   TextureHelper11 *textureOut);
488 
489     angle::Result allocateTexture(d3d::Context *context,
490                                   const D3D11_TEXTURE3D_DESC &desc,
491                                   const d3d11::Format &format,
492                                   const D3D11_SUBRESOURCE_DATA *initData,
493                                   TextureHelper11 *textureOut);
494 
495     angle::Result clearRenderTarget(const gl::Context *context,
496                                     RenderTargetD3D *renderTarget,
497                                     const gl::ColorF &clearColorValue,
498                                     const float clearDepthValue,
499                                     const unsigned int clearStencilValue) override;
500 
501     bool canSelectViewInVertexShader() const override;
502 
503     angle::Result mapResource(const gl::Context *context,
504                               ID3D11Resource *resource,
505                               UINT subResource,
506                               D3D11_MAP mapType,
507                               UINT mapFlags,
508                               D3D11_MAPPED_SUBRESOURCE *mappedResource);
509 
510     angle::Result getIncompleteTexture(const gl::Context *context,
511                                        gl::TextureType type,
512                                        gl::Texture **textureOut) override;
513 
514   private:
515     void generateCaps(gl::Caps *outCaps,
516                       gl::TextureCapsMap *outTextureCaps,
517                       gl::Extensions *outExtensions,
518                       gl::Limitations *outLimitations) const override;
519 
520     void initializeFeatures(angle::FeaturesD3D *features) const override;
521 
522     angle::Result drawLineLoop(const gl::Context *context,
523                                GLuint count,
524                                gl::DrawElementsType type,
525                                const void *indices,
526                                int baseVertex,
527                                int instances);
528     angle::Result drawTriangleFan(const gl::Context *context,
529                                   GLuint count,
530                                   gl::DrawElementsType type,
531                                   const void *indices,
532                                   int baseVertex,
533                                   int instances);
534 
535     angle::Result resolveMultisampledTexture(const gl::Context *context,
536                                              RenderTarget11 *renderTarget,
537                                              bool depth,
538                                              bool stencil,
539                                              TextureHelper11 *textureOut);
540 
541     void populateRenderer11DeviceCaps();
542 
543     void updateHistograms();
544 
545     angle::Result copyImageInternal(const gl::Context *context,
546                                     const gl::Framebuffer *framebuffer,
547                                     const gl::Rectangle &sourceRect,
548                                     GLenum destFormat,
549                                     const gl::Offset &destOffset,
550                                     RenderTargetD3D *destRenderTarget);
551 
552     gl::SupportedSampleSet generateSampleSetForEGLConfig(
553         const gl::TextureCaps &colorBufferFormatCaps,
554         const gl::TextureCaps &depthStencilBufferFormatCaps) const;
555 
556     HRESULT callD3D11CreateDevice(PFN_D3D11_CREATE_DEVICE createDevice, bool debug);
557     HRESULT callD3D11On12CreateDevice(PFN_D3D12_CREATE_DEVICE createDevice12,
558                                       PFN_D3D11ON12_CREATE_DEVICE createDevice11on12,
559                                       bool debug);
560     egl::Error initializeD3DDevice();
561     egl::Error initializeDevice();
562     void releaseDeviceResources();
563     void release();
564 
565     d3d11::ANGLED3D11DeviceType getDeviceType() const;
566 
567     // Make sure that the raw buffer is the latest buffer.
568     angle::Result markRawBufferUsage(const gl::Context *context);
569     angle::Result markTransformFeedbackUsage(const gl::Context *context);
570     angle::Result drawWithGeometryShaderAndTransformFeedback(Context11 *context11,
571                                                              gl::PrimitiveMode mode,
572                                                              UINT instanceCount,
573                                                              UINT vertexCount);
574 
575     HMODULE mD3d11Module;
576     HMODULE mD3d12Module;
577     HMODULE mDxgiModule;
578     HMODULE mDCompModule;
579     std::vector<D3D_FEATURE_LEVEL> mAvailableFeatureLevels;
580     D3D_DRIVER_TYPE mRequestedDriverType;
581     bool mCreateDebugDevice;
582     bool mCreatedWithDeviceEXT;
583 
584     HLSLCompiler mCompiler;
585 
586     RenderStateCache mStateCache;
587 
588     StateManager11 mStateManager;
589 
590     StreamingIndexBufferInterface *mLineLoopIB;
591     StreamingIndexBufferInterface *mTriangleFanIB;
592 
593     // Texture copy resources
594     Blit11 *mBlit;
595     PixelTransfer11 *mPixelTransfer;
596 
597     // Masked clear resources
598     Clear11 *mClear;
599 
600     // Perform trim for D3D resources
601     Trim11 *mTrim;
602 
603     // Sync query
604     d3d11::Query mSyncQuery;
605 
606     // Created objects state tracking
607     std::set<const Buffer11 *> mAliveBuffers;
608 
609     double mLastHistogramUpdateTime;
610 
611     angle::ComPtr<ID3D12Device> mDevice12;
612     angle::ComPtr<ID3D12CommandQueue> mCommandQueue;
613 
614     ID3D11Device *mDevice;
615     Renderer11DeviceCaps mRenderer11DeviceCaps;
616     ID3D11DeviceContext *mDeviceContext;
617     ID3D11DeviceContext1 *mDeviceContext1;
618     ID3D11DeviceContext3 *mDeviceContext3;
619     IDXGIAdapter *mDxgiAdapter;
620     DXGI_ADAPTER_DESC mAdapterDescription;
621     char mDescription[128];
622     IDXGIFactory *mDxgiFactory;
623     ID3D11Debug *mDebug;
624 
625     std::vector<GLuint> mScratchIndexDataBuffer;
626 
627     angle::ScratchBuffer mScratchMemoryBuffer;
628 
629     DebugAnnotator11 mAnnotator;
630 
631     mutable Optional<bool> mSupportsShareHandles;
632     ResourceManager11 mResourceManager11;
633 
634     TextureHelper11 mCachedResolveTexture;
635 };
636 
637 }  // namespace rx
638 #endif  // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_
639