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.
5 #include "gpu/command_buffer/service/texture_manager.h"
7 #include "base/strings/stringprintf.h"
8 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
9 #include "gpu/command_buffer/service/context_state.h"
10 #include "gpu/command_buffer/service/error_state.h"
11 #include "gpu/command_buffer/service/feature_info.h"
12 #include "gpu/command_buffer/service/framebuffer_manager.h"
13 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
14 #include "gpu/command_buffer/service/mailbox_manager.h"
15 #include "gpu/command_buffer/service/memory_tracking.h"
20 static size_t GLTargetToFaceIndex(GLenum target) {
23 case GL_TEXTURE_EXTERNAL_OES:
24 case GL_TEXTURE_RECTANGLE_ARB:
26 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
28 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
30 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
32 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
34 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
36 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
44 static size_t FaceIndexToGLTarget(size_t index) {
47 return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
49 return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
51 return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
53 return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
55 return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
57 return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
64 TextureManager::DestructionObserver::DestructionObserver() {}
66 TextureManager::DestructionObserver::~DestructionObserver() {}
68 TextureManager::~TextureManager() {
69 for (unsigned int i = 0; i < destruction_observers_.size(); i++)
70 destruction_observers_[i]->OnTextureManagerDestroying(this);
72 DCHECK(textures_.empty());
74 // If this triggers, that means something is keeping a reference to
75 // a Texture belonging to this.
76 CHECK_EQ(texture_count_, 0u);
78 DCHECK_EQ(0, num_unrenderable_textures_);
79 DCHECK_EQ(0, num_unsafe_textures_);
80 DCHECK_EQ(0, num_uncleared_mips_);
81 DCHECK_EQ(0, num_images_);
84 void TextureManager::Destroy(bool have_context) {
85 have_context_ = have_context;
87 for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
88 default_textures_[ii] = NULL;
92 glDeleteTextures(arraysize(black_texture_ids_), black_texture_ids_);
95 DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
96 DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
99 Texture::Texture(GLuint service_id)
100 : mailbox_manager_(NULL),
101 memory_tracking_ref_(NULL),
102 service_id_(service_id),
104 num_uncleared_mips_(0),
106 min_filter_(GL_NEAREST_MIPMAP_LINEAR),
107 mag_filter_(GL_LINEAR),
111 pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
113 texture_complete_(false),
114 cube_complete_(false),
116 has_been_bound_(false),
117 framebuffer_attachment_count_(0),
121 can_render_condition_(CAN_RENDER_ALWAYS),
122 texture_max_anisotropy_initialized_(false) {
125 Texture::~Texture() {
126 if (mailbox_manager_)
127 mailbox_manager_->TextureDeleted(this);
130 void Texture::AddTextureRef(TextureRef* ref) {
131 DCHECK(refs_.find(ref) == refs_.end());
133 if (!memory_tracking_ref_) {
134 memory_tracking_ref_ = ref;
135 GetMemTracker()->TrackMemAlloc(estimated_size());
139 void Texture::RemoveTextureRef(TextureRef* ref, bool have_context) {
140 if (memory_tracking_ref_ == ref) {
141 GetMemTracker()->TrackMemFree(estimated_size());
142 memory_tracking_ref_ = NULL;
144 size_t result = refs_.erase(ref);
145 DCHECK_EQ(result, 1u);
148 GLuint id = service_id();
149 glDeleteTextures(1, &id);
152 } else if (memory_tracking_ref_ == NULL) {
153 // TODO(piman): tune ownership semantics for cross-context group shared
155 memory_tracking_ref_ = *refs_.begin();
156 GetMemTracker()->TrackMemAlloc(estimated_size());
160 MemoryTypeTracker* Texture::GetMemTracker() {
161 DCHECK(memory_tracking_ref_);
162 return memory_tracking_ref_->manager()->GetMemTracker(pool_);
165 Texture::LevelInfo::LevelInfo()
179 Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
180 : cleared(rhs.cleared),
183 internal_format(rhs.internal_format),
191 estimated_size(rhs.estimated_size) {
194 Texture::LevelInfo::~LevelInfo() {
197 Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
199 return CAN_RENDER_ALWAYS;
201 if (target_ != GL_TEXTURE_EXTERNAL_OES) {
202 if (level_infos_.empty()) {
203 return CAN_RENDER_NEVER;
206 const Texture::LevelInfo& first_face = level_infos_[0][0];
207 if (first_face.width == 0 ||
208 first_face.height == 0 ||
209 first_face.depth == 0) {
210 return CAN_RENDER_NEVER;
214 bool needs_mips = NeedsMips();
216 if (!texture_complete())
217 return CAN_RENDER_NEVER;
218 if (target_ == GL_TEXTURE_CUBE_MAP && !cube_complete())
219 return CAN_RENDER_NEVER;
222 bool is_npot_compatible = !needs_mips &&
223 wrap_s_ == GL_CLAMP_TO_EDGE &&
224 wrap_t_ == GL_CLAMP_TO_EDGE;
226 if (!is_npot_compatible) {
227 if (target_ == GL_TEXTURE_RECTANGLE_ARB)
228 return CAN_RENDER_NEVER;
230 return CAN_RENDER_ONLY_IF_NPOT;
233 return CAN_RENDER_ALWAYS;
236 bool Texture::CanRender(const FeatureInfo* feature_info) const {
237 switch (can_render_condition_) {
238 case CAN_RENDER_ALWAYS:
240 case CAN_RENDER_NEVER:
242 case CAN_RENDER_ONLY_IF_NPOT:
245 return feature_info->feature_flags().npot_ok;
248 void Texture::AddToSignature(
249 const FeatureInfo* feature_info,
252 std::string* signature) const {
253 DCHECK(feature_info);
256 DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
257 level_infos_.size());
258 DCHECK_LT(static_cast<size_t>(level),
259 level_infos_[GLTargetToFaceIndex(target)].size());
260 const Texture::LevelInfo& info =
261 level_infos_[GLTargetToFaceIndex(target)][level];
262 *signature += base::StringPrintf(
263 "|Texture|target=%04x|level=%d|internal_format=%04x"
264 "|width=%d|height=%d|depth=%d|border=%d|format=%04x|type=%04x"
265 "|image=%d|canrender=%d|canrenderto=%d|npot_=%d"
266 "|min_filter=%04x|mag_filter=%04x|wrap_s=%04x|wrap_t=%04x"
268 target, level, info.internal_format,
269 info.width, info.height, info.depth, info.border,
270 info.format, info.type, info.image.get() != NULL,
271 CanRender(feature_info), CanRenderTo(), npot_,
272 min_filter_, mag_filter_, wrap_s_, wrap_t_,
276 void Texture::SetMailboxManager(MailboxManager* mailbox_manager) {
277 DCHECK(!mailbox_manager_ || mailbox_manager_ == mailbox_manager);
278 mailbox_manager_ = mailbox_manager;
281 bool Texture::MarkMipmapsGenerated(
282 const FeatureInfo* feature_info) {
283 if (!CanGenerateMipmaps(feature_info)) {
286 for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
287 const Texture::LevelInfo& info1 = level_infos_[ii][0];
288 GLsizei width = info1.width;
289 GLsizei height = info1.height;
290 GLsizei depth = info1.depth;
291 GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
292 FaceIndexToGLTarget(ii);
294 TextureManager::ComputeMipMapCount(target_, width, height, depth);
295 for (int level = 1; level < num_mips; ++level) {
296 width = std::max(1, width >> 1);
297 height = std::max(1, height >> 1);
298 depth = std::max(1, depth >> 1);
299 SetLevelInfo(feature_info,
302 info1.internal_format,
316 void Texture::SetTarget(
317 const FeatureInfo* feature_info, GLenum target, GLint max_levels) {
318 DCHECK_EQ(0u, target_); // you can only set this once.
320 size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
321 level_infos_.resize(num_faces);
322 for (size_t ii = 0; ii < num_faces; ++ii) {
323 level_infos_[ii].resize(max_levels);
326 if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
327 min_filter_ = GL_LINEAR;
328 wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
331 if (target == GL_TEXTURE_EXTERNAL_OES) {
334 Update(feature_info);
335 UpdateCanRenderCondition();
338 bool Texture::CanGenerateMipmaps(
339 const FeatureInfo* feature_info) const {
340 if ((npot() && !feature_info->feature_flags().npot_ok) ||
341 level_infos_.empty() ||
342 target_ == GL_TEXTURE_EXTERNAL_OES ||
343 target_ == GL_TEXTURE_RECTANGLE_ARB) {
347 // Can't generate mips for depth or stencil textures.
348 const Texture::LevelInfo& first = level_infos_[0][0];
349 uint32 channels = GLES2Util::GetChannelsForFormat(first.format);
350 if (channels & (GLES2Util::kDepth | GLES2Util::kStencil)) {
354 // TODO(gman): Check internal_format, format and type.
355 for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
356 const LevelInfo& info = level_infos_[ii][0];
357 if ((info.target == 0) || (info.width != first.width) ||
358 (info.height != first.height) || (info.depth != 1) ||
359 (info.format != first.format) ||
360 (info.internal_format != first.internal_format) ||
361 (info.type != first.type) ||
362 feature_info->validators()->compressed_texture_format.IsValid(
363 info.internal_format) ||
371 void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
373 DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
374 level_infos_.size());
375 DCHECK_LT(static_cast<size_t>(level),
376 level_infos_[GLTargetToFaceIndex(target)].size());
377 Texture::LevelInfo& info =
378 level_infos_[GLTargetToFaceIndex(target)][level];
379 UpdateMipCleared(&info, cleared);
383 void Texture::UpdateCleared() {
384 if (level_infos_.empty()) {
388 const Texture::LevelInfo& first_face = level_infos_[0][0];
389 int levels_needed = TextureManager::ComputeMipMapCount(
390 target_, first_face.width, first_face.height, first_face.depth);
392 for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
393 for (GLint jj = 0; jj < levels_needed; ++jj) {
394 const Texture::LevelInfo& info = level_infos_[ii][jj];
395 if (info.width > 0 && info.height > 0 && info.depth > 0 &&
403 // If texture is uncleared and is attached to a framebuffer,
404 // that framebuffer must be marked possibly incomplete.
405 if (!cleared && IsAttachedToFramebuffer()) {
406 IncAllFramebufferStateChangeCount();
409 UpdateSafeToRenderFrom(cleared);
412 void Texture::UpdateSafeToRenderFrom(bool cleared) {
413 if (cleared_ == cleared)
416 int delta = cleared ? -1 : +1;
417 for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
418 (*it)->manager()->UpdateSafeToRenderFrom(delta);
421 void Texture::UpdateMipCleared(LevelInfo* info, bool cleared) {
422 if (info->cleared == cleared)
424 info->cleared = cleared;
425 int delta = cleared ? -1 : +1;
426 num_uncleared_mips_ += delta;
427 for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
428 (*it)->manager()->UpdateUnclearedMips(delta);
431 void Texture::UpdateCanRenderCondition() {
432 CanRenderCondition can_render_condition = GetCanRenderCondition();
433 if (can_render_condition_ == can_render_condition)
435 for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
436 (*it)->manager()->UpdateCanRenderCondition(can_render_condition_,
437 can_render_condition);
438 can_render_condition_ = can_render_condition;
441 void Texture::UpdateHasImages() {
442 if (level_infos_.empty())
445 bool has_images = false;
446 for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
447 for (size_t jj = 0; jj < level_infos_[ii].size(); ++jj) {
448 const Texture::LevelInfo& info = level_infos_[ii][jj];
449 if (info.image.get() != NULL) {
456 if (has_images_ == has_images)
458 has_images_ = has_images;
459 int delta = has_images ? +1 : -1;
460 for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
461 (*it)->manager()->UpdateNumImages(delta);
464 void Texture::IncAllFramebufferStateChangeCount() {
465 for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
466 (*it)->manager()->IncFramebufferStateChangeCount();
469 void Texture::SetLevelInfo(
470 const FeatureInfo* feature_info,
473 GLenum internal_format,
482 DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
483 level_infos_.size());
484 DCHECK_LT(static_cast<size_t>(level),
485 level_infos_[GLTargetToFaceIndex(target)].size());
487 DCHECK_GE(height, 0);
489 Texture::LevelInfo& info =
490 level_infos_[GLTargetToFaceIndex(target)][level];
491 info.target = target;
493 info.internal_format = internal_format;
495 info.height = height;
497 info.border = border;
498 info.format = format;
502 estimated_size_ -= info.estimated_size;
503 GLES2Util::ComputeImageDataSizes(
504 width, height, format, type, 4, &info.estimated_size, NULL, NULL);
505 estimated_size_ += info.estimated_size;
507 UpdateMipCleared(&info, cleared);
508 max_level_set_ = std::max(max_level_set_, level);
509 Update(feature_info);
511 UpdateCanRenderCondition();
513 if (IsAttachedToFramebuffer()) {
514 // TODO(gman): If textures tracked which framebuffers they were attached to
515 // we could just mark those framebuffers as not complete.
516 IncAllFramebufferStateChangeCount();
520 bool Texture::ValidForTexture(
528 size_t face_index = GLTargetToFaceIndex(target);
529 if (level >= 0 && face_index < level_infos_.size() &&
530 static_cast<size_t>(level) < level_infos_[face_index].size()) {
531 const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
534 return SafeAddInt32(xoffset, width, &right) &&
535 SafeAddInt32(yoffset, height, &top) &&
538 right <= info.width &&
539 top <= info.height &&
545 bool Texture::GetLevelSize(
546 GLint target, GLint level, GLsizei* width, GLsizei* height) const {
549 size_t face_index = GLTargetToFaceIndex(target);
550 if (level >= 0 && face_index < level_infos_.size() &&
551 static_cast<size_t>(level) < level_infos_[face_index].size()) {
552 const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
553 if (info.target != 0) {
555 *height = info.height;
562 bool Texture::GetLevelType(
563 GLint target, GLint level, GLenum* type, GLenum* internal_format) const {
565 DCHECK(internal_format);
566 size_t face_index = GLTargetToFaceIndex(target);
567 if (level >= 0 && face_index < level_infos_.size() &&
568 static_cast<size_t>(level) < level_infos_[face_index].size()) {
569 const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
570 if (info.target != 0) {
572 *internal_format = info.internal_format;
579 GLenum Texture::SetParameteri(
580 const FeatureInfo* feature_info, GLenum pname, GLint param) {
581 DCHECK(feature_info);
583 if (target_ == GL_TEXTURE_EXTERNAL_OES ||
584 target_ == GL_TEXTURE_RECTANGLE_ARB) {
585 if (pname == GL_TEXTURE_MIN_FILTER &&
586 (param != GL_NEAREST && param != GL_LINEAR))
587 return GL_INVALID_ENUM;
588 if ((pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T) &&
589 param != GL_CLAMP_TO_EDGE)
590 return GL_INVALID_ENUM;
594 case GL_TEXTURE_MIN_FILTER:
595 if (!feature_info->validators()->texture_min_filter_mode.IsValid(param)) {
596 return GL_INVALID_ENUM;
600 case GL_TEXTURE_MAG_FILTER:
601 if (!feature_info->validators()->texture_mag_filter_mode.IsValid(param)) {
602 return GL_INVALID_ENUM;
606 case GL_TEXTURE_POOL_CHROMIUM:
607 if (!feature_info->validators()->texture_pool.IsValid(param)) {
608 return GL_INVALID_ENUM;
610 GetMemTracker()->TrackMemFree(estimated_size());
612 GetMemTracker()->TrackMemAlloc(estimated_size());
614 case GL_TEXTURE_WRAP_S:
615 if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
616 return GL_INVALID_ENUM;
620 case GL_TEXTURE_WRAP_T:
621 if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
622 return GL_INVALID_ENUM;
626 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
628 return GL_INVALID_VALUE;
631 case GL_TEXTURE_USAGE_ANGLE:
632 if (!feature_info->validators()->texture_usage.IsValid(param)) {
633 return GL_INVALID_ENUM;
639 return GL_INVALID_ENUM;
641 Update(feature_info);
643 UpdateCanRenderCondition();
647 GLenum Texture::SetParameterf(
648 const FeatureInfo* feature_info, GLenum pname, GLfloat param) {
650 case GL_TEXTURE_MIN_FILTER:
651 case GL_TEXTURE_MAG_FILTER:
652 case GL_TEXTURE_POOL_CHROMIUM:
653 case GL_TEXTURE_WRAP_S:
654 case GL_TEXTURE_WRAP_T:
655 case GL_TEXTURE_USAGE_ANGLE:
657 GLint iparam = static_cast<GLint>(param);
658 return SetParameteri(feature_info, pname, iparam);
660 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
662 return GL_INVALID_VALUE;
667 return GL_INVALID_ENUM;
672 void Texture::Update(const FeatureInfo* feature_info) {
673 // Update npot status.
674 // Assume GL_TEXTURE_EXTERNAL_OES textures are npot, all others
675 npot_ = target_ == GL_TEXTURE_EXTERNAL_OES;
677 if (level_infos_.empty()) {
678 texture_complete_ = false;
679 cube_complete_ = false;
683 // checks that the first mip of any face is npot.
684 for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
685 const Texture::LevelInfo& info = level_infos_[ii][0];
686 if (GLES2Util::IsNPOT(info.width) ||
687 GLES2Util::IsNPOT(info.height) ||
688 GLES2Util::IsNPOT(info.depth)) {
694 // Update texture_complete and cube_complete status.
695 const Texture::LevelInfo& first_face = level_infos_[0][0];
696 int levels_needed = TextureManager::ComputeMipMapCount(
697 target_, first_face.width, first_face.height, first_face.depth);
699 max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
700 cube_complete_ = (level_infos_.size() == 6) &&
701 (first_face.width == first_face.height);
703 if (first_face.width == 0 || first_face.height == 0) {
704 texture_complete_ = false;
706 if (first_face.type == GL_FLOAT &&
707 !feature_info->feature_flags().enable_texture_float_linear &&
708 (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
709 mag_filter_ != GL_NEAREST)) {
710 texture_complete_ = false;
711 } else if (first_face.type == GL_HALF_FLOAT_OES &&
712 !feature_info->feature_flags().enable_texture_half_float_linear &&
713 (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
714 mag_filter_ != GL_NEAREST)) {
715 texture_complete_ = false;
718 ii < level_infos_.size() && (cube_complete_ || texture_complete_);
720 const Texture::LevelInfo& level0 = level_infos_[ii][0];
721 if (level0.target == 0 ||
722 level0.width != first_face.width ||
723 level0.height != first_face.height ||
725 level0.internal_format != first_face.internal_format ||
726 level0.format != first_face.format ||
727 level0.type != first_face.type) {
728 cube_complete_ = false;
730 // Get level0 dimensions
731 GLsizei width = level0.width;
732 GLsizei height = level0.height;
733 GLsizei depth = level0.depth;
734 for (GLint jj = 1; jj < levels_needed; ++jj) {
735 // compute required size for mip.
736 width = std::max(1, width >> 1);
737 height = std::max(1, height >> 1);
738 depth = std::max(1, depth >> 1);
739 const Texture::LevelInfo& info = level_infos_[ii][jj];
740 if (info.target == 0 ||
741 info.width != width ||
742 info.height != height ||
743 info.depth != depth ||
744 info.internal_format != level0.internal_format ||
745 info.format != level0.format ||
746 info.type != level0.type) {
747 texture_complete_ = false;
754 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
760 const Texture::LevelInfo& first_face = level_infos_[0][0];
761 int levels_needed = TextureManager::ComputeMipMapCount(
762 target_, first_face.width, first_face.height, first_face.depth);
764 for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
765 for (GLint jj = 0; jj < levels_needed; ++jj) {
766 Texture::LevelInfo& info = level_infos_[ii][jj];
767 if (info.target != 0) {
768 if (!ClearLevel(decoder, info.target, jj)) {
774 UpdateSafeToRenderFrom(true);
778 bool Texture::IsLevelCleared(GLenum target, GLint level) const {
779 size_t face_index = GLTargetToFaceIndex(target);
780 if (face_index >= level_infos_.size() ||
781 level >= static_cast<GLint>(level_infos_[face_index].size())) {
785 const Texture::LevelInfo& info = level_infos_[face_index][level];
790 void Texture::InitTextureMaxAnisotropyIfNeeded(GLenum target) {
791 if (texture_max_anisotropy_initialized_)
793 texture_max_anisotropy_initialized_ = true;
794 GLfloat params[] = { 1.0f };
795 glTexParameterfv(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, params);
798 bool Texture::ClearLevel(
799 GLES2Decoder* decoder, GLenum target, GLint level) {
801 size_t face_index = GLTargetToFaceIndex(target);
802 if (face_index >= level_infos_.size() ||
803 level >= static_cast<GLint>(level_infos_[face_index].size())) {
807 Texture::LevelInfo& info = level_infos_[face_index][level];
809 DCHECK(target == info.target);
811 if (info.target == 0 ||
819 // NOTE: It seems kind of gross to call back into the decoder for this
820 // but only the decoder knows all the state (like unpack_alignment_) that's
821 // needed to be able to call GL correctly.
822 bool cleared = decoder->ClearLevel(
823 service_id_, target_, info.target, info.level, info.internal_format,
824 info.format, info.type, info.width, info.height, immutable_);
825 UpdateMipCleared(&info, cleared);
829 void Texture::SetLevelImage(
830 const FeatureInfo* feature_info,
833 gfx::GLImage* image) {
835 DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
836 level_infos_.size());
837 DCHECK_LT(static_cast<size_t>(level),
838 level_infos_[GLTargetToFaceIndex(target)].size());
839 Texture::LevelInfo& info =
840 level_infos_[GLTargetToFaceIndex(target)][level];
841 DCHECK_EQ(info.target, target);
842 DCHECK_EQ(info.level, level);
844 UpdateCanRenderCondition();
848 gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
849 if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
850 target != GL_TEXTURE_RECTANGLE_ARB) {
854 size_t face_index = GLTargetToFaceIndex(target);
855 if (level >= 0 && face_index < level_infos_.size() &&
856 static_cast<size_t>(level) < level_infos_[face_index].size()) {
857 const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
858 if (info.target != 0) {
859 return info.image.get();
865 void Texture::OnWillModifyPixels() {
866 gfx::GLImage* image = GetLevelImage(target(), 0);
868 image->WillModifyTexImage();
871 void Texture::OnDidModifyPixels() {
872 gfx::GLImage* image = GetLevelImage(target(), 0);
874 image->DidModifyTexImage();
877 TextureRef::TextureRef(TextureManager* manager,
882 client_id_(client_id),
886 texture_->AddTextureRef(this);
887 manager_->StartTracking(this);
890 scoped_refptr<TextureRef> TextureRef::Create(TextureManager* manager,
893 return new TextureRef(manager, client_id, new Texture(service_id));
896 TextureRef::~TextureRef() {
897 manager_->StopTracking(this);
898 texture_->RemoveTextureRef(this, manager_->have_context_);
902 TextureManager::TextureManager(MemoryTracker* memory_tracker,
903 FeatureInfo* feature_info,
904 GLint max_texture_size,
905 GLint max_cube_map_texture_size,
906 bool use_default_textures)
907 : memory_tracker_managed_(
908 new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
909 memory_tracker_unmanaged_(
910 new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
911 feature_info_(feature_info),
912 framebuffer_manager_(NULL),
913 max_texture_size_(max_texture_size),
914 max_cube_map_texture_size_(max_cube_map_texture_size),
915 max_levels_(ComputeMipMapCount(GL_TEXTURE_2D,
919 max_cube_map_levels_(ComputeMipMapCount(GL_TEXTURE_CUBE_MAP,
920 max_cube_map_texture_size,
921 max_cube_map_texture_size,
922 max_cube_map_texture_size)),
923 use_default_textures_(use_default_textures),
924 num_unrenderable_textures_(0),
925 num_unsafe_textures_(0),
926 num_uncleared_mips_(0),
929 have_context_(true) {
930 for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
931 black_texture_ids_[ii] = 0;
935 bool TextureManager::Initialize() {
936 // TODO(gman): The default textures have to be real textures, not the 0
937 // texture because we simulate non shared resources on top of shared
938 // resources and all contexts that share resource share the same default
940 default_textures_[kTexture2D] = CreateDefaultAndBlackTextures(
941 GL_TEXTURE_2D, &black_texture_ids_[kTexture2D]);
942 default_textures_[kCubeMap] = CreateDefaultAndBlackTextures(
943 GL_TEXTURE_CUBE_MAP, &black_texture_ids_[kCubeMap]);
945 if (feature_info_->feature_flags().oes_egl_image_external) {
946 default_textures_[kExternalOES] = CreateDefaultAndBlackTextures(
947 GL_TEXTURE_EXTERNAL_OES, &black_texture_ids_[kExternalOES]);
950 if (feature_info_->feature_flags().arb_texture_rectangle) {
951 default_textures_[kRectangleARB] = CreateDefaultAndBlackTextures(
952 GL_TEXTURE_RECTANGLE_ARB, &black_texture_ids_[kRectangleARB]);
958 scoped_refptr<TextureRef>
959 TextureManager::CreateDefaultAndBlackTextures(
961 GLuint* black_texture) {
962 static uint8 black[] = {0, 0, 0, 255};
964 // Sampling a texture not associated with any EGLImage sibling will return
965 // black values according to the spec.
966 bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
967 bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
969 // Make default textures and texture for replacing non-renderable textures.
971 const unsigned long num_ids = use_default_textures_ ? 2 : 1;
972 glGenTextures(num_ids, ids);
973 for (unsigned long ii = 0; ii < num_ids; ++ii) {
974 glBindTexture(target, ids[ii]);
975 if (needs_initialization) {
977 for (int jj = 0; jj < GLES2Util::kNumFaces; ++jj) {
978 glTexImage2D(GLES2Util::IndexToGLFaceTarget(jj), 0, GL_RGBA, 1, 1, 0,
979 GL_RGBA, GL_UNSIGNED_BYTE, black);
982 glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
983 GL_UNSIGNED_BYTE, black);
987 glBindTexture(target, 0);
989 scoped_refptr<TextureRef> default_texture;
990 if (use_default_textures_) {
991 default_texture = TextureRef::Create(this, 0, ids[1]);
992 SetTarget(default_texture.get(), target);
994 for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
995 SetLevelInfo(default_texture.get(),
996 GLES2Util::IndexToGLFaceTarget(ii),
1008 if (needs_initialization) {
1009 SetLevelInfo(default_texture.get(),
1021 SetLevelInfo(default_texture.get(),
1022 GL_TEXTURE_EXTERNAL_OES,
1036 *black_texture = ids[0];
1037 return default_texture;
1040 bool TextureManager::ValidForTarget(
1041 GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth) {
1042 GLsizei max_size = MaxSizeForTarget(target) >> level;
1043 return level >= 0 &&
1047 level < MaxLevelsForTarget(target) &&
1048 width <= max_size &&
1049 height <= max_size &&
1050 depth <= max_size &&
1051 (level == 0 || feature_info_->feature_flags().npot_ok ||
1052 (!GLES2Util::IsNPOT(width) &&
1053 !GLES2Util::IsNPOT(height) &&
1054 !GLES2Util::IsNPOT(depth))) &&
1055 (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
1056 (target != GL_TEXTURE_2D || (depth == 1));
1059 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
1062 ->SetTarget(feature_info_.get(), target, MaxLevelsForTarget(target));
1065 void TextureManager::SetLevelCleared(TextureRef* ref,
1070 ref->texture()->SetLevelCleared(target, level, cleared);
1073 bool TextureManager::ClearRenderableLevels(
1074 GLES2Decoder* decoder, TextureRef* ref) {
1076 return ref->texture()->ClearRenderableLevels(decoder);
1079 bool TextureManager::ClearTextureLevel(
1080 GLES2Decoder* decoder, TextureRef* ref,
1081 GLenum target, GLint level) {
1083 Texture* texture = ref->texture();
1084 if (texture->num_uncleared_mips() == 0) {
1087 bool result = texture->ClearLevel(decoder, target, level);
1088 texture->UpdateCleared();
1092 void TextureManager::SetLevelInfo(
1096 GLenum internal_format,
1105 Texture* texture = ref->texture();
1107 texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
1108 texture->SetLevelInfo(feature_info_.get(),
1119 texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
1122 Texture* TextureManager::Produce(TextureRef* ref) {
1124 return ref->texture();
1127 TextureRef* TextureManager::Consume(
1131 scoped_refptr<TextureRef> ref(new TextureRef(this, client_id, texture));
1132 bool result = textures_.insert(std::make_pair(client_id, ref)).second;
1137 void TextureManager::SetParameteri(
1138 const char* function_name, ErrorState* error_state,
1139 TextureRef* ref, GLenum pname, GLint param) {
1140 DCHECK(error_state);
1142 Texture* texture = ref->texture();
1143 GLenum result = texture->SetParameteri(feature_info_.get(), pname, param);
1144 if (result != GL_NO_ERROR) {
1145 if (result == GL_INVALID_ENUM) {
1146 ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
1147 error_state, function_name, param, "param");
1149 ERRORSTATE_SET_GL_ERROR_INVALID_PARAMI(
1150 error_state, result, function_name, pname, param);
1153 // Texture tracking pools exist only for the command decoder, so
1154 // do not pass them on to the native GL implementation.
1155 if (pname != GL_TEXTURE_POOL_CHROMIUM) {
1156 glTexParameteri(texture->target(), pname, param);
1161 void TextureManager::SetParameterf(
1162 const char* function_name, ErrorState* error_state,
1163 TextureRef* ref, GLenum pname, GLfloat param) {
1164 DCHECK(error_state);
1166 Texture* texture = ref->texture();
1167 GLenum result = texture->SetParameterf(feature_info_.get(), pname, param);
1168 if (result != GL_NO_ERROR) {
1169 if (result == GL_INVALID_ENUM) {
1170 ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
1171 error_state, function_name, param, "param");
1173 ERRORSTATE_SET_GL_ERROR_INVALID_PARAMF(
1174 error_state, result, function_name, pname, param);
1177 // Texture tracking pools exist only for the command decoder, so
1178 // do not pass them on to the native GL implementation.
1179 if (pname != GL_TEXTURE_POOL_CHROMIUM) {
1180 glTexParameterf(texture->target(), pname, param);
1185 bool TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
1187 Texture* texture = ref->texture();
1188 texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
1189 bool result = texture->MarkMipmapsGenerated(feature_info_.get());
1190 texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
1194 TextureRef* TextureManager::CreateTexture(
1195 GLuint client_id, GLuint service_id) {
1196 DCHECK_NE(0u, service_id);
1197 scoped_refptr<TextureRef> ref(TextureRef::Create(
1198 this, client_id, service_id));
1199 std::pair<TextureMap::iterator, bool> result =
1200 textures_.insert(std::make_pair(client_id, ref));
1201 DCHECK(result.second);
1205 TextureRef* TextureManager::GetTexture(
1206 GLuint client_id) const {
1207 TextureMap::const_iterator it = textures_.find(client_id);
1208 return it != textures_.end() ? it->second.get() : NULL;
1211 void TextureManager::RemoveTexture(GLuint client_id) {
1212 TextureMap::iterator it = textures_.find(client_id);
1213 if (it != textures_.end()) {
1214 it->second->reset_client_id();
1215 textures_.erase(it);
1219 void TextureManager::StartTracking(TextureRef* ref) {
1220 Texture* texture = ref->texture();
1222 num_uncleared_mips_ += texture->num_uncleared_mips();
1223 if (!texture->SafeToRenderFrom())
1224 ++num_unsafe_textures_;
1225 if (!texture->CanRender(feature_info_.get()))
1226 ++num_unrenderable_textures_;
1227 if (texture->HasImages())
1231 void TextureManager::StopTracking(TextureRef* ref) {
1232 if (ref->num_observers()) {
1233 for (unsigned int i = 0; i < destruction_observers_.size(); i++) {
1234 destruction_observers_[i]->OnTextureRefDestroying(ref);
1236 DCHECK_EQ(ref->num_observers(), 0);
1239 Texture* texture = ref->texture();
1242 if (texture->HasImages()) {
1243 DCHECK_NE(0, num_images_);
1246 if (!texture->CanRender(feature_info_.get())) {
1247 DCHECK_NE(0, num_unrenderable_textures_);
1248 --num_unrenderable_textures_;
1250 if (!texture->SafeToRenderFrom()) {
1251 DCHECK_NE(0, num_unsafe_textures_);
1252 --num_unsafe_textures_;
1254 num_uncleared_mips_ -= texture->num_uncleared_mips();
1255 DCHECK_GE(num_uncleared_mips_, 0);
1258 MemoryTypeTracker* TextureManager::GetMemTracker(GLenum tracking_pool) {
1259 switch(tracking_pool) {
1260 case GL_TEXTURE_POOL_MANAGED_CHROMIUM:
1261 return memory_tracker_managed_.get();
1263 case GL_TEXTURE_POOL_UNMANAGED_CHROMIUM:
1264 return memory_tracker_unmanaged_.get();
1273 Texture* TextureManager::GetTextureForServiceId(GLuint service_id) const {
1274 // This doesn't need to be fast. It's only used during slow queries.
1275 for (TextureMap::const_iterator it = textures_.begin();
1276 it != textures_.end(); ++it) {
1277 Texture* texture = it->second->texture();
1278 if (texture->service_id() == service_id)
1284 GLsizei TextureManager::ComputeMipMapCount(GLenum target,
1289 case GL_TEXTURE_EXTERNAL_OES:
1293 base::bits::Log2Floor(std::max(std::max(width, height), depth));
1297 void TextureManager::SetLevelImage(
1301 gfx::GLImage* image) {
1303 ref->texture()->SetLevelImage(feature_info_.get(), target, level, image);
1306 void TextureManager::AddToSignature(
1310 std::string* signature) const {
1311 ref->texture()->AddToSignature(feature_info_.get(), target, level, signature);
1314 void TextureManager::UpdateSafeToRenderFrom(int delta) {
1315 num_unsafe_textures_ += delta;
1316 DCHECK_GE(num_unsafe_textures_, 0);
1319 void TextureManager::UpdateUnclearedMips(int delta) {
1320 num_uncleared_mips_ += delta;
1321 DCHECK_GE(num_uncleared_mips_, 0);
1324 void TextureManager::UpdateCanRenderCondition(
1325 Texture::CanRenderCondition old_condition,
1326 Texture::CanRenderCondition new_condition) {
1327 if (old_condition == Texture::CAN_RENDER_NEVER ||
1328 (old_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
1329 !feature_info_->feature_flags().npot_ok)) {
1330 DCHECK_GT(num_unrenderable_textures_, 0);
1331 --num_unrenderable_textures_;
1333 if (new_condition == Texture::CAN_RENDER_NEVER ||
1334 (new_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
1335 !feature_info_->feature_flags().npot_ok))
1336 ++num_unrenderable_textures_;
1339 void TextureManager::UpdateNumImages(int delta) {
1340 num_images_ += delta;
1341 DCHECK_GE(num_images_, 0);
1344 void TextureManager::IncFramebufferStateChangeCount() {
1345 if (framebuffer_manager_)
1346 framebuffer_manager_->IncFramebufferStateChangeCount();
1349 bool TextureManager::ValidateFormatAndTypeCombination(
1350 ErrorState* error_state, const char* function_name, GLenum format,
1352 if (!feature_info_->GetTextureFormatValidator(format).IsValid(type)) {
1353 ERRORSTATE_SET_GL_ERROR(
1354 error_state, GL_INVALID_OPERATION, function_name,
1355 (std::string("invalid type ") +
1356 GLES2Util::GetStringEnum(type) + " for format " +
1357 GLES2Util::GetStringEnum(format)).c_str());
1363 bool TextureManager::ValidateTextureParameters(
1364 ErrorState* error_state, const char* function_name,
1365 GLenum format, GLenum type, GLenum internal_format, GLint level) {
1366 const Validators* validators = feature_info_->validators();
1367 if (!validators->texture_format.IsValid(format)) {
1368 ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
1369 error_state, function_name, format, "format");
1372 if (!validators->pixel_type.IsValid(type)) {
1373 ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
1374 error_state, function_name, type, "type");
1377 if (format != internal_format &&
1378 !((internal_format == GL_RGBA32F && format == GL_RGBA) ||
1379 (internal_format == GL_RGB32F && format == GL_RGB))) {
1380 ERRORSTATE_SET_GL_ERROR(
1381 error_state, GL_INVALID_OPERATION, function_name,
1382 "format != internalformat");
1385 uint32 channels = GLES2Util::GetChannelsForFormat(format);
1386 if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
1387 ERRORSTATE_SET_GL_ERROR(
1388 error_state, GL_INVALID_OPERATION, function_name,
1389 (std::string("invalid format ") + GLES2Util::GetStringEnum(format) +
1390 " for level != 0").c_str());
1393 return ValidateFormatAndTypeCombination(error_state, function_name,
1397 // Gets the texture id for a given target.
1398 TextureRef* TextureManager::GetTextureInfoForTarget(
1399 ContextState* state, GLenum target) {
1400 TextureUnit& unit = state->texture_units[state->active_texture_unit];
1401 TextureRef* texture = NULL;
1404 texture = unit.bound_texture_2d.get();
1406 case GL_TEXTURE_CUBE_MAP:
1407 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1408 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1409 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1410 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1411 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1412 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1413 texture = unit.bound_texture_cube_map.get();
1415 case GL_TEXTURE_EXTERNAL_OES:
1416 texture = unit.bound_texture_external_oes.get();
1418 case GL_TEXTURE_RECTANGLE_ARB:
1419 texture = unit.bound_texture_rectangle_arb.get();
1428 TextureRef* TextureManager::GetTextureInfoForTargetUnlessDefault(
1429 ContextState* state, GLenum target) {
1430 TextureRef* texture = GetTextureInfoForTarget(state, target);
1433 if (texture == GetDefaultTextureInfo(target))
1438 bool TextureManager::ValidateTexImage2D(
1439 ContextState* state,
1440 const char* function_name,
1441 const DoTextImage2DArguments& args,
1442 TextureRef** texture_ref) {
1443 ErrorState* error_state = state->GetErrorState();
1444 const Validators* validators = feature_info_->validators();
1445 if (!validators->texture_target.IsValid(args.target)) {
1446 ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
1447 error_state, function_name, args.target, "target");
1450 if (!validators->texture_internal_format.IsValid(args.internal_format)) {
1451 ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
1452 error_state, function_name, args.internal_format,
1456 if (!ValidateTextureParameters(
1457 error_state, function_name, args.format, args.type,
1458 args.internal_format, args.level)) {
1461 if (!ValidForTarget(args.target, args.level, args.width, args.height, 1) ||
1463 ERRORSTATE_SET_GL_ERROR(
1464 error_state, GL_INVALID_VALUE, function_name,
1465 "dimensions out of range");
1468 if ((GLES2Util::GetChannelsForFormat(args.format) &
1469 (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && args.pixels) {
1470 ERRORSTATE_SET_GL_ERROR(
1471 error_state, GL_INVALID_OPERATION,
1472 function_name, "can not supply data for depth or stencil textures");
1476 TextureRef* local_texture_ref = GetTextureInfoForTarget(state, args.target);
1477 if (!local_texture_ref) {
1478 ERRORSTATE_SET_GL_ERROR(
1479 error_state, GL_INVALID_OPERATION, function_name,
1480 "unknown texture for target");
1483 if (local_texture_ref->texture()->IsImmutable()) {
1484 ERRORSTATE_SET_GL_ERROR(
1485 error_state, GL_INVALID_OPERATION, function_name,
1486 "texture is immutable");
1490 // TODO - verify that using the managed vs unmanaged does not matter.
1491 // They both use the same MemoryTracker, and this call just re-routes
1493 if (!memory_tracker_managed_->EnsureGPUMemoryAvailable(args.pixels_size)) {
1494 ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY, function_name,
1499 // Write the TextureReference since this is valid.
1500 *texture_ref = local_texture_ref;
1504 void TextureManager::ValidateAndDoTexImage2D(
1505 DecoderTextureState* texture_state,
1506 ContextState* state,
1507 DecoderFramebufferState* framebuffer_state,
1508 const DoTextImage2DArguments& args) {
1509 TextureRef* texture_ref;
1510 if (!ValidateTexImage2D(state, "glTexImage2D", args, &texture_ref)) {
1514 DoTexImage2D(texture_state, state->GetErrorState(), framebuffer_state,
1518 void TextureManager::DoTexImage2D(
1519 DecoderTextureState* texture_state,
1520 ErrorState* error_state,
1521 DecoderFramebufferState* framebuffer_state,
1522 TextureRef* texture_ref,
1523 const DoTextImage2DArguments& args) {
1524 Texture* texture = texture_ref->texture();
1525 GLsizei tex_width = 0;
1526 GLsizei tex_height = 0;
1527 GLenum tex_type = 0;
1528 GLenum tex_format = 0;
1529 bool level_is_same =
1530 texture->GetLevelSize(args.target, args.level, &tex_width, &tex_height) &&
1531 texture->GetLevelType(args.target, args.level, &tex_type, &tex_format) &&
1532 args.width == tex_width && args.height == tex_height &&
1533 args.type == tex_type && args.format == tex_format;
1535 if (level_is_same && !args.pixels) {
1536 // Just set the level texture but mark the texture as uncleared.
1539 args.target, args.level, args.internal_format, args.width, args.height,
1540 1, args.border, args.format, args.type, false);
1541 texture_state->tex_image_2d_failed = false;
1545 if (texture->IsAttachedToFramebuffer()) {
1546 framebuffer_state->clear_state_dirty = true;
1549 if (texture_state->texsubimage2d_faster_than_teximage2d &&
1550 level_is_same && args.pixels) {
1552 ScopedTextureUploadTimer timer(texture_state);
1553 glTexSubImage2D(args.target, args.level, 0, 0, args.width, args.height,
1554 args.format, args.type, args.pixels);
1556 SetLevelCleared(texture_ref, args.target, args.level, true);
1557 texture_state->tex_image_2d_failed = false;
1561 ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glTexImage2D");
1563 ScopedTextureUploadTimer timer(texture_state);
1565 args.target, args.level, args.internal_format, args.width, args.height,
1566 args.border, args.format, args.type, args.pixels);
1568 GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glTexImage2D");
1569 if (error == GL_NO_ERROR) {
1572 args.target, args.level, args.internal_format, args.width, args.height,
1573 1, args.border, args.format, args.type, args.pixels != NULL);
1574 texture_state->tex_image_2d_failed = false;
1578 ScopedTextureUploadTimer::ScopedTextureUploadTimer(
1579 DecoderTextureState* texture_state)
1580 : texture_state_(texture_state),
1581 begin_time_(base::TimeTicks::HighResNow()) {
1584 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
1585 texture_state_->texture_upload_count++;
1586 texture_state_->total_texture_upload_time +=
1587 base::TimeTicks::HighResNow() - begin_time_;
1590 } // namespace gles2