// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_ #include #include #include #include #include #include #include #include #include #include #include "base/compiler_specific.h" #include "base/macros.h" #include "base/memory/weak_ptr.h" #include "base/trace_event/memory_dump_provider.h" #include "gpu/command_buffer/client/buffer_tracker.h" #include "gpu/command_buffer/client/client_context_state.h" #include "gpu/command_buffer/client/context_support.h" #include "gpu/command_buffer/client/gles2_impl_export.h" #include "gpu/command_buffer/client/gles2_interface.h" #include "gpu/command_buffer/client/gpu_control_client.h" #include "gpu/command_buffer/client/mapped_memory.h" #include "gpu/command_buffer/client/ref_counted.h" #include "gpu/command_buffer/client/share_group.h" #include "gpu/command_buffer/common/capabilities.h" #include "gpu/command_buffer/common/debug_marker_manager.h" #include "gpu/command_buffer/common/gles2_cmd_utils.h" #if !defined(NDEBUG) && !defined(__native_client__) && !defined(GLES2_CONFORMANCE_TESTS) // NOLINT #if defined(GLES2_INLINE_OPTIMIZATION) // TODO(gman): Replace with macros that work with inline optmization. #define GPU_CLIENT_SINGLE_THREAD_CHECK() #define GPU_CLIENT_LOG(args) #define GPU_CLIENT_LOG_CODE_BLOCK(code) #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) #else #include "base/logging.h" #define GPU_CLIENT_SINGLE_THREAD_CHECK() SingleThreadChecker checker(this); #define GPU_CLIENT_LOG(args) DLOG_IF(INFO, debug_) << args; #define GPU_CLIENT_LOG_CODE_BLOCK(code) code #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) code #define GPU_CLIENT_DEBUG #endif #else #define GPU_CLIENT_SINGLE_THREAD_CHECK() #define GPU_CLIENT_LOG(args) #define GPU_CLIENT_LOG_CODE_BLOCK(code) #define GPU_CLIENT_DCHECK_CODE_BLOCK(code) #endif #if defined(GPU_CLIENT_DEBUG) // Set to 1 to have the client fail when a GL error is generated. // This helps find bugs in the renderer since the debugger stops on the error. # if 0 # define GL_CLIENT_FAIL_GL_ERRORS # endif #endif // Check that destination pointers point to initialized memory. // When the context is lost, calling GL function has no effect so if destination // pointers point to initialized memory it can often lead to crash bugs. eg. // // GLsizei len; // glGetShaderSource(shader, max_size, &len, buffer); // std::string src(buffer, buffer + len); // len can be uninitialized here!!! // // Because this check is not official GL this check happens only on Chrome code, // not Pepper. // // If it was up to us we'd just always write to the destination but the OpenGL // spec defines the behavior of OpenGL functions, not us. :-( #if defined(__native_client__) || defined(GLES2_CONFORMANCE_TESTS) #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) #define GPU_CLIENT_DCHECK(v) #elif defined(GPU_DCHECK) #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) GPU_DCHECK(v) #define GPU_CLIENT_DCHECK(v) GPU_DCHECK(v) #elif defined(DCHECK) #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) DCHECK(v) #define GPU_CLIENT_DCHECK(v) DCHECK(v) #else #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(v) ASSERT(v) #define GPU_CLIENT_DCHECK(v) ASSERT(v) #endif #define GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(type, ptr) \ GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(ptr && \ (ptr[0] == static_cast(0) || ptr[0] == static_cast(-1))); #define GPU_CLIENT_VALIDATE_DESTINATION_OPTIONAL_INITALIZATION(type, ptr) \ GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION_ASSERT(!ptr || \ (ptr[0] == static_cast(0) || ptr[0] == static_cast(-1))); namespace gpu { class GpuControl; class IdAllocator; class ScopedTransferBufferPtr; class TransferBufferInterface; namespace gles2 { class GLES2CmdHelper; class VertexArrayObjectManager; class QueryTracker; // This class emulates GLES2 over command buffers. It can be used by a client // program so that the program does not need deal with shared memory and command // buffer management. See gl2_lib.h. Note that there is a performance gain to // be had by changing your code to use command buffers directly by using the // GLES2CmdHelper but that entails changing your code to use and deal with // shared memory and synchronization issues. class GLES2_IMPL_EXPORT GLES2Implementation : NON_EXPORTED_BASE(public GLES2Interface), NON_EXPORTED_BASE(public ContextSupport), NON_EXPORTED_BASE(public GpuControlClient), NON_EXPORTED_BASE(public base::trace_event::MemoryDumpProvider) { public: // Stores GL state that never changes. struct GLES2_IMPL_EXPORT GLStaticState { GLStaticState(); ~GLStaticState(); typedef std::pair ShaderPrecisionKey; typedef std::map ShaderPrecisionMap; ShaderPrecisionMap shader_precisions; }; // The maximum result size from simple GL get commands. static const size_t kMaxSizeOfSimpleResult = 16 * sizeof(uint32_t); // NOLINT. // used for testing only. If more things are reseved add them here. static const unsigned int kStartingOffset = kMaxSizeOfSimpleResult; // Size in bytes to issue async flush for transfer buffer. static const unsigned int kSizeToFlush = 256 * 1024; // The bucket used for results. Public for testing only. static const uint32_t kResultBucketId = 1; // Alignment of allocations. static const unsigned int kAlignment = 16; // GL names for the buffers used to emulate client side buffers. static const GLuint kClientSideArrayId = 0xFEDCBA98u; static const GLuint kClientSideElementArrayId = 0xFEDCBA99u; // Number of swap buffers allowed before waiting. static const size_t kMaxSwapBuffers = 2; GLES2Implementation(GLES2CmdHelper* helper, scoped_refptr share_group, TransferBufferInterface* transfer_buffer, bool bind_generates_resource, bool lose_context_when_out_of_memory, bool support_client_side_arrays, GpuControl* gpu_control); ~GLES2Implementation() override; bool Initialize( unsigned int starting_transfer_buffer_size, unsigned int min_transfer_buffer_size, unsigned int max_transfer_buffer_size, unsigned int mapped_memory_limit); // The GLES2CmdHelper being used by this GLES2Implementation. You can use // this to issue cmds at a lower level for certain kinds of optimization. GLES2CmdHelper* helper() const; // Gets client side generated errors. GLenum GetClientSideGLError(); // Include the auto-generated part of this class. We split this because // it means we can easily edit the non-auto generated parts right here in // this file instead of having to edit some template or the code generator. #include "gpu/command_buffer/client/gles2_implementation_autogen.h" // ContextSupport implementation. void Swap() override; void SwapWithDamage(const gfx::Rect& damage) override; void PartialSwapBuffers(const gfx::Rect& sub_buffer) override; void CommitOverlayPlanes() override; void ScheduleOverlayPlane(int plane_z_order, gfx::OverlayTransform plane_transform, unsigned overlay_texture_id, const gfx::Rect& display_bounds, const gfx::RectF& uv_rect) override; uint64_t ShareGroupTracingGUID() const override; void SetErrorMessageCallback( const base::Callback& callback) override; // TODO(danakj): Move to ContextSupport once ContextProvider doesn't need to // intercept it. void SetLostContextCallback(const base::Closure& callback); void GetProgramInfoCHROMIUMHelper(GLuint program, std::vector* result); GLint GetAttribLocationHelper(GLuint program, const char* name); GLint GetUniformLocationHelper(GLuint program, const char* name); GLint GetFragDataIndexEXTHelper(GLuint program, const char* name); GLint GetFragDataLocationHelper(GLuint program, const char* name); bool GetActiveAttribHelper( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name); bool GetActiveUniformHelper( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name); void GetUniformBlocksCHROMIUMHelper(GLuint program, std::vector* result); void GetUniformsES3CHROMIUMHelper(GLuint program, std::vector* result); GLuint GetUniformBlockIndexHelper(GLuint program, const char* name); bool GetActiveUniformBlockNameHelper( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, char* name); bool GetActiveUniformBlockivHelper( GLuint program, GLuint index, GLenum pname, GLint* params); void GetTransformFeedbackVaryingsCHROMIUMHelper(GLuint program, std::vector* result); bool GetTransformFeedbackVaryingHelper( GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name); bool GetUniformIndicesHelper( GLuint program, GLsizei count, const char* const* names, GLuint* indices); bool GetActiveUniformsivHelper( GLuint program, GLsizei count, const GLuint* indices, GLenum pname, GLint* params); bool GetSyncivHelper( GLsync sync, GLenum pname, GLsizei bufsize, GLsizei* length, GLint* values); bool GetQueryObjectValueHelper( const char* function_name, GLuint id, GLenum pname, GLuint64* params); void FreeUnusedSharedMemory(); void FreeEverything(); void FreeSharedMemory(void*) override; // ContextSupport implementation. void SignalSyncToken(const gpu::SyncToken& sync_token, const base::Closure& callback) override; void SignalQuery(uint32_t query, const base::Closure& callback) override; void SetAggressivelyFreeResources(bool aggressively_free_resources) override; // base::trace_event::MemoryDumpProvider implementation. bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args, base::trace_event::ProcessMemoryDump* pmd) override; const scoped_refptr& share_group() const { return share_group_; } const Capabilities& capabilities() const { return capabilities_; } GpuControl* gpu_control() { return gpu_control_; } ShareGroupContextData* share_group_context_data() { return &share_group_context_data_; } private: friend class GLES2ImplementationTest; friend class VertexArrayObjectManager; friend class QueryTracker; // Used to track whether an extension is available enum ExtensionStatus { kAvailableExtensionStatus, kUnavailableExtensionStatus, kUnknownExtensionStatus }; enum Dimension { k2D, k3D, }; // Base class for mapped resources. struct MappedResource { MappedResource(GLenum _access, int _shm_id, void* mem, unsigned int offset) : access(_access), shm_id(_shm_id), shm_memory(mem), shm_offset(offset) { } // access mode. Currently only GL_WRITE_ONLY is valid GLenum access; // Shared memory ID for buffer. int shm_id; // Address of shared memory void* shm_memory; // Offset of shared memory unsigned int shm_offset; }; // Used to track mapped textures. struct MappedTexture : public MappedResource { MappedTexture( GLenum access, int shm_id, void* shm_mem, unsigned int shm_offset, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLsizei _width, GLsizei _height, GLenum _format, GLenum _type) : MappedResource(access, shm_id, shm_mem, shm_offset), target(_target), level(_level), xoffset(_xoffset), yoffset(_yoffset), width(_width), height(_height), format(_format), type(_type) { } // These match the arguments to TexSubImage2D. GLenum target; GLint level; GLint xoffset; GLint yoffset; GLsizei width; GLsizei height; GLenum format; GLenum type; }; // Used to track mapped buffers. struct MappedBuffer : public MappedResource { MappedBuffer( GLenum access, int shm_id, void* shm_mem, unsigned int shm_offset, GLenum _target, GLintptr _offset, GLsizeiptr _size) : MappedResource(access, shm_id, shm_mem, shm_offset), target(_target), offset(_offset), size(_size) { } // These match the arguments to BufferSubData. GLenum target; GLintptr offset; GLsizeiptr size; }; struct TextureUnit { TextureUnit() : bound_texture_2d(0), bound_texture_cube_map(0), bound_texture_external_oes(0) {} // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture GLuint bound_texture_2d; // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with // glBindTexture GLuint bound_texture_cube_map; // texture currently bound to this unit's GL_TEXTURE_EXTERNAL_OES with // glBindTexture GLuint bound_texture_external_oes; }; // Checks for single threaded access. class SingleThreadChecker { public: explicit SingleThreadChecker(GLES2Implementation* gles2_implementation); ~SingleThreadChecker(); private: GLES2Implementation* gles2_implementation_; }; // Gets the value of the result. template T GetResultAs() { return static_cast(GetResultBuffer()); } // GpuControlClient implementation. void OnGpuControlLostContext() final; void OnGpuControlLostContextMaybeReentrant() final; void OnGpuControlErrorMessage(const char* message, int32_t id) final; void* GetResultBuffer(); int32_t GetResultShmId(); uint32_t GetResultShmOffset(); bool IsChromiumFramebufferMultisampleAvailable(); bool IsExtensionAvailableHelper( const char* extension, ExtensionStatus* status); // Gets the GLError through our wrapper. GLenum GetGLError(); // Sets our wrapper for the GLError. void SetGLError(GLenum error, const char* function_name, const char* msg); void SetGLErrorInvalidEnum( const char* function_name, GLenum value, const char* label); // Returns the last error and clears it. Useful for debugging. const std::string& GetLastError() { return last_error_; } // Waits for all commands to execute. void WaitForCmd(); // TODO(gman): These bucket functions really seem like they belong in // CommandBufferHelper (or maybe BucketHelper?). Unfortunately they need // a transfer buffer to function which is currently managed by this class. // Gets the contents of a bucket. bool GetBucketContents(uint32_t bucket_id, std::vector* data); // Sets the contents of a bucket. void SetBucketContents(uint32_t bucket_id, const void* data, size_t size); // Sets the contents of a bucket as a string. void SetBucketAsCString(uint32_t bucket_id, const char* str); // Gets the contents of a bucket as a string. Returns false if there is no // string available which is a separate case from the empty string. bool GetBucketAsString(uint32_t bucket_id, std::string* str); // Sets the contents of a bucket as a string. void SetBucketAsString(uint32_t bucket_id, const std::string& str); // Returns true if id is reserved. bool IsBufferReservedId(GLuint id); bool IsFramebufferReservedId(GLuint id) { return false; } bool IsRenderbufferReservedId(GLuint id) { return false; } bool IsTextureReservedId(GLuint id) { return false; } bool IsVertexArrayReservedId(GLuint id) { return false; } bool IsProgramReservedId(GLuint id) { return false; } bool IsSamplerReservedId(GLuint id) { return false; } bool IsTransformFeedbackReservedId(GLuint id) { return false; } void BindBufferHelper(GLenum target, GLuint buffer); void BindBufferBaseHelper(GLenum target, GLuint index, GLuint buffer); void BindBufferRangeHelper(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); void BindFramebufferHelper(GLenum target, GLuint framebuffer); void BindRenderbufferHelper(GLenum target, GLuint renderbuffer); void BindSamplerHelper(GLuint unit, GLuint sampler); void BindTextureHelper(GLenum target, GLuint texture); void BindTransformFeedbackHelper(GLenum target, GLuint transformfeedback); void BindVertexArrayOESHelper(GLuint array); void UseProgramHelper(GLuint program); void BindBufferStub(GLenum target, GLuint buffer); void BindBufferBaseStub(GLenum target, GLuint index, GLuint buffer); void BindBufferRangeStub(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); void BindFramebufferStub(GLenum target, GLuint framebuffer); void BindRenderbufferStub(GLenum target, GLuint renderbuffer); void BindTextureStub(GLenum target, GLuint texture); void GenBuffersHelper(GLsizei n, const GLuint* buffers); void GenFramebuffersHelper(GLsizei n, const GLuint* framebuffers); void GenRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers); void GenTexturesHelper(GLsizei n, const GLuint* textures); void GenVertexArraysOESHelper(GLsizei n, const GLuint* arrays); void GenQueriesEXTHelper(GLsizei n, const GLuint* queries); void GenSamplersHelper(GLsizei n, const GLuint* samplers); void GenTransformFeedbacksHelper(GLsizei n, const GLuint* transformfeedbacks); void DeleteBuffersHelper(GLsizei n, const GLuint* buffers); void DeleteFramebuffersHelper(GLsizei n, const GLuint* framebuffers); void DeleteRenderbuffersHelper(GLsizei n, const GLuint* renderbuffers); void DeleteTexturesHelper(GLsizei n, const GLuint* textures); bool DeleteProgramHelper(GLuint program); bool DeleteShaderHelper(GLuint shader); void DeleteQueriesEXTHelper(GLsizei n, const GLuint* queries); void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* arrays); void DeleteSamplersHelper(GLsizei n, const GLuint* samplers); void DeleteTransformFeedbacksHelper( GLsizei n, const GLuint* transformfeedbacks); void DeleteSyncHelper(GLsync sync); void DeleteBuffersStub(GLsizei n, const GLuint* buffers); void DeleteFramebuffersStub(GLsizei n, const GLuint* framebuffers); void DeleteRenderbuffersStub(GLsizei n, const GLuint* renderbuffers); void DeleteTexturesStub(GLsizei n, const GLuint* textures); void DeletePathsCHROMIUMStub(GLuint first_client_id, GLsizei range); void DeleteProgramStub(GLsizei n, const GLuint* programs); void DeleteShaderStub(GLsizei n, const GLuint* shaders); void DeleteVertexArraysOESStub(GLsizei n, const GLuint* arrays); void DeleteSamplersStub(GLsizei n, const GLuint* samplers); void DeleteTransformFeedbacksStub( GLsizei n, const GLuint* transformfeedbacks); void DeleteSyncStub(GLsizei n, const GLuint* syncs); void BufferDataHelper( GLenum target, GLsizeiptr size, const void* data, GLenum usage); void BufferSubDataHelper( GLenum target, GLintptr offset, GLsizeiptr size, const void* data); void BufferSubDataHelperImpl( GLenum target, GLintptr offset, GLsizeiptr size, const void* data, ScopedTransferBufferPtr* buffer); GLuint CreateImageCHROMIUMHelper(ClientBuffer buffer, GLsizei width, GLsizei height, GLenum internalformat); void DestroyImageCHROMIUMHelper(GLuint image_id); GLuint CreateGpuMemoryBufferImageCHROMIUMHelper(GLsizei width, GLsizei height, GLenum internalformat, GLenum usage); // Helper for GetVertexAttrib bool GetVertexAttribHelper(GLuint index, GLenum pname, uint32_t* param); GLuint GetMaxValueInBufferCHROMIUMHelper( GLuint buffer_id, GLsizei count, GLenum type, GLuint offset); void WaitAllAsyncTexImage2DCHROMIUMHelper(); void RestoreElementAndArrayBuffers(bool restore); void RestoreArrayBuffer(bool restrore); // The pixels pointer should already account for unpack skip // images/rows/pixels. void TexSubImage2DImpl(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, uint32_t unpadded_row_size, const void* pixels, uint32_t pixels_padded_row_size, GLboolean internal, ScopedTransferBufferPtr* buffer, uint32_t buffer_padded_row_size); void TexSubImage3DImpl(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, uint32_t unpadded_row_size, const void* pixels, uint32_t pixels_padded_row_size, GLboolean internal, ScopedTransferBufferPtr* buffer, uint32_t buffer_padded_row_size); // Helpers for query functions. bool GetHelper(GLenum pname, GLint* params); GLuint GetBoundBufferHelper(GLenum target); bool GetBooleanvHelper(GLenum pname, GLboolean* params); bool GetBufferParameteri64vHelper( GLenum target, GLenum pname, GLint64* params); bool GetBufferParameterivHelper(GLenum target, GLenum pname, GLint* params); bool GetFloatvHelper(GLenum pname, GLfloat* params); bool GetFramebufferAttachmentParameterivHelper( GLenum target, GLenum attachment, GLenum pname, GLint* params); bool GetInteger64vHelper(GLenum pname, GLint64* params); bool GetIntegervHelper(GLenum pname, GLint* params); bool GetIntegeri_vHelper(GLenum pname, GLuint index, GLint* data); bool GetInteger64i_vHelper(GLenum pname, GLuint index, GLint64* data); bool GetInternalformativHelper( GLenum target, GLenum format, GLenum pname, GLsizei bufSize, GLint* params); bool GetProgramivHelper(GLuint program, GLenum pname, GLint* params); bool GetSamplerParameterfvHelper( GLuint sampler, GLenum pname, GLfloat* params); bool GetSamplerParameterivHelper( GLuint sampler, GLenum pname, GLint* params); bool GetRenderbufferParameterivHelper( GLenum target, GLenum pname, GLint* params); bool GetShaderivHelper(GLuint shader, GLenum pname, GLint* params); bool GetTexParameterfvHelper(GLenum target, GLenum pname, GLfloat* params); bool GetTexParameterivHelper(GLenum target, GLenum pname, GLint* params); const GLubyte* GetStringHelper(GLenum name); bool IsExtensionAvailable(const char* ext); // Caches certain capabilties state. Return true if cached. bool SetCapabilityState(GLenum cap, bool enabled); IdHandlerInterface* GetIdHandler(int id_namespace) const; RangeIdHandlerInterface* GetRangeIdHandler(int id_namespace) const; // IdAllocators for objects that can't be shared among contexts. // For now, used only for Queries. TODO(hj.r.chung) Should be added for // Framebuffer and Vertex array objects. IdAllocator* GetIdAllocator(int id_namespace) const; void FinishHelper(); void FlushHelper(); void RunIfContextNotLost(const base::Closure& callback); // Validate if an offset is valid, i.e., non-negative and fit into 32-bit. // If not, generate an approriate error, and return false. bool ValidateOffset(const char* func, GLintptr offset); // Validate if a size is valid, i.e., non-negative and fit into 32-bit. // If not, generate an approriate error, and return false. bool ValidateSize(const char* func, GLsizeiptr offset); // Remove the transfer buffer from the buffer tracker. For buffers used // asynchronously the memory is free:ed if the upload has completed. For // other buffers, the memory is either free:ed immediately or free:ed pending // a token. void RemoveTransferBuffer(BufferTracker::Buffer* buffer); bool GetBoundPixelTransferBuffer( GLenum target, const char* function_name, GLuint* buffer_id); BufferTracker::Buffer* GetBoundPixelTransferBufferIfValid( GLuint buffer_id, const char* function_name, GLuint offset, GLsizei size); // Pack 2D arrays of char into a bucket. // Helper function for ShaderSource(), TransformFeedbackVaryings(), etc. bool PackStringsToBucket(GLsizei count, const char* const* str, const GLint* length, const char* func_name); const std::string& GetLogPrefix() const; bool PrepareInstancedPathCommand(const char* function_name, GLsizei num_paths, GLenum path_name_type, const void* paths, GLenum transform_type, const GLfloat* transform_values, ScopedTransferBufferPtr* buffer, uint32_t* out_paths_shm_id, size_t* out_paths_offset, uint32_t* out_transforms_shm_id, size_t* out_transforms_offset); #if defined(GL_CLIENT_FAIL_GL_ERRORS) void CheckGLError(); void FailGLError(GLenum error); #else void CheckGLError() { } void FailGLError(GLenum /* error */) { } #endif void RemoveMappedBufferRangeByTarget(GLenum target); void RemoveMappedBufferRangeById(GLuint buffer); void ClearMappedBufferRangeMap(); void DrawElementsImpl(GLenum mode, GLsizei count, GLenum type, const void* indices, const char* func_name); void UpdateCachedExtensionsIfNeeded(); void InvalidateCachedExtensions(); PixelStoreParams GetUnpackParameters(Dimension dimension); GLES2Util util_; GLES2CmdHelper* helper_; TransferBufferInterface* transfer_buffer_; std::string last_error_; DebugMarkerManager debug_marker_manager_; std::string this_in_hex_; std::queue swap_buffers_tokens_; std::queue rate_limit_tokens_; ExtensionStatus chromium_framebuffer_multisample_; GLStaticState static_state_; ClientContextState state_; // pack alignment as last set by glPixelStorei GLint pack_alignment_; // pack row length as last set by glPixelStorei GLint pack_row_length_; // pack skip pixels as last set by glPixelStorei GLint pack_skip_pixels_; // pack skip rows as last set by glPixelStorei GLint pack_skip_rows_; // unpack alignment as last set by glPixelStorei GLint unpack_alignment_; // unpack row length as last set by glPixelStorei GLint unpack_row_length_; // unpack image height as last set by glPixelStorei GLint unpack_image_height_; // unpack skip rows as last set by glPixelStorei GLint unpack_skip_rows_; // unpack skip pixels as last set by glPixelStorei GLint unpack_skip_pixels_; // unpack skip images as last set by glPixelStorei GLint unpack_skip_images_; std::unique_ptr texture_units_; // 0 to gl_state_.max_combined_texture_image_units. GLuint active_texture_unit_; GLuint bound_framebuffer_; GLuint bound_read_framebuffer_; GLuint bound_renderbuffer_; // The program in use by glUseProgram GLuint current_program_; GLuint bound_array_buffer_; GLuint bound_copy_read_buffer_; GLuint bound_copy_write_buffer_; GLuint bound_pixel_pack_buffer_; GLuint bound_pixel_unpack_buffer_; GLuint bound_transform_feedback_buffer_; GLuint bound_uniform_buffer_; // The currently bound pixel transfer buffers. GLuint bound_pixel_pack_transfer_buffer_id_; GLuint bound_pixel_unpack_transfer_buffer_id_; // Client side management for vertex array objects. Needed to correctly // track client side arrays. std::unique_ptr vertex_array_object_manager_; GLuint reserved_ids_[2]; // Current GL error bits. uint32_t error_bits_; // Whether or not to print debugging info. bool debug_; // When true, the context is lost when a GL_OUT_OF_MEMORY error occurs. const bool lose_context_when_out_of_memory_; // Whether or not to support client side arrays. const bool support_client_side_arrays_; // Used to check for single threaded access. int use_count_; // Changed every time a flush or finish occurs. uint32_t flush_id_; // Maximum amount of extra memory from the mapped memory pool to use when // needing to transfer something exceeding the default transfer buffer. // This should be 0 for low memory devices since they are already memory // constrained. const uint32_t max_extra_transfer_buffer_size_; // Set of strings returned from glGetString. We need to cache these because // the pointer passed back to the client has to remain valid for eternity. std::set gl_strings_; typedef std::map MappedBufferMap; MappedBufferMap mapped_buffers_; // TODO(zmo): Consolidate |mapped_buffers_| and |mapped_buffer_range_map_|. typedef base::hash_map MappedBufferRangeMap; MappedBufferRangeMap mapped_buffer_range_map_; typedef std::map MappedTextureMap; MappedTextureMap mapped_textures_; std::unique_ptr mapped_memory_; scoped_refptr share_group_; ShareGroupContextData share_group_context_data_; std::unique_ptr query_tracker_; std::unique_ptr query_id_allocator_; std::unique_ptr buffer_tracker_; base::Callback error_message_callback_; base::Closure lost_context_callback_; bool lost_context_callback_run_ = false; int current_trace_stack_; GpuControl* gpu_control_; Capabilities capabilities_; // Flag to indicate whether the implementation can retain resources, or // whether it should aggressively free them. bool aggressively_free_resources_; // Result of last GetString(GL_EXTENSIONS), used to keep // GetString(GL_EXTENSIONS), GetStringi(GL_EXTENSIONS, index) and // GetIntegerv(GL_NUM_EXTENSIONS) in sync. This points to gl_strings, valid // forever. const char* cached_extension_string_; // Populated if cached_extension_string_ != nullptr. These point to // gl_strings, valid forever. std::vector cached_extensions_; base::WeakPtrFactory weak_ptr_factory_; DISALLOW_COPY_AND_ASSIGN(GLES2Implementation); }; inline bool GLES2Implementation::GetBufferParameteri64vHelper( GLenum /* target */, GLenum /* pname */, GLint64* /* params */) { return false; } inline bool GLES2Implementation::GetBufferParameterivHelper( GLenum /* target */, GLenum /* pname */, GLint* /* params */) { return false; } inline bool GLES2Implementation::GetFramebufferAttachmentParameterivHelper( GLenum /* target */, GLenum /* attachment */, GLenum /* pname */, GLint* /* params */) { return false; } inline bool GLES2Implementation::GetRenderbufferParameterivHelper( GLenum /* target */, GLenum /* pname */, GLint* /* params */) { return false; } inline bool GLES2Implementation::GetShaderivHelper( GLuint /* shader */, GLenum /* pname */, GLint* /* params */) { return false; } inline bool GLES2Implementation::GetTexParameterfvHelper( GLenum /* target */, GLenum /* pname */, GLfloat* /* params */) { return false; } inline bool GLES2Implementation::GetTexParameterivHelper( GLenum /* target */, GLenum /* pname */, GLint* /* params */) { return false; } } // namespace gles2 } // namespace gpu #endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_