gpu/command_buffer/service/context_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_SERVICE_CONTEXT_GROUP_H_
   6 #define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
   7
   8 #include <string>
   9 #include <vector>
  10 #include "base/basictypes.h"
  11 #include "base/containers/hash_tables.h"
  12 #include "base/memory/linked_ptr.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  17 #include "gpu/command_buffer/service/feature_info.h"
  18 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
  19 #include "gpu/command_buffer/service/shader_translator_cache.h"
  20 #include "gpu/gpu_export.h"
  21
  22 namespace gpu {
  23
  24 class TransferBufferManagerInterface;
  25 class ValueStateMap;
  26
  27 namespace gles2 {
  28
  29 class ProgramCache;
  30 class BufferManager;
  31 class GLES2Decoder;
  32 class FramebufferManager;
  33 class MailboxManager;
  34 class RenderbufferManager;
  35 class ProgramManager;
  36 class ShaderManager;
  37 class TextureManager;
  38 class SubscriptionRefSet;
  39 class ValuebufferManager;
  40 class MemoryTracker;
  41 struct DisallowedFeatures;
  42
  43 // A Context Group helps manage multiple GLES2Decoders that share
  44 // resources.
  45 class GPU_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
  46  public:
  47   ContextGroup(
  48       const scoped_refptr<MailboxManager>& mailbox_manager,
  49       const scoped_refptr<MemoryTracker>& memory_tracker,
  50       const scoped_refptr<ShaderTranslatorCache>& shader_translator_cache,
  51       const scoped_refptr<FeatureInfo>& feature_info,
  52       const scoped_refptr<SubscriptionRefSet>& subscription_ref_set,
  53       const scoped_refptr<ValueStateMap>& pending_valuebuffer_state,
  54       bool bind_generates_resource);
  55
  56   // This should only be called by GLES2Decoder. This must be paired with a
  57   // call to destroy if it succeeds.
  58   bool Initialize(
  59       GLES2Decoder* decoder,
  60       const DisallowedFeatures& disallowed_features);
  61
  62   // Destroys all the resources when called for the last context in the group.
  63   // It should only be called by GLES2Decoder.
  64   void Destroy(GLES2Decoder* decoder, bool have_context);
  65
  66   MailboxManager* mailbox_manager() const {
  67     return mailbox_manager_.get();
  68   }
  69
  70   MemoryTracker* memory_tracker() const {
  71     return memory_tracker_.get();
  72   }
  73
  74   ShaderTranslatorCache* shader_translator_cache() const {
  75     return shader_translator_cache_.get();
  76   }
  77
  78   bool bind_generates_resource() {
  79     return bind_generates_resource_;
  80   }
  81
  82   uint32 max_vertex_attribs() const {
  83     return max_vertex_attribs_;
  84   }
  85
  86   uint32 max_texture_units() const {
  87     return max_texture_units_;
  88   }
  89
  90   uint32 max_texture_image_units() const {
  91     return max_texture_image_units_;
  92   }
  93
  94   uint32 max_vertex_texture_image_units() const {
  95     return max_vertex_texture_image_units_;
  96   }
  97
  98   uint32 max_fragment_uniform_vectors() const {
  99     return max_fragment_uniform_vectors_;
 100   }
 101
 102   uint32 max_varying_vectors() const {
 103     return max_varying_vectors_;
 104   }
 105
 106   uint32 max_vertex_uniform_vectors() const {
 107     return max_vertex_uniform_vectors_;
 108   }
 109
 110   uint32 max_color_attachments() const {
 111     return max_color_attachments_;
 112   }
 113
 114   uint32 max_draw_buffers() const {
 115     return max_draw_buffers_;
 116   }
 117
 118   FeatureInfo* feature_info() {
 119     return feature_info_.get();
 120   }
 121
 122   BufferManager* buffer_manager() const {
 123     return buffer_manager_.get();
 124   }
 125
 126   FramebufferManager* framebuffer_manager() const {
 127     return framebuffer_manager_.get();
 128   }
 129
 130   RenderbufferManager* renderbuffer_manager() const {
 131     return renderbuffer_manager_.get();
 132   }
 133
 134   ValuebufferManager* valuebuffer_manager() const {
 135     return valuebuffer_manager_.get();
 136   }
 137
 138   ValueStateMap* pending_valuebuffer_state() const {
 139     return pending_valuebuffer_state_.get();
 140   }
 141
 142   TextureManager* texture_manager() const {
 143     return texture_manager_.get();
 144   }
 145
 146   ProgramManager* program_manager() const {
 147     return program_manager_.get();
 148   }
 149
 150   bool has_program_cache() const {
 151     return program_cache_ != NULL;
 152   }
 153
 154   void set_program_cache(ProgramCache* program_cache) {
 155     program_cache_ = program_cache;
 156   }
 157
 158   ShaderManager* shader_manager() const {
 159     return shader_manager_.get();
 160   }
 161
 162   TransferBufferManagerInterface* transfer_buffer_manager() const {
 163     return transfer_buffer_manager_.get();
 164   }
 165
 166   uint32 GetMemRepresented() const;
 167
 168   // Loses all the context associated with this group.
 169   void LoseContexts(GLenum reset_status);
 170
 171   // EXT_draw_buffer related states for backbuffer.
 172   GLenum draw_buffer() const {
 173     return draw_buffer_;
 174   }
 175   void set_draw_buffer(GLenum buf) {
 176     draw_buffer_ = buf;
 177   }
 178
 179   bool GetBufferServiceId(GLuint client_id, GLuint* service_id) const;
 180
 181   void AddSamplerId(GLuint client_id, GLuint service_id) {
 182     samplers_id_map_[client_id] = service_id;
 183   }
 184
 185   bool GetSamplerServiceId(GLuint client_id, GLuint* service_id) const {
 186     base::hash_map<GLuint, GLuint>::const_iterator iter =
 187         samplers_id_map_.find(client_id);
 188     if (iter == samplers_id_map_.end())
 189       return false;
 190     if (service_id)
 191       *service_id = iter->second;
 192     return true;
 193   }
 194
 195   void RemoveSamplerId(GLuint client_id) {
 196     samplers_id_map_.erase(client_id);
 197   }
 198
 199   void AddTransformFeedbackId(GLuint client_id, GLuint service_id) {
 200     transformfeedbacks_id_map_[client_id] = service_id;
 201   }
 202
 203   bool GetTransformFeedbackServiceId(
 204       GLuint client_id, GLuint* service_id) const {
 205     base::hash_map<GLuint, GLuint>::const_iterator iter =
 206         transformfeedbacks_id_map_.find(client_id);
 207     if (iter == transformfeedbacks_id_map_.end())
 208       return false;
 209     if (service_id)
 210       *service_id = iter->second;
 211     return true;
 212   }
 213
 214   void RemoveTransformFeedbackId(GLuint client_id) {
 215     transformfeedbacks_id_map_.erase(client_id);
 216   }
 217
 218   void AddSyncId(GLuint client_id, GLsync service_id) {
 219     syncs_id_map_[client_id] = service_id;
 220   }
 221
 222   bool GetSyncServiceId(GLuint client_id, GLsync* service_id) const {
 223     base::hash_map<GLuint, GLsync>::const_iterator iter =
 224         syncs_id_map_.find(client_id);
 225     if (iter == syncs_id_map_.end())
 226       return false;
 227     if (service_id)
 228       *service_id = iter->second;
 229     return true;
 230   }
 231
 232   void RemoveSyncId(GLuint client_id) {
 233     syncs_id_map_.erase(client_id);
 234   }
 235
 236  private:
 237   friend class base::RefCounted<ContextGroup>;
 238   ~ContextGroup();
 239
 240   bool CheckGLFeature(GLint min_required, GLint* v);
 241   bool CheckGLFeatureU(GLint min_required, uint32* v);
 242   bool QueryGLFeature(GLenum pname, GLint min_required, GLint* v);
 243   bool QueryGLFeatureU(GLenum pname, GLint min_required, uint32* v);
 244   bool HaveContexts();
 245
 246   scoped_refptr<MailboxManager> mailbox_manager_;
 247   scoped_refptr<MemoryTracker> memory_tracker_;
 248   scoped_refptr<ShaderTranslatorCache> shader_translator_cache_;
 249   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
 250   scoped_refptr<SubscriptionRefSet> subscription_ref_set_;
 251   scoped_refptr<ValueStateMap> pending_valuebuffer_state_;
 252
 253   bool enforce_gl_minimums_;
 254   bool bind_generates_resource_;
 255
 256   uint32 max_vertex_attribs_;
 257   uint32 max_texture_units_;
 258   uint32 max_texture_image_units_;
 259   uint32 max_vertex_texture_image_units_;
 260   uint32 max_fragment_uniform_vectors_;
 261   uint32 max_varying_vectors_;
 262   uint32 max_vertex_uniform_vectors_;
 263   uint32 max_color_attachments_;
 264   uint32 max_draw_buffers_;
 265
 266   ProgramCache* program_cache_;
 267
 268   scoped_ptr<BufferManager> buffer_manager_;
 269
 270   scoped_ptr<FramebufferManager> framebuffer_manager_;
 271
 272   scoped_ptr<RenderbufferManager> renderbuffer_manager_;
 273
 274   scoped_ptr<TextureManager> texture_manager_;
 275
 276   scoped_ptr<ProgramManager> program_manager_;
 277
 278   scoped_ptr<ShaderManager> shader_manager_;
 279
 280   scoped_ptr<ValuebufferManager> valuebuffer_manager_;
 281
 282   scoped_refptr<FeatureInfo> feature_info_;
 283
 284   std::vector<base::WeakPtr<gles2::GLES2Decoder> > decoders_;
 285
 286   // Mappings from client side IDs to service side IDs.
 287   base::hash_map<GLuint, GLuint> samplers_id_map_;
 288   base::hash_map<GLuint, GLuint> transformfeedbacks_id_map_;
 289   base::hash_map<GLuint, GLsync> syncs_id_map_;
 290
 291   GLenum draw_buffer_;
 292
 293   DISALLOW_COPY_AND_ASSIGN(ContextGroup);
 294 };
 295
 296 }  // namespace gles2
 297 }  // namespace gpu
 298
 299 #endif  // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
 300
 301