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_GLES2_IMPLEMENTATION_H_ 6 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ 7 8 #include <GLES2/gl2.h> 9 10 #include <map> 11 #include <queue> 12 #include <set> 13 #include <string> 14 #include <vector> 15 16 #include "base/memory/scoped_ptr.h" 17 #include "gles2_impl_export.h" 18 #include "gpu/command_buffer/client/buffer_tracker.h" 19 #include "gpu/command_buffer/client/client_context_state.h" 20 #include "gpu/command_buffer/client/gles2_cmd_helper.h" 21 #include "gpu/command_buffer/client/gles2_interface.h" 22 #include "gpu/command_buffer/client/gpu_memory_buffer_tracker.h" 23 #include "gpu/command_buffer/client/image_factory.h" 24 #include "gpu/command_buffer/client/query_tracker.h" 25 #include "gpu/command_buffer/client/ref_counted.h" 26 #include "gpu/command_buffer/client/ring_buffer.h" 27 #include "gpu/command_buffer/client/share_group.h" 28 #include "gpu/command_buffer/common/compiler_specific.h" 29 #include "gpu/command_buffer/common/debug_marker_manager.h" 30 #include "gpu/command_buffer/common/gles2_cmd_utils.h" 31 32 #if !defined(NDEBUG) && !defined(__native_client__) && !defined(GLES2_CONFORMANCE_TESTS) // NOLINT 33 #if defined(GLES2_INLINE_OPTIMIZATION) 34 // TODO(gman): Replace with macros that work with inline optmization. 35 #define GPU_CLIENT_SINGLE_THREAD_CHECK() 36 #define GPU_CLIENT_LOG(args) 37 #define GPU_CLIENT_LOG_CODE_BLOCK(code) 38 #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) 39 #else 40 #include "base/logging.h" 41 #define GPU_CLIENT_SINGLE_THREAD_CHECK() SingleThreadChecker checker(this); 42 #define GPU_CLIENT_LOG(args) DLOG_IF(INFO, debug_) << args; 43 #define GPU_CLIENT_LOG_CODE_BLOCK(code) code 44 #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) code 45 #define GPU_CLIENT_DEBUG 46 #endif 47 #else 48 #define GPU_CLIENT_SINGLE_THREAD_CHECK() 49 #define GPU_CLIENT_LOG(args) 50 #define GPU_CLIENT_LOG_CODE_BLOCK(code) 51 #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) 52 #endif 53 54 #if defined(GPU_CLIENT_DEBUG) 55 // Set to 1 to have the client fail when a GL error is generated. 56 // This helps find bugs in the renderer since the debugger stops on the error. 57 # if 0 58 # define GL_CLIENT_FAIL_GL_ERRORS 59 # endif 60 #endif 61 62 // Check that destination pointers point to initialized memory. 63 // When the context is lost, calling GL function has no effect so if destination 64 // pointers point to initialized memory it can often lead to crash bugs. eg. 65 // 66 // GLsizei len; 67 // glGetShaderSource(shader, max_size, &len, buffer); 68 // std::string src(buffer, buffer + len); // len can be uninitialized here!!! 69 // 70 // Because this check is not official GL this check happens only on Chrome code, 71 // not Pepper. 72 // 73 // If it was up to us we'd just always write to the destination but the OpenGL 74 // spec defines the behavior of OpenGL functions, not us. :-( 75 #if defined(__native_client__) || defined(GLES2_CONFORMANCE_TESTS) 76 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) 77 #define GPU_CLIENT_DCHECK(v) 78 #elif defined(GPU_DCHECK) 79 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) GPU_DCHECK(v) 80 #define GPU_CLIENT_DCHECK(v) GPU_DCHECK(v) 81 #elif defined(DCHECK) 82 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) DCHECK(v) 83 #define GPU_CLIENT_DCHECK(v) DCHECK(v) 84 #else 85 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) ASSERT(v) 86 #define GPU_CLIENT_DCHECK(v) ASSERT(v) 87 #endif 88 89 #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(type, ptr) \ 90 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(ptr && \ 91 (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1))); 92 93 #define GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(type, ptr) \ 94 GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(!ptr || \ 95 (ptr[0] == static_cast<type>(0) || ptr[0] == static_cast<type>(-1))); 96 97 struct GLUniformDefinitionCHROMIUM; 98 99 namespace gpu { 100 101 class MappedMemoryManager; 102 class ScopedTransferBufferPtr; 103 class TransferBufferInterface; 104 105 namespace gles2 { 106 107 class ImageFactory; 108 class VertexArrayObjectManager; 109 110 // This class emulates GLES2 over command buffers. It can be used by a client 111 // program so that the program does not need deal with shared memory and command 112 // buffer management. See gl2_lib.h. Note that there is a performance gain to 113 // be had by changing your code to use command buffers directly by using the 114 // GLES2CmdHelper but that entails changing your code to use and deal with 115 // shared memory and synchronization issues. 116 class GLES2_IMPL_EXPORT GLES2Implementation : public GLES2Interface { 117 public: 118 class ErrorMessageCallback { 119 public: 120 virtual ~ErrorMessageCallback() { } 121 virtual void OnErrorMessage(const char* msg, int id) = 0; 122 }; 123 124 // Stores GL state that never changes. 125 struct GLES2_IMPL_EXPORT GLStaticState { 126 GLStaticState(); 127 ~GLStaticState(); 128 129 struct GLES2_IMPL_EXPORT IntState { 130 IntState(); 131 GLint max_combined_texture_image_units; 132 GLint max_cube_map_texture_size; 133 GLint max_fragment_uniform_vectors; 134 GLint max_renderbuffer_size; 135 GLint max_texture_image_units; 136 GLint max_texture_size; 137 GLint max_varying_vectors; 138 GLint max_vertex_attribs; 139 GLint max_vertex_texture_image_units; 140 GLint max_vertex_uniform_vectors; 141 GLint num_compressed_texture_formats; 142 GLint num_shader_binary_formats; 143 }; 144 IntState int_state; 145 146 typedef std::pair<GLenum,GLenum> ShaderPrecisionKey; 147 typedef std::map<ShaderPrecisionKey, 148 cmds::GetShaderPrecisionFormat::Result> 149 ShaderPrecisionMap; 150 ShaderPrecisionMap shader_precisions; 151 }; 152 153 // The maxiumum result size from simple GL get commands. 154 static const size_t kMaxSizeOfSimpleResult = 16 * sizeof(uint32); // NOLINT. 155 156 // used for testing only. If more things are reseved add them here. 157 static const unsigned int kStartingOffset = kMaxSizeOfSimpleResult; 158 159 // Size in bytes to issue async flush for transfer buffer. 160 static const unsigned int kSizeToFlush = 256 * 1024; 161 162 // The bucket used for results. Public for testing only. 163 static const uint32 kResultBucketId = 1; 164 165 // Alignment of allocations. 166 static const unsigned int kAlignment = 4; 167 168 // GL names for the buffers used to emulate client side buffers. 169 static const GLuint kClientSideArrayId = 0xFEDCBA98u; 170 static const GLuint kClientSideElementArrayId = 0xFEDCBA99u; 171 172 // Number of swap buffers allowed before waiting. 173 static const size_t kMaxSwapBuffers = 2; 174 175 GLES2Implementation( 176 GLES2CmdHelper* helper, 177 ShareGroup* share_group, 178 TransferBufferInterface* transfer_buffer, 179 bool bind_generates_resource, 180 ImageFactory* image_factory); 181 182 virtual ~GLES2Implementation(); 183 184 bool Initialize( 185 unsigned int starting_transfer_buffer_size, 186 unsigned int min_transfer_buffer_size, 187 unsigned int max_transfer_buffer_size); 188 189 // The GLES2CmdHelper being used by this GLES2Implementation. You can use 190 // this to issue cmds at a lower level for certain kinds of optimization. 191 GLES2CmdHelper* helper() const; 192 193 // Gets client side generated errors. 194 GLenum GetClientSideGLError(); 195 196 // Include the auto-generated part of this class. We split this because 197 // it means we can easily edit the non-auto generated parts right here in 198 // this file instead of having to edit some template or the code generator. 199 #include "gpu/command_buffer/client/gles2_implementation_autogen.h" 200 201 virtual void DisableVertexAttribArray(GLuint index) OVERRIDE; 202 virtual void EnableVertexAttribArray(GLuint index) OVERRIDE; 203 virtual void GetVertexAttribfv( 204 GLuint index, GLenum pname, GLfloat* params) OVERRIDE; 205 virtual void GetVertexAttribiv( 206 GLuint index, GLenum pname, GLint* params) OVERRIDE; 207 208 void GetProgramInfoCHROMIUMHelper(GLuint program, std::vector<int8>* result); 209 GLint GetAttribLocationHelper(GLuint program, const char* name); 210 GLint GetUniformLocationHelper(GLuint program, const char* name); 211 bool GetActiveAttribHelper( 212 GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, 213 GLint* size, GLenum* type, char* name); 214 bool GetActiveUniformHelper( 215 GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, 216 GLint* size, GLenum* type, char* name); 217 218 void SetSharedMemoryChunkSizeMultiple(unsigned int multiple); 219 220 void FreeUnusedSharedMemory(); 221 void FreeEverything(); 222 223 void SetErrorMessageCallback(ErrorMessageCallback* callback) { 224 error_message_callback_ = callback; 225 } 226 227 ShareGroup* share_group() const { 228 return share_group_.get(); 229 } 230 231 private: 232 friend class GLES2ImplementationTest; 233 friend class VertexArrayObjectManager; 234 235 // Used to track whether an extension is available 236 enum ExtensionStatus { 237 kAvailableExtensionStatus, 238 kUnavailableExtensionStatus, 239 kUnknownExtensionStatus 240 }; 241 242 // Base class for mapped resources. 243 struct MappedResource { 244 MappedResource(GLenum _access, int _shm_id, void* mem, unsigned int offset) 245 : access(_access), 246 shm_id(_shm_id), 247 shm_memory(mem), 248 shm_offset(offset) { 249 } 250 251 // access mode. Currently only GL_WRITE_ONLY is valid 252 GLenum access; 253 254 // Shared memory ID for buffer. 255 int shm_id; 256 257 // Address of shared memory 258 void* shm_memory; 259 260 // Offset of shared memory 261 unsigned int shm_offset; 262 }; 263 264 // Used to track mapped textures. 265 struct MappedTexture : public MappedResource { 266 MappedTexture( 267 GLenum access, 268 int shm_id, 269 void* shm_mem, 270 unsigned int shm_offset, 271 GLenum _target, 272 GLint _level, 273 GLint _xoffset, 274 GLint _yoffset, 275 GLsizei _width, 276 GLsizei _height, 277 GLenum _format, 278 GLenum _type) 279 : MappedResource(access, shm_id, shm_mem, shm_offset), 280 target(_target), 281 level(_level), 282 xoffset(_xoffset), 283 yoffset(_yoffset), 284 width(_width), 285 height(_height), 286 format(_format), 287 type(_type) { 288 } 289 290 // These match the arguments to TexSubImage2D. 291 GLenum target; 292 GLint level; 293 GLint xoffset; 294 GLint yoffset; 295 GLsizei width; 296 GLsizei height; 297 GLenum format; 298 GLenum type; 299 }; 300 301 // Used to track mapped buffers. 302 struct MappedBuffer : public MappedResource { 303 MappedBuffer( 304 GLenum access, 305 int shm_id, 306 void* shm_mem, 307 unsigned int shm_offset, 308 GLenum _target, 309 GLintptr _offset, 310 GLsizeiptr _size) 311 : MappedResource(access, shm_id, shm_mem, shm_offset), 312 target(_target), 313 offset(_offset), 314 size(_size) { 315 } 316 317 // These match the arguments to BufferSubData. 318 GLenum target; 319 GLintptr offset; 320 GLsizeiptr size; 321 }; 322 323 struct TextureUnit { 324 TextureUnit() 325 : bound_texture_2d(0), 326 bound_texture_cube_map(0) { 327 } 328 329 // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture 330 GLuint bound_texture_2d; 331 332 // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with 333 // glBindTexture 334 GLuint bound_texture_cube_map; 335 }; 336 337 // Checks for single threaded access. 338 class SingleThreadChecker { 339 public: 340 SingleThreadChecker(GLES2Implementation* gles2_implementation); 341 ~SingleThreadChecker(); 342 343 private: 344 GLES2Implementation* gles2_implementation_; 345 }; 346 347 // Gets the value of the result. 348 template <typename T> 349 T GetResultAs() { 350 return static_cast<T>(GetResultBuffer()); 351 } 352 353 void* GetResultBuffer(); 354 int32 GetResultShmId(); 355 uint32 GetResultShmOffset(); 356 357 bool QueryAndCacheStaticState(); 358 359 // Helpers used to batch synchronous GetIntergerv calls with other 360 // synchronous calls. 361 struct GetMultipleIntegervState { 362 GetMultipleIntegervState(const GLenum* pnames, GLuint pnames_count, 363 GLint* results, GLsizeiptr results_size) 364 : pnames(pnames), 365 pnames_count(pnames_count), 366 results(results), 367 results_size(results_size) 368 { } 369 // inputs 370 const GLenum* pnames; 371 GLuint pnames_count; 372 // outputs 373 GLint* results; 374 GLsizeiptr results_size; 375 // transfer buffer 376 int num_results; 377 int transfer_buffer_size_needed; 378 void* buffer; 379 void* results_buffer; 380 }; 381 bool GetMultipleIntegervSetup( 382 GetMultipleIntegervState* state); 383 void GetMultipleIntegervRequest( 384 GetMultipleIntegervState* state); 385 void GetMultipleIntegervOnCompleted( 386 GetMultipleIntegervState* state); 387 388 // Helpers used to batch synchronous GetShaderPrecision calls with other 389 // synchronous calls. 390 struct GetAllShaderPrecisionFormatsState { 391 GetAllShaderPrecisionFormatsState( 392 const GLenum (*precision_params)[2], 393 int precision_params_count) 394 : precision_params(precision_params), 395 precision_params_count(precision_params_count) 396 { } 397 const GLenum (*precision_params)[2]; 398 int precision_params_count; 399 int transfer_buffer_size_needed; 400 void* results_buffer; 401 }; 402 void GetAllShaderPrecisionFormatsSetup( 403 GetAllShaderPrecisionFormatsState* state); 404 void GetAllShaderPrecisionFormatsRequest( 405 GetAllShaderPrecisionFormatsState* state); 406 void GetAllShaderPrecisionFormatsOnCompleted( 407 GetAllShaderPrecisionFormatsState* state); 408 409 // Lazily determines if GL_ANGLE_pack_reverse_row_order is available 410 bool IsAnglePackReverseRowOrderAvailable(); 411 bool IsChromiumFramebufferMultisampleAvailable(); 412 413 bool IsExtensionAvailableHelper( 414 const char* extension, ExtensionStatus* status); 415 416 // Gets the GLError through our wrapper. 417 GLenum GetGLError(); 418 419 // Sets our wrapper for the GLError. 420 void SetGLError(GLenum error, const char* function_name, const char* msg); 421 void SetGLErrorInvalidEnum( 422 const char* function_name, GLenum value, const char* label); 423 424 // Returns the last error and clears it. Useful for debugging. 425 const std::string& GetLastError() { 426 return last_error_; 427 } 428 429 // Waits for all commands to execute. 430 void WaitForCmd(); 431 432 // TODO(gman): These bucket functions really seem like they belong in 433 // CommandBufferHelper (or maybe BucketHelper?). Unfortunately they need 434 // a transfer buffer to function which is currently managed by this class. 435 436 // Gets the contents of a bucket. 437 bool GetBucketContents(uint32 bucket_id, std::vector<int8>* data); 438 439 // Sets the contents of a bucket. 440 void SetBucketContents(uint32 bucket_id, const void* data, size_t size); 441 442 // Sets the contents of a bucket as a string. 443 void SetBucketAsCString(uint32 bucket_id, const char* str); 444 445 // Gets the contents of a bucket as a string. Returns false if there is no 446 // string available which is a separate case from the empty string. 447 bool GetBucketAsString(uint32 bucket_id, std::string* str); 448 449 // Sets the contents of a bucket as a string. 450 void SetBucketAsString(uint32 bucket_id, const std::string& str); 451 452 // Returns true if id is reserved. 453 bool IsBufferReservedId(GLuint id); 454 bool IsFramebufferReservedId(GLuint id) { return false; } 455 bool IsRenderbufferReservedId(GLuint id) { return false; } 456 bool IsTextureReservedId(GLuint id) { return false; } 457 bool IsVertexArrayReservedId(GLuint id) { return false; } 458 459 bool BindBufferHelper(GLenum target, GLuint texture); 460 bool BindFramebufferHelper(GLenum target, GLuint texture); 461 bool BindRenderbufferHelper(GLenum target, GLuint texture); 462 bool BindTextureHelper(GLenum target, GLuint texture); 463 bool BindVertexArrayHelper(GLuint array); 464 465 void GenBuffersHelper(GLsizei n, const GLuint* buffers); 466 void GenFramebuffersHelper(GLsizei n, const GLuint* framebuffers); 467 void GenRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers); 468 void GenTexturesHelper(GLsizei n, const GLuint* textures); 469 void GenVertexArraysOESHelper(GLsizei n, const GLuint* arrays); 470 void GenQueriesEXTHelper(GLsizei n, const GLuint* queries); 471 472 void DeleteBuffersHelper(GLsizei n, const GLuint* buffers); 473 void DeleteFramebuffersHelper(GLsizei n, const GLuint* framebuffers); 474 void DeleteRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers); 475 void DeleteTexturesHelper(GLsizei n, const GLuint* textures); 476 bool DeleteProgramHelper(GLuint program); 477 bool DeleteShaderHelper(GLuint shader); 478 void DeleteQueriesEXTHelper(GLsizei n, const GLuint* queries); 479 void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* arrays); 480 481 void DeleteBuffersStub(GLsizei n, const GLuint* buffers); 482 void DeleteFramebuffersStub(GLsizei n, const GLuint* framebuffers); 483 void DeleteRenderbuffersStub(GLsizei n, const GLuint* renderbuffers); 484 void DeleteTexturesStub(GLsizei n, const GLuint* textures); 485 void DeleteProgramStub(GLsizei n, const GLuint* programs); 486 void DeleteShaderStub(GLsizei n, const GLuint* shaders); 487 // TODO(gman): Remove this as queries are not shared. 488 void DeleteQueriesStub(GLsizei n, const GLuint* queries); 489 void DeleteVertexArraysOESStub(GLsizei n, const GLuint* arrays); 490 491 void BufferDataHelper( 492 GLenum target, GLsizeiptr size, const void* data, GLenum usage); 493 void BufferSubDataHelper( 494 GLenum target, GLintptr offset, GLsizeiptr size, const void* data); 495 void BufferSubDataHelperImpl( 496 GLenum target, GLintptr offset, GLsizeiptr size, const void* data, 497 ScopedTransferBufferPtr* buffer); 498 499 GLuint CreateImageCHROMIUMHelper( 500 GLsizei width, GLsizei height, GLenum internalformat); 501 void DestroyImageCHROMIUMHelper(GLuint image_id); 502 void* MapImageCHROMIUMHelper(GLuint image_id, GLenum access); 503 void UnmapImageCHROMIUMHelper(GLuint image_id); 504 void GetImageParameterivCHROMIUMHelper( 505 GLuint image_id, GLenum pname, GLint* params); 506 507 // Helper for GetVertexAttrib 508 bool GetVertexAttribHelper(GLuint index, GLenum pname, uint32* param); 509 510 GLuint GetMaxValueInBufferCHROMIUMHelper( 511 GLuint buffer_id, GLsizei count, GLenum type, GLuint offset); 512 513 void RestoreElementAndArrayBuffers(bool restore); 514 void RestoreArrayBuffer(bool restrore); 515 516 // The pixels pointer should already account for unpack skip rows and skip 517 // pixels. 518 void TexSubImage2DImpl( 519 GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, 520 GLsizei height, GLenum format, GLenum type, uint32 unpadded_row_size, 521 const void* pixels, uint32 pixels_padded_row_size, GLboolean internal, 522 ScopedTransferBufferPtr* buffer, uint32 buffer_padded_row_size); 523 524 // Helpers for query functions. 525 bool GetHelper(GLenum pname, GLint* params); 526 bool GetBooleanvHelper(GLenum pname, GLboolean* params); 527 bool GetBufferParameterivHelper(GLenum target, GLenum pname, GLint* params); 528 bool GetFloatvHelper(GLenum pname, GLfloat* params); 529 bool GetFramebufferAttachmentParameterivHelper( 530 GLenum target, GLenum attachment, GLenum pname, GLint* params); 531 bool GetIntegervHelper(GLenum pname, GLint* params); 532 bool GetProgramivHelper(GLuint program, GLenum pname, GLint* params); 533 bool GetRenderbufferParameterivHelper( 534 GLenum target, GLenum pname, GLint* params); 535 bool GetShaderivHelper(GLuint shader, GLenum pname, GLint* params); 536 bool GetTexParameterfvHelper(GLenum target, GLenum pname, GLfloat* params); 537 bool GetTexParameterivHelper(GLenum target, GLenum pname, GLint* params); 538 const GLubyte* GetStringHelper(GLenum name); 539 540 bool IsExtensionAvailable(const char* ext); 541 542 // Caches certain capabilties state. Return true if cached. 543 bool SetCapabilityState(GLenum cap, bool enabled); 544 545 IdHandlerInterface* GetIdHandler(int id_namespace) const; 546 547 void FinishHelper(); 548 549 // Asserts that the context is lost. 550 // NOTE: This is an expensive call and should only be called 551 // for error checking. 552 bool MustBeContextLost(); 553 554 bool GetBoundPixelTransferBuffer( 555 GLenum target, const char* function_name, GLuint* buffer_id); 556 BufferTracker::Buffer* GetBoundPixelUnpackTransferBufferIfValid( 557 GLuint buffer_id, 558 const char* function_name, GLuint offset, GLsizei size); 559 560 const std::string& GetLogPrefix() const; 561 562 #if defined(GL_CLIENT_FAIL_GL_ERRORS) 563 void CheckGLError(); 564 void FailGLError(GLenum error); 565 #else 566 void CheckGLError() { } 567 void FailGLError(GLenum /* error */) { } 568 #endif 569 570 GLES2Util util_; 571 GLES2CmdHelper* helper_; 572 TransferBufferInterface* transfer_buffer_; 573 std::string last_error_; 574 DebugMarkerManager debug_marker_manager_; 575 std::string this_in_hex_; 576 577 std::queue<int32> swap_buffers_tokens_; 578 std::queue<int32> rate_limit_tokens_; 579 580 ExtensionStatus angle_pack_reverse_row_order_status_; 581 ExtensionStatus chromium_framebuffer_multisample_; 582 583 GLStaticState static_state_; 584 ClientContextState state_; 585 586 // pack alignment as last set by glPixelStorei 587 GLint pack_alignment_; 588 589 // unpack alignment as last set by glPixelStorei 590 GLint unpack_alignment_; 591 592 // unpack yflip as last set by glPixelstorei 593 bool unpack_flip_y_; 594 595 // unpack row length as last set by glPixelStorei 596 GLint unpack_row_length_; 597 598 // unpack skip rows as last set by glPixelStorei 599 GLint unpack_skip_rows_; 600 601 // unpack skip pixels as last set by glPixelStorei 602 GLint unpack_skip_pixels_; 603 604 // pack reverse row order as last set by glPixelstorei 605 bool pack_reverse_row_order_; 606 607 scoped_ptr<TextureUnit[]> texture_units_; 608 609 // 0 to gl_state_.max_combined_texture_image_units. 610 GLuint active_texture_unit_; 611 612 GLuint bound_framebuffer_; 613 GLuint bound_read_framebuffer_; 614 GLuint bound_renderbuffer_; 615 616 // The program in use by glUseProgram 617 GLuint current_program_; 618 619 // The currently bound array buffer. 620 GLuint bound_array_buffer_id_; 621 622 // The currently bound pixel transfer buffers. 623 GLuint bound_pixel_pack_transfer_buffer_id_; 624 GLuint bound_pixel_unpack_transfer_buffer_id_; 625 626 // Client side management for vertex array objects. Needed to correctly 627 // track client side arrays. 628 scoped_ptr<VertexArrayObjectManager> vertex_array_object_manager_; 629 630 GLuint reserved_ids_[2]; 631 632 // Current GL error bits. 633 uint32 error_bits_; 634 635 // Whether or not to print debugging info. 636 bool debug_; 637 638 // Used to check for single threaded access. 639 int use_count_; 640 641 // Map of GLenum to Strings for glGetString. We need to cache these because 642 // the pointer passed back to the client has to remain valid for eternity. 643 typedef std::map<uint32, std::set<std::string> > GLStringMap; 644 GLStringMap gl_strings_; 645 646 // Similar cache for glGetRequestableExtensionsCHROMIUM. We don't 647 // have an enum for this so handle it separately. 648 std::set<std::string> requestable_extensions_set_; 649 650 typedef std::map<const void*, MappedBuffer> MappedBufferMap; 651 MappedBufferMap mapped_buffers_; 652 653 typedef std::map<const void*, MappedTexture> MappedTextureMap; 654 MappedTextureMap mapped_textures_; 655 656 scoped_ptr<MappedMemoryManager> mapped_memory_; 657 658 scoped_refptr<ShareGroup> share_group_; 659 660 scoped_ptr<QueryTracker> query_tracker_; 661 QueryTracker::Query* current_query_; 662 663 scoped_ptr<BufferTracker> buffer_tracker_; 664 665 scoped_ptr<GpuMemoryBufferTracker> gpu_memory_buffer_tracker_; 666 667 ErrorMessageCallback* error_message_callback_; 668 669 scoped_ptr<std::string> current_trace_name_; 670 671 ImageFactory* image_factory_; 672 673 DISALLOW_COPY_AND_ASSIGN(GLES2Implementation); 674 }; 675 676 inline bool GLES2Implementation::GetBufferParameterivHelper( 677 GLenum /* target */, GLenum /* pname */, GLint* /* params */) { 678 return false; 679 } 680 681 inline bool GLES2Implementation::GetFramebufferAttachmentParameterivHelper( 682 GLenum /* target */, 683 GLenum /* attachment */, 684 GLenum /* pname */, 685 GLint* /* params */) { 686 return false; 687 } 688 689 inline bool GLES2Implementation::GetRenderbufferParameterivHelper( 690 GLenum /* target */, GLenum /* pname */, GLint* /* params */) { 691 return false; 692 } 693 694 inline bool GLES2Implementation::GetShaderivHelper( 695 GLuint /* shader */, GLenum /* pname */, GLint* /* params */) { 696 return false; 697 } 698 699 inline bool GLES2Implementation::GetTexParameterfvHelper( 700 GLenum /* target */, GLenum /* pname */, GLfloat* /* params */) { 701 return false; 702 } 703 704 inline bool GLES2Implementation::GetTexParameterivHelper( 705 GLenum /* target */, GLenum /* pname */, GLint* /* params */) { 706 return false; 707 } 708 709 } // namespace gles2 710 } // namespace gpu 711 712 #endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ 713