gpu/command_buffer/client/share_group.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef GPU_COMMAND_BUFFER_CLIENT_SHARE_GROUP_H_
   6 #define GPU_COMMAND_BUFFER_CLIENT_SHARE_GROUP_H_
   7
   8 #include <GLES2/gl2.h>
   9 #include "base/memory/scoped_ptr.h"
  10 #include "gles2_impl_export.h"
  11 #include "gpu/command_buffer/client/ref_counted.h"
  12 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  13
  14 namespace gpu {
  15 namespace gles2 {
  16
  17 class GLES2Implementation;
  18 class GLES2ImplementationTest;
  19 class ProgramInfoManager;
  20
  21 typedef void (GLES2Implementation::*DeleteFn)(GLsizei n, const GLuint* ids);
  22 typedef void (GLES2Implementation::*DeleteRangeFn)(const GLuint first_id,
  23                                                    GLsizei range);
  24 typedef void (GLES2Implementation::*BindFn)(GLenum target, GLuint id);
  25 typedef void (GLES2Implementation::*BindIndexedFn)( \
  26     GLenum target, GLuint index, GLuint id);
  27 typedef void (GLES2Implementation::*BindIndexedRangeFn)( \
  28     GLenum target, GLuint index, GLuint id, GLintptr offset, GLsizeiptr size);
  29
  30 class ShareGroupContextData {
  31  public:
  32   struct IdHandlerData {
  33     IdHandlerData();
  34     ~IdHandlerData();
  35
  36     std::vector<GLuint> freed_ids_;
  37     uint32 flush_generation_;
  38   };
  39
  40   IdHandlerData* id_handler_data(int namespace_id) {
  41     return &id_handler_data_[namespace_id];
  42   }
  43
  44  private:
  45   IdHandlerData id_handler_data_[id_namespaces::kNumIdNamespaces];
  46 };
  47
  48 // Base class for IdHandlers
  49 class IdHandlerInterface {
  50  public:
  51   IdHandlerInterface() { }
  52   virtual ~IdHandlerInterface() { }
  53
  54   // Makes some ids at or above id_offset.
  55   virtual void MakeIds(
  56       GLES2Implementation* gl_impl,
  57       GLuint id_offset, GLsizei n, GLuint* ids) = 0;
  58
  59   // Frees some ids.
  60   virtual bool FreeIds(
  61       GLES2Implementation* gl_impl, GLsizei n, const GLuint* ids,
  62       DeleteFn delete_fn) = 0;
  63
  64   // Marks an id as used for glBind functions. id = 0 does nothing.
  65   virtual bool MarkAsUsedForBind(
  66       GLES2Implementation* gl_impl,
  67       GLenum target,
  68       GLuint id,
  69       BindFn bind_fn) = 0;
  70   // This is for glBindBufferBase.
  71   virtual bool MarkAsUsedForBind(
  72       GLES2Implementation* gl_impl,
  73       GLenum target,
  74       GLuint index,
  75       GLuint id,
  76       BindIndexedFn bind_fn) = 0;
  77   // This is for glBindBufferRange.
  78   virtual bool MarkAsUsedForBind(
  79       GLES2Implementation* gl_impl,
  80       GLenum target,
  81       GLuint index,
  82       GLuint id,
  83       GLintptr offset,
  84       GLsizeiptr size,
  85       BindIndexedRangeFn bind_fn) = 0;
  86
  87   // Called when a context in the share group is destructed.
  88   virtual void FreeContext(GLES2Implementation* gl_impl) = 0;
  89 };
  90
  91 class RangeIdHandlerInterface {
  92  public:
  93   RangeIdHandlerInterface() {}
  94   virtual ~RangeIdHandlerInterface() {}
  95
  96   // Makes a continuous range of ids. Stores the first allocated id to
  97   // |first_id| or 0 if allocation failed.
  98   virtual void MakeIdRange(GLES2Implementation* gl_impl,
  99                            GLsizei n,
 100                            GLuint* first_id) = 0;
 101
 102   // Frees a continuous |range| of ids beginning at |first_id|.
 103   virtual void FreeIdRange(GLES2Implementation* gl_impl,
 104                            const GLuint first_id,
 105                            GLsizei range,
 106                            DeleteRangeFn delete_fn) = 0;
 107
 108   // Called when a context in the share group is destructed.
 109   virtual void FreeContext(GLES2Implementation* gl_impl) = 0;
 110 };
 111
 112 // ShareGroup manages shared resources for contexts that are sharing resources.
 113 class GLES2_IMPL_EXPORT ShareGroup
 114     : public gpu::RefCountedThreadSafe<ShareGroup> {
 115  public:
 116   ShareGroup(bool bind_generates_resource);
 117
 118   bool bind_generates_resource() const {
 119     return bind_generates_resource_;
 120   }
 121
 122   IdHandlerInterface* GetIdHandler(int namespace_id) const {
 123     return id_handlers_[namespace_id].get();
 124   }
 125
 126   RangeIdHandlerInterface* GetRangeIdHandler(int range_namespace_id) const {
 127     return range_id_handlers_[range_namespace_id].get();
 128   }
 129
 130   ProgramInfoManager* program_info_manager() {
 131     return program_info_manager_.get();
 132   }
 133
 134   void FreeContext(GLES2Implementation* gl_impl) {
 135     for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
 136       id_handlers_[i]->FreeContext(gl_impl);
 137     }
 138     for (auto& range_id_handler : range_id_handlers_) {
 139       range_id_handler->FreeContext(gl_impl);
 140     }
 141   }
 142
 143  private:
 144   friend class gpu::RefCountedThreadSafe<ShareGroup>;
 145   friend class gpu::gles2::GLES2ImplementationTest;
 146   ~ShareGroup();
 147
 148   // Install a new program info manager. Used for testing only;
 149   void set_program_info_manager(ProgramInfoManager* manager);
 150
 151   scoped_ptr<IdHandlerInterface> id_handlers_[id_namespaces::kNumIdNamespaces];
 152   scoped_ptr<RangeIdHandlerInterface>
 153       range_id_handlers_[id_namespaces::kNumRangeIdNamespaces];
 154   scoped_ptr<ProgramInfoManager> program_info_manager_;
 155
 156   bool bind_generates_resource_;
 157
 158   DISALLOW_COPY_AND_ASSIGN(ShareGroup);
 159 };
 160
 161 }  // namespace gles2
 162 }  // namespace gpu
 163
 164 #endif  // GPU_COMMAND_BUFFER_CLIENT_SHARE_GROUP_H_