gpu/command_buffer/service/context_state.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 // This file contains the ContextState class.
   6
   7 #ifndef GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_H_
   8 #define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_H_
   9
  10 #include <vector>
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "gpu/command_buffer/service/gl_utils.h"
  14 #include "gpu/command_buffer/service/texture_manager.h"
  15 #include "gpu/command_buffer/service/valuebuffer_manager.h"
  16 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
  17 #include "gpu/command_buffer/service/vertex_array_manager.h"
  18 #include "gpu/gpu_export.h"
  19
  20 namespace gpu {
  21 namespace gles2 {
  22
  23 class Buffer;
  24 class ErrorState;
  25 class ErrorStateClient;
  26 class FeatureInfo;
  27 class Framebuffer;
  28 class Logger;
  29 class Program;
  30 class Renderbuffer;
  31
  32 // State associated with each texture unit.
  33 struct GPU_EXPORT TextureUnit {
  34   TextureUnit();
  35   ~TextureUnit();
  36
  37   // The last target that was bound to this texture unit.
  38   GLenum bind_target;
  39
  40   // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture
  41   scoped_refptr<TextureRef> bound_texture_2d;
  42
  43   // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
  44   // glBindTexture
  45   scoped_refptr<TextureRef> bound_texture_cube_map;
  46
  47   // texture currently bound to this unit's GL_TEXTURE_EXTERNAL_OES with
  48   // glBindTexture
  49   scoped_refptr<TextureRef> bound_texture_external_oes;
  50
  51   // texture currently bound to this unit's GL_TEXTURE_RECTANGLE_ARB with
  52   // glBindTexture
  53   scoped_refptr<TextureRef> bound_texture_rectangle_arb;
  54
  55   // texture currently bound to this unit's GL_TEXTURE_3D with glBindTexture
  56   scoped_refptr<TextureRef> bound_texture_3d;
  57
  58   // texture currently bound to this unit's GL_TEXTURE_2D_ARRAY with
  59   // glBindTexture
  60   scoped_refptr<TextureRef> bound_texture_2d_array;
  61
  62   scoped_refptr<TextureRef> GetInfoForSamplerType(
  63       GLenum type) {
  64     DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
  65            type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
  66     switch (type) {
  67       case GL_SAMPLER_2D:
  68         return bound_texture_2d;
  69       case GL_SAMPLER_CUBE:
  70         return bound_texture_cube_map;
  71       case GL_SAMPLER_EXTERNAL_OES:
  72         return bound_texture_external_oes;
  73       case GL_SAMPLER_2D_RECT_ARB:
  74         return bound_texture_rectangle_arb;
  75       case GL_SAMPLER_3D:
  76         return bound_texture_3d;
  77       case GL_SAMPLER_2D_ARRAY:
  78         return bound_texture_2d_array;
  79     }
  80
  81     NOTREACHED();
  82     return NULL;
  83   }
  84
  85   void Unbind(TextureRef* texture) {
  86     if (bound_texture_2d.get() == texture) {
  87       bound_texture_2d = NULL;
  88     }
  89     if (bound_texture_cube_map.get() == texture) {
  90       bound_texture_cube_map = NULL;
  91     }
  92     if (bound_texture_external_oes.get() == texture) {
  93       bound_texture_external_oes = NULL;
  94     }
  95     if (bound_texture_3d.get() == texture) {
  96       bound_texture_3d = NULL;
  97     }
  98     if (bound_texture_2d_array.get() == texture) {
  99       bound_texture_2d_array = NULL;
 100     }
 101   }
 102 };
 103
 104 class GPU_EXPORT Vec4 {
 105  public:
 106   enum DataType {
 107     kFloat,
 108     kInt,
 109     kUInt,
 110   };
 111
 112   Vec4() {
 113     v_[0].float_value = 0.0f;
 114     v_[1].float_value = 0.0f;
 115     v_[2].float_value = 0.0f;
 116     v_[3].float_value = 1.0f;
 117     type_ = kFloat;
 118   }
 119
 120   template <typename T>
 121   void GetValues(T* values) const;
 122
 123   template <typename T>
 124   void SetValues(const T* values);
 125
 126   DataType type() const {
 127     return type_;
 128   }
 129
 130   bool Equal(const Vec4& other) const;
 131
 132  private:
 133   union ValueUnion {
 134     GLfloat float_value;
 135     GLint int_value;
 136     GLuint uint_value;
 137   };
 138
 139   ValueUnion v_[4];
 140   DataType type_;
 141 };
 142
 143 template <>
 144 GPU_EXPORT void Vec4::GetValues<GLfloat>(GLfloat* values) const;
 145 template <>
 146 GPU_EXPORT void Vec4::GetValues<GLint>(GLint* values) const;
 147 template <>
 148 GPU_EXPORT void Vec4::GetValues<GLuint>(GLuint* values) const;
 149
 150 template <>
 151 GPU_EXPORT void Vec4::SetValues<GLfloat>(const GLfloat* values);
 152 template <>
 153 GPU_EXPORT void Vec4::SetValues<GLint>(const GLint* values);
 154 template <>
 155 GPU_EXPORT void Vec4::SetValues<GLuint>(const GLuint* values);
 156
 157 struct GPU_EXPORT ContextState {
 158   ContextState(FeatureInfo* feature_info,
 159                ErrorStateClient* error_state_client,
 160                Logger* logger);
 161   ~ContextState();
 162
 163   void Initialize();
 164
 165   void SetIgnoreCachedStateForTest(bool ignore) {
 166     ignore_cached_state = ignore;
 167   }
 168
 169   void RestoreState(const ContextState* prev_state);
 170   void InitCapabilities(const ContextState* prev_state) const;
 171   void InitState(const ContextState* prev_state) const;
 172
 173   void RestoreActiveTexture() const;
 174   void RestoreAllTextureUnitBindings(const ContextState* prev_state) const;
 175   void RestoreActiveTextureUnitBinding(unsigned int target) const;
 176   void RestoreVertexAttribValues() const;
 177   void RestoreVertexAttribArrays(
 178       const scoped_refptr<VertexAttribManager> attrib_manager) const;
 179   void RestoreVertexAttribs() const;
 180   void RestoreBufferBindings() const;
 181   void RestoreGlobalState(const ContextState* prev_state) const;
 182   void RestoreProgramBindings() const;
 183   void RestoreRenderbufferBindings();
 184   void RestoreTextureUnitBindings(
 185       GLuint unit, const ContextState* prev_state) const;
 186
 187   // Helper for getting cached state.
 188   bool GetStateAsGLint(
 189       GLenum pname, GLint* params, GLsizei* num_written) const;
 190   bool GetStateAsGLfloat(
 191       GLenum pname, GLfloat* params, GLsizei* num_written) const;
 192   bool GetEnabled(GLenum cap) const;
 193
 194   inline void SetDeviceColorMask(GLboolean red,
 195                                  GLboolean green,
 196                                  GLboolean blue,
 197                                  GLboolean alpha) {
 198     if (cached_color_mask_red == red && cached_color_mask_green == green &&
 199         cached_color_mask_blue == blue && cached_color_mask_alpha == alpha &&
 200         !ignore_cached_state)
 201       return;
 202     cached_color_mask_red = red;
 203     cached_color_mask_green = green;
 204     cached_color_mask_blue = blue;
 205     cached_color_mask_alpha = alpha;
 206     glColorMask(red, green, blue, alpha);
 207   }
 208
 209   inline void SetDeviceDepthMask(GLboolean mask) {
 210     if (cached_depth_mask == mask && !ignore_cached_state)
 211       return;
 212     cached_depth_mask = mask;
 213     glDepthMask(mask);
 214   }
 215
 216   inline void SetDeviceStencilMaskSeparate(GLenum op, GLuint mask) {
 217     if (op == GL_FRONT) {
 218       if (cached_stencil_front_writemask == mask && !ignore_cached_state)
 219         return;
 220       cached_stencil_front_writemask = mask;
 221     } else if (op == GL_BACK) {
 222       if (cached_stencil_back_writemask == mask && !ignore_cached_state)
 223         return;
 224       cached_stencil_back_writemask = mask;
 225     } else {
 226       NOTREACHED();
 227       return;
 228     }
 229     glStencilMaskSeparate(op, mask);
 230   }
 231
 232   ErrorState* GetErrorState();
 233
 234   void SetBoundBuffer(GLenum target, Buffer* buffer);
 235   void RemoveBoundBuffer(Buffer* buffer);
 236
 237   #include "gpu/command_buffer/service/context_state_autogen.h"
 238
 239   EnableFlags enable_flags;
 240
 241   // Current active texture by 0 - n index.
 242   // In other words, if we call glActiveTexture(GL_TEXTURE2) this value would
 243   // be 2.
 244   GLuint active_texture_unit;
 245
 246   // The currently bound array buffer. If this is 0 it is illegal to call
 247   // glVertexAttribPointer.
 248   scoped_refptr<Buffer> bound_array_buffer;
 249
 250   scoped_refptr<Buffer> bound_copy_read_buffer;
 251   scoped_refptr<Buffer> bound_copy_write_buffer;
 252   scoped_refptr<Buffer> bound_pixel_pack_buffer;
 253   scoped_refptr<Buffer> bound_pixel_unpack_buffer;
 254   scoped_refptr<Buffer> bound_transform_feedback_buffer;
 255   scoped_refptr<Buffer> bound_uniform_buffer;
 256
 257   // Which textures are bound to texture units through glActiveTexture.
 258   std::vector<TextureUnit> texture_units;
 259
 260   // The values for each attrib.
 261   std::vector<Vec4> attrib_values;
 262
 263   // Class that manages vertex attribs.
 264   scoped_refptr<VertexAttribManager> vertex_attrib_manager;
 265   scoped_refptr<VertexAttribManager> default_vertex_attrib_manager;
 266
 267   // The program in use by glUseProgram
 268   scoped_refptr<Program> current_program;
 269
 270   // The currently bound renderbuffer
 271   scoped_refptr<Renderbuffer> bound_renderbuffer;
 272   bool bound_renderbuffer_valid;
 273
 274   // The currently bound valuebuffer
 275   scoped_refptr<Valuebuffer> bound_valuebuffer;
 276
 277   bool pack_reverse_row_order;
 278   bool ignore_cached_state;
 279
 280   mutable bool fbo_binding_for_scissor_workaround_dirty;
 281
 282  private:
 283   void EnableDisable(GLenum pname, bool enable) const;
 284
 285   FeatureInfo* feature_info_;
 286   scoped_ptr<ErrorState> error_state_;
 287 };
 288
 289 }  // namespace gles2
 290 }  // namespace gpu
 291
 292 #endif  // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_H_
 293