kc3-lang/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h

• Show log

  Commit

• Hash : e58e77f5
  Author :
  Date : 2022-11-10T12:49:03
  

  Support timestamp behind flag enableTimestampQueries
  
  All timestamp queries happen in the same disjoint query in one
  Context11.
  
  The whole design is that we start a disjoint query in D3D11 at the first
  timestamp request and keep it continuously running in current context.
  Only end it and read it back when the user queries if there is a
  disjoint. We cache the frequency and assume it doesn't change. For the
  first timestamp, we create a temporary D3D disjoint query and end it so
  we have a frequency to convert the ticks to nanoseconds.
  
  This task is taken over from
  https://chromium-review.googlesource.com/c/angle/angle/+/3694732
  
  Bug: angleproject:7367
  Change-Id: I747c9b00e10ac58362df66332efd01a24aa395f2
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4021139
  Commit-Queue: Jiajia Qin <jiajia.qin@intel.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/d3d11/Context11.h

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // Context11:
  //   D3D11-specific functionality associated with a GL Context.
  //
  
  #ifndef LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_
  #define LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_
  
  #include <stack>
  #include "libANGLE/renderer/ContextImpl.h"
  #include "libANGLE/renderer/d3d/ContextD3D.h"
  #include "libANGLE/renderer/d3d/d3d11/ResourceManager11.h"
  
  namespace rx
  {
  class Renderer11;
  
  class Context11 : public ContextD3D, public MultisampleTextureInitializer
  {
    public:
      Context11(const gl::State &state, gl::ErrorSet *errorSet, Renderer11 *renderer);
      ~Context11() override;
  
      angle::Result initialize() override;
      void onDestroy(const gl::Context *context) override;
  
      // Shader creation
      CompilerImpl *createCompiler() override;
      ShaderImpl *createShader(const gl::ShaderState &data) override;
      ProgramImpl *createProgram(const gl::ProgramState &data) override;
  
      // Framebuffer creation
      FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override;
  
      // Texture creation
      TextureImpl *createTexture(const gl::TextureState &state) override;
  
      // Renderbuffer creation
      RenderbufferImpl *createRenderbuffer(const gl::RenderbufferState &state) override;
  
      // Buffer creation
      BufferImpl *createBuffer(const gl::BufferState &state) override;
  
      // Vertex Array creation
      VertexArrayImpl *createVertexArray(const gl::VertexArrayState &data) override;
  
      // Query and Fence creation
      QueryImpl *createQuery(gl::QueryType type) override;
      FenceNVImpl *createFenceNV() override;
      SyncImpl *createSync() override;
  
      // Transform Feedback creation
      TransformFeedbackImpl *createTransformFeedback(
          const gl::TransformFeedbackState &state) override;
  
      // Sampler object creation
      SamplerImpl *createSampler(const gl::SamplerState &state) override;
  
      // Program Pipeline object creation
      ProgramPipelineImpl *createProgramPipeline(const gl::ProgramPipelineState &data) override;
  
      // Memory object creation.
      MemoryObjectImpl *createMemoryObject() override;
  
      // Semaphore creation.
      SemaphoreImpl *createSemaphore() override;
  
      // Overlay creation.
      OverlayImpl *createOverlay(const gl::OverlayState &state) override;
  
      // Flush and finish.
      angle::Result flush(const gl::Context *context) override;
      angle::Result finish(const gl::Context *context) override;
  
      // Drawing methods.
      angle::Result drawArrays(const gl::Context *context,
                               gl::PrimitiveMode mode,
                               GLint first,
                               GLsizei count) override;
      angle::Result drawArraysInstanced(const gl::Context *context,
                                        gl::PrimitiveMode mode,
                                        GLint first,
                                        GLsizei count,
                                        GLsizei instanceCount) override;
      angle::Result drawArraysInstancedBaseInstance(const gl::Context *context,
                                                    gl::PrimitiveMode mode,
                                                    GLint first,
                                                    GLsizei count,
                                                    GLsizei instanceCount,
                                                    GLuint baseInstance) override;
  
      angle::Result drawElements(const gl::Context *context,
                                 gl::PrimitiveMode mode,
                                 GLsizei count,
                                 gl::DrawElementsType type,
                                 const void *indices) override;
      angle::Result drawElementsBaseVertex(const gl::Context *context,
                                           gl::PrimitiveMode mode,
                                           GLsizei count,
                                           gl::DrawElementsType type,
                                           const void *indices,
                                           GLint baseVertex) override;
      angle::Result drawElementsInstanced(const gl::Context *context,
                                          gl::PrimitiveMode mode,
                                          GLsizei count,
                                          gl::DrawElementsType type,
                                          const void *indices,
                                          GLsizei instances) override;
      angle::Result drawElementsInstancedBaseVertex(const gl::Context *context,
                                                    gl::PrimitiveMode mode,
                                                    GLsizei count,
                                                    gl::DrawElementsType type,
                                                    const void *indices,
                                                    GLsizei instances,
                                                    GLint baseVertex) override;
      angle::Result drawElementsInstancedBaseVertexBaseInstance(const gl::Context *context,
                                                                gl::PrimitiveMode mode,
                                                                GLsizei count,
                                                                gl::DrawElementsType type,
                                                                const void *indices,
                                                                GLsizei instances,
                                                                GLint baseVertex,
                                                                GLuint baseInstance) override;
      angle::Result drawRangeElements(const gl::Context *context,
                                      gl::PrimitiveMode mode,
                                      GLuint start,
                                      GLuint end,
                                      GLsizei count,
                                      gl::DrawElementsType type,
                                      const void *indices) override;
      angle::Result drawRangeElementsBaseVertex(const gl::Context *context,
                                                gl::PrimitiveMode mode,
                                                GLuint start,
                                                GLuint end,
                                                GLsizei count,
                                                gl::DrawElementsType type,
                                                const void *indices,
                                                GLint baseVertex) override;
      angle::Result drawArraysIndirect(const gl::Context *context,
                                       gl::PrimitiveMode mode,
                                       const void *indirect) override;
      angle::Result drawElementsIndirect(const gl::Context *context,
                                         gl::PrimitiveMode mode,
                                         gl::DrawElementsType type,
                                         const void *indirect) override;
  
      angle::Result multiDrawArrays(const gl::Context *context,
                                    gl::PrimitiveMode mode,
                                    const GLint *firsts,
                                    const GLsizei *counts,
                                    GLsizei drawcount) override;
      angle::Result multiDrawArraysInstanced(const gl::Context *context,
                                             gl::PrimitiveMode mode,
                                             const GLint *firsts,
                                             const GLsizei *counts,
                                             const GLsizei *instanceCounts,
                                             GLsizei drawcount) override;
      angle::Result multiDrawArraysIndirect(const gl::Context *context,
                                            gl::PrimitiveMode mode,
                                            const void *indirect,
                                            GLsizei drawcount,
                                            GLsizei stride) override;
      angle::Result multiDrawElements(const gl::Context *context,
                                      gl::PrimitiveMode mode,
                                      const GLsizei *counts,
                                      gl::DrawElementsType type,
                                      const GLvoid *const *indices,
                                      GLsizei drawcount) override;
      angle::Result multiDrawElementsInstanced(const gl::Context *context,
                                               gl::PrimitiveMode mode,
                                               const GLsizei *counts,
                                               gl::DrawElementsType type,
                                               const GLvoid *const *indices,
                                               const GLsizei *instanceCounts,
                                               GLsizei drawcount) override;
      angle::Result multiDrawElementsIndirect(const gl::Context *context,
                                              gl::PrimitiveMode mode,
                                              gl::DrawElementsType type,
                                              const void *indirect,
                                              GLsizei drawcount,
                                              GLsizei stride) override;
      angle::Result multiDrawArraysInstancedBaseInstance(const gl::Context *context,
                                                         gl::PrimitiveMode mode,
                                                         const GLint *firsts,
                                                         const GLsizei *counts,
                                                         const GLsizei *instanceCounts,
                                                         const GLuint *baseInstances,
                                                         GLsizei drawcount) override;
      angle::Result multiDrawElementsInstancedBaseVertexBaseInstance(const gl::Context *context,
                                                                     gl::PrimitiveMode mode,
                                                                     const GLsizei *counts,
                                                                     gl::DrawElementsType type,
                                                                     const GLvoid *const *indices,
                                                                     const GLsizei *instanceCounts,
                                                                     const GLint *baseVertices,
                                                                     const GLuint *baseInstances,
                                                                     GLsizei drawcount) override;
  
      // Device loss
      gl::GraphicsResetStatus getResetStatus() override;
  
      // EXT_debug_marker
      angle::Result insertEventMarker(GLsizei length, const char *marker) override;
      angle::Result pushGroupMarker(GLsizei length, const char *marker) override;
      angle::Result popGroupMarker() override;
  
      // KHR_debug
      angle::Result pushDebugGroup(const gl::Context *context,
                                   GLenum source,
                                   GLuint id,
                                   const std::string &message) override;
      angle::Result popDebugGroup(const gl::Context *context) override;
  
      // State sync with dirty bits.
      angle::Result syncState(const gl::Context *context,
                              const gl::State::DirtyBits &dirtyBits,
                              const gl::State::DirtyBits &bitMask,
                              gl::Command command) override;
  
      // Disjoint timer queries
      GLint getGPUDisjoint() override;
      GLint64 getTimestamp() override;
  
      // Context switching
      angle::Result onMakeCurrent(const gl::Context *context) override;
  
      // Caps queries
      gl::Caps getNativeCaps() const override;
      const gl::TextureCapsMap &getNativeTextureCaps() const override;
      const gl::Extensions &getNativeExtensions() const override;
      const gl::Limitations &getNativeLimitations() const override;
      const ShPixelLocalStorageOptions &getNativePixelLocalStorageOptions() const override;
  
      Renderer11 *getRenderer() const { return mRenderer; }
      angle::ImageLoadContext getImageLoadContext() const;
  
      angle::Result dispatchCompute(const gl::Context *context,
                                    GLuint numGroupsX,
                                    GLuint numGroupsY,
                                    GLuint numGroupsZ) override;
      angle::Result dispatchComputeIndirect(const gl::Context *context, GLintptr indirect) override;
  
      angle::Result memoryBarrier(const gl::Context *context, GLbitfield barriers) override;
      angle::Result memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers) override;
  
      angle::Result triggerDrawCallProgramRecompilation(const gl::Context *context,
                                                        gl::PrimitiveMode drawMode);
      angle::Result triggerDispatchCallProgramRecompilation(const gl::Context *context);
      angle::Result getIncompleteTexture(const gl::Context *context,
                                         gl::TextureType type,
                                         gl::Texture **textureOut);
  
      angle::Result initializeMultisampleTextureToBlack(const gl::Context *context,
                                                        gl::Texture *glTexture) override;
  
      void handleResult(HRESULT hr,
                        const char *message,
                        const char *file,
                        const char *function,
                        unsigned int line) override;
  
      void setGPUDisjoint();
      angle::Result checkDisjointQuery();
      HRESULT checkDisjointQueryStatus();
      UINT64 getDisjointFrequency();
      void setDisjointFrequency(UINT64 frequency);
  
    private:
      angle::Result drawElementsImpl(const gl::Context *context,
                                     gl::PrimitiveMode mode,
                                     GLsizei indexCount,
                                     gl::DrawElementsType indexType,
                                     const void *indices,
                                     GLsizei instanceCount,
                                     GLint baseVertex,
                                     GLuint baseInstance,
                                     bool promoteDynamic,
                                     bool isInstancedDraw);
  
      Renderer11 *mRenderer;
      IncompleteTextureSet mIncompleteTextures;
      std::stack<std::string> mMarkerStack;
      d3d11::Query mDisjointQuery;
      bool mDisjointQueryStarted;
      bool mDisjoint;
      UINT64 mFrequency;
  };
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_D3D_D3D11_CONTEXT11_H_
  

Download