1 #include "precompiled.h" 2 // 3 // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. 4 // Use of this source code is governed by a BSD-style license that can be 5 // found in the LICENSE file. 6 // 7 8 // Texture.cpp: Implements the gl::Texture class and its derived classes 9 // Texture2D and TextureCubeMap. Implements GL texture objects and related 10 // functionality. [OpenGL ES 2.0.24] section 3.7 page 63. 11 12 #include "libGLESv2/Texture.h" 13 14 #include "libGLESv2/main.h" 15 #include "common/mathutil.h" 16 #include "common/utilities.h" 17 #include "libGLESv2/formatutils.h" 18 #include "libGLESv2/Renderbuffer.h" 19 #include "libGLESv2/renderer/Image.h" 20 #include "libGLESv2/renderer/Renderer.h" 21 #include "libGLESv2/renderer/TextureStorage.h" 22 #include "libEGL/Surface.h" 23 #include "libGLESv2/Buffer.h" 24 #include "libGLESv2/renderer/BufferStorage.h" 25 #include "libGLESv2/renderer/RenderTarget.h" 26 27 namespace gl 28 { 29 30 bool IsMipmapFiltered(const SamplerState &samplerState) 31 { 32 switch (samplerState.minFilter) 33 { 34 case GL_NEAREST: 35 case GL_LINEAR: 36 return false; 37 case GL_NEAREST_MIPMAP_NEAREST: 38 case GL_LINEAR_MIPMAP_NEAREST: 39 case GL_NEAREST_MIPMAP_LINEAR: 40 case GL_LINEAR_MIPMAP_LINEAR: 41 return true; 42 default: UNREACHABLE(); 43 return false; 44 } 45 } 46 47 bool IsRenderTargetUsage(GLenum usage) 48 { 49 return (usage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE); 50 } 51 52 Texture::Texture(rx::Renderer *renderer, GLuint id, GLenum target) : RefCountObject(id) 53 { 54 mRenderer = renderer; 55 56 mSamplerState.minFilter = GL_NEAREST_MIPMAP_LINEAR; 57 mSamplerState.magFilter = GL_LINEAR; 58 mSamplerState.wrapS = GL_REPEAT; 59 mSamplerState.wrapT = GL_REPEAT; 60 mSamplerState.wrapR = GL_REPEAT; 61 mSamplerState.maxAnisotropy = 1.0f; 62 mSamplerState.baseLevel = 0; 63 mSamplerState.maxLevel = 1000; 64 mSamplerState.minLod = -1000.0f; 65 mSamplerState.maxLod = 1000.0f; 66 mSamplerState.compareMode = GL_NONE; 67 mSamplerState.compareFunc = GL_LEQUAL; 68 mSamplerState.swizzleRed = GL_RED; 69 mSamplerState.swizzleGreen = GL_GREEN; 70 mSamplerState.swizzleBlue = GL_BLUE; 71 mSamplerState.swizzleAlpha = GL_ALPHA; 72 mUsage = GL_NONE; 73 74 mDirtyImages = true; 75 76 mImmutable = false; 77 78 mTarget = target; 79 } 80 81 Texture::~Texture() 82 { 83 } 84 85 GLenum Texture::getTarget() const 86 { 87 return mTarget; 88 } 89 90 void Texture::addProxyRef(const FramebufferAttachment *proxy) 91 { 92 mRenderbufferProxies.addRef(proxy); 93 } 94 95 void Texture::releaseProxy(const FramebufferAttachment *proxy) 96 { 97 mRenderbufferProxies.release(proxy); 98 } 99 100 void Texture::setMinFilter(GLenum filter) 101 { 102 mSamplerState.minFilter = filter; 103 } 104 105 void Texture::setMagFilter(GLenum filter) 106 { 107 mSamplerState.magFilter = filter; 108 } 109 110 void Texture::setWrapS(GLenum wrap) 111 { 112 mSamplerState.wrapS = wrap; 113 } 114 115 void Texture::setWrapT(GLenum wrap) 116 { 117 mSamplerState.wrapT = wrap; 118 } 119 120 void Texture::setWrapR(GLenum wrap) 121 { 122 mSamplerState.wrapR = wrap; 123 } 124 125 void Texture::setMaxAnisotropy(float textureMaxAnisotropy, float contextMaxAnisotropy) 126 { 127 mSamplerState.maxAnisotropy = std::min(textureMaxAnisotropy, contextMaxAnisotropy); 128 } 129 130 void Texture::setCompareMode(GLenum mode) 131 { 132 mSamplerState.compareMode = mode; 133 } 134 135 void Texture::setCompareFunc(GLenum func) 136 { 137 mSamplerState.compareFunc = func; 138 } 139 140 void Texture::setSwizzleRed(GLenum swizzle) 141 { 142 mSamplerState.swizzleRed = swizzle; 143 } 144 145 void Texture::setSwizzleGreen(GLenum swizzle) 146 { 147 mSamplerState.swizzleGreen = swizzle; 148 } 149 150 void Texture::setSwizzleBlue(GLenum swizzle) 151 { 152 mSamplerState.swizzleBlue = swizzle; 153 } 154 155 void Texture::setSwizzleAlpha(GLenum swizzle) 156 { 157 mSamplerState.swizzleAlpha = swizzle; 158 } 159 160 void Texture::setBaseLevel(GLint baseLevel) 161 { 162 mSamplerState.baseLevel = baseLevel; 163 } 164 165 void Texture::setMaxLevel(GLint maxLevel) 166 { 167 mSamplerState.maxLevel = maxLevel; 168 } 169 170 void Texture::setMinLod(GLfloat minLod) 171 { 172 mSamplerState.minLod = minLod; 173 } 174 175 void Texture::setMaxLod(GLfloat maxLod) 176 { 177 mSamplerState.maxLod = maxLod; 178 } 179 180 void Texture::setUsage(GLenum usage) 181 { 182 mUsage = usage; 183 } 184 185 GLenum Texture::getMinFilter() const 186 { 187 return mSamplerState.minFilter; 188 } 189 190 GLenum Texture::getMagFilter() const 191 { 192 return mSamplerState.magFilter; 193 } 194 195 GLenum Texture::getWrapS() const 196 { 197 return mSamplerState.wrapS; 198 } 199 200 GLenum Texture::getWrapT() const 201 { 202 return mSamplerState.wrapT; 203 } 204 205 GLenum Texture::getWrapR() const 206 { 207 return mSamplerState.wrapR; 208 } 209 210 float Texture::getMaxAnisotropy() const 211 { 212 return mSamplerState.maxAnisotropy; 213 } 214 215 GLenum Texture::getSwizzleRed() const 216 { 217 return mSamplerState.swizzleRed; 218 } 219 220 GLenum Texture::getSwizzleGreen() const 221 { 222 return mSamplerState.swizzleGreen; 223 } 224 225 GLenum Texture::getSwizzleBlue() const 226 { 227 return mSamplerState.swizzleBlue; 228 } 229 230 GLenum Texture::getSwizzleAlpha() const 231 { 232 return mSamplerState.swizzleAlpha; 233 } 234 235 GLint Texture::getBaseLevel() const 236 { 237 return mSamplerState.baseLevel; 238 } 239 240 GLint Texture::getMaxLevel() const 241 { 242 return mSamplerState.maxLevel; 243 } 244 245 GLfloat Texture::getMinLod() const 246 { 247 return mSamplerState.minLod; 248 } 249 250 GLfloat Texture::getMaxLod() const 251 { 252 return mSamplerState.maxLod; 253 } 254 255 bool Texture::isSwizzled() const 256 { 257 return mSamplerState.swizzleRed != GL_RED || 258 mSamplerState.swizzleGreen != GL_GREEN || 259 mSamplerState.swizzleBlue != GL_BLUE || 260 mSamplerState.swizzleAlpha != GL_ALPHA; 261 } 262 263 void Texture::getSamplerState(SamplerState *sampler) 264 { 265 *sampler = mSamplerState; 266 267 // Offset the effective base level by the texture storage's top level 268 rx::TextureStorageInterface *texture = getNativeTexture(); 269 int topLevel = texture ? texture->getTopLevel() : 0; 270 sampler->baseLevel = topLevel + mSamplerState.baseLevel; 271 } 272 273 GLenum Texture::getUsage() const 274 { 275 return mUsage; 276 } 277 278 GLint Texture::getBaseLevelWidth() const 279 { 280 const rx::Image *baseImage = getBaseLevelImage(); 281 return (baseImage ? baseImage->getWidth() : 0); 282 } 283 284 GLint Texture::getBaseLevelHeight() const 285 { 286 const rx::Image *baseImage = getBaseLevelImage(); 287 return (baseImage ? baseImage->getHeight() : 0); 288 } 289 290 GLint Texture::getBaseLevelDepth() const 291 { 292 const rx::Image *baseImage = getBaseLevelImage(); 293 return (baseImage ? baseImage->getDepth() : 0); 294 } 295 296 // Note: "base level image" is loosely defined to be any image from the base level, 297 // where in the base of 2D array textures and cube maps there are several. Don't use 298 // the base level image for anything except querying texture format and size. 299 GLenum Texture::getBaseLevelInternalFormat() const 300 { 301 const rx::Image *baseImage = getBaseLevelImage(); 302 return (baseImage ? baseImage->getInternalFormat() : GL_NONE); 303 } 304 305 void Texture::setImage(const PixelUnpackState &unpack, GLenum type, const void *pixels, rx::Image *image) 306 { 307 // No-op 308 if (image->getWidth() == 0 || image->getHeight() == 0 || image->getDepth() == 0) 309 { 310 return; 311 } 312 313 // We no longer need the "GLenum format" parameter to TexImage to determine what data format "pixels" contains. 314 // From our image internal format we know how many channels to expect, and "type" gives the format of pixel's components. 315 const void *pixelData = pixels; 316 317 if (unpack.pixelBuffer.id() != 0) 318 { 319 // Do a CPU readback here, if we have an unpack buffer bound and the fast GPU path is not supported 320 Buffer *pixelBuffer = unpack.pixelBuffer.get(); 321 ptrdiff_t offset = reinterpret_cast<ptrdiff_t>(pixels); 322 const void *bufferData = pixelBuffer->getStorage()->getData(); 323 pixelData = static_cast<const unsigned char *>(bufferData) + offset; 324 } 325 326 if (pixelData != NULL) 327 { 328 image->loadData(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth(), unpack.alignment, type, pixelData); 329 mDirtyImages = true; 330 } 331 } 332 333 bool Texture::isFastUnpackable(const PixelUnpackState &unpack, GLenum sizedInternalFormat) 334 { 335 return unpack.pixelBuffer.id() != 0 && mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat); 336 } 337 338 bool Texture::fastUnpackPixels(const PixelUnpackState &unpack, const void *pixels, const Box &destArea, 339 GLenum sizedInternalFormat, GLenum type, rx::RenderTarget *destRenderTarget) 340 { 341 if (destArea.width <= 0 && destArea.height <= 0 && destArea.depth <= 0) 342 { 343 return true; 344 } 345 346 // In order to perform the fast copy through the shader, we must have the right format, and be able 347 // to create a render target. 348 ASSERT(mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat)); 349 350 unsigned int offset = reinterpret_cast<unsigned int>(pixels); 351 352 return mRenderer->fastCopyBufferToTexture(unpack, offset, destRenderTarget, sizedInternalFormat, type, destArea); 353 } 354 355 void Texture::setCompressedImage(GLsizei imageSize, const void *pixels, rx::Image *image) 356 { 357 if (pixels != NULL) 358 { 359 image->loadCompressedData(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth(), pixels); 360 mDirtyImages = true; 361 } 362 } 363 364 bool Texture::subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, 365 GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels, rx::Image *image) 366 { 367 const void *pixelData = pixels; 368 369 // CPU readback & copy where direct GPU copy is not supported 370 if (unpack.pixelBuffer.id() != 0) 371 { 372 Buffer *pixelBuffer = unpack.pixelBuffer.get(); 373 unsigned int offset = reinterpret_cast<unsigned int>(pixels); 374 const void *bufferData = pixelBuffer->getStorage()->getData(); 375 pixelData = static_cast<const unsigned char *>(bufferData) + offset; 376 } 377 378 if (pixelData != NULL) 379 { 380 image->loadData(xoffset, yoffset, zoffset, width, height, depth, unpack.alignment, type, pixelData); 381 mDirtyImages = true; 382 } 383 384 return true; 385 } 386 387 bool Texture::subImageCompressed(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, 388 GLenum format, GLsizei imageSize, const void *pixels, rx::Image *image) 389 { 390 if (pixels != NULL) 391 { 392 image->loadCompressedData(xoffset, yoffset, zoffset, width, height, depth, pixels); 393 mDirtyImages = true; 394 } 395 396 return true; 397 } 398 399 rx::TextureStorageInterface *Texture::getNativeTexture() 400 { 401 // ensure the underlying texture is created 402 initializeStorage(false); 403 404 rx::TextureStorageInterface *storage = getBaseLevelStorage(); 405 if (storage) 406 { 407 updateStorage(); 408 } 409 410 return storage; 411 } 412 413 bool Texture::hasDirtyImages() const 414 { 415 return mDirtyImages; 416 } 417 418 void Texture::resetDirty() 419 { 420 mDirtyImages = false; 421 } 422 423 unsigned int Texture::getTextureSerial() 424 { 425 rx::TextureStorageInterface *texture = getNativeTexture(); 426 return texture ? texture->getTextureSerial() : 0; 427 } 428 429 bool Texture::isImmutable() const 430 { 431 return mImmutable; 432 } 433 434 int Texture::immutableLevelCount() 435 { 436 return (mImmutable ? getNativeTexture()->getStorageInstance()->getLevelCount() : 0); 437 } 438 439 GLint Texture::creationLevels(GLsizei width, GLsizei height, GLsizei depth) const 440 { 441 if ((isPow2(width) && isPow2(height) && isPow2(depth)) || mRenderer->getNonPower2TextureSupport()) 442 { 443 // Maximum number of levels 444 return log2(std::max(std::max(width, height), depth)) + 1; 445 } 446 else 447 { 448 // OpenGL ES 2.0 without GL_OES_texture_npot does not permit NPOT mipmaps. 449 return 1; 450 } 451 } 452 453 int Texture::mipLevels() const 454 { 455 return log2(std::max(std::max(getBaseLevelWidth(), getBaseLevelHeight()), getBaseLevelDepth())) + 1; 456 } 457 458 Texture2D::Texture2D(rx::Renderer *renderer, GLuint id) : Texture(renderer, id, GL_TEXTURE_2D) 459 { 460 mTexStorage = NULL; 461 mSurface = NULL; 462 463 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i) 464 { 465 mImageArray[i] = renderer->createImage(); 466 } 467 } 468 469 Texture2D::~Texture2D() 470 { 471 delete mTexStorage; 472 mTexStorage = NULL; 473 474 if (mSurface) 475 { 476 mSurface->setBoundTexture(NULL); 477 mSurface = NULL; 478 } 479 480 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i) 481 { 482 delete mImageArray[i]; 483 } 484 } 485 486 GLsizei Texture2D::getWidth(GLint level) const 487 { 488 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 489 return mImageArray[level]->getWidth(); 490 else 491 return 0; 492 } 493 494 GLsizei Texture2D::getHeight(GLint level) const 495 { 496 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 497 return mImageArray[level]->getHeight(); 498 else 499 return 0; 500 } 501 502 GLenum Texture2D::getInternalFormat(GLint level) const 503 { 504 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 505 return mImageArray[level]->getInternalFormat(); 506 else 507 return GL_NONE; 508 } 509 510 GLenum Texture2D::getActualFormat(GLint level) const 511 { 512 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 513 return mImageArray[level]->getActualFormat(); 514 else 515 return GL_NONE; 516 } 517 518 void Texture2D::redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height) 519 { 520 releaseTexImage(); 521 522 // If there currently is a corresponding storage texture image, it has these parameters 523 const int storageWidth = std::max(1, getBaseLevelWidth() >> level); 524 const int storageHeight = std::max(1, getBaseLevelHeight() >> level); 525 const GLenum storageFormat = getBaseLevelInternalFormat(); 526 527 mImageArray[level]->redefine(mRenderer, GL_TEXTURE_2D, internalformat, width, height, 1, false); 528 529 if (mTexStorage) 530 { 531 const int storageLevels = mTexStorage->getLevelCount(); 532 533 if ((level >= storageLevels && storageLevels != 0) || 534 width != storageWidth || 535 height != storageHeight || 536 internalformat != storageFormat) // Discard mismatched storage 537 { 538 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) 539 { 540 mImageArray[i]->markDirty(); 541 } 542 543 delete mTexStorage; 544 mTexStorage = NULL; 545 mDirtyImages = true; 546 } 547 } 548 } 549 550 void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 551 { 552 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 553 GLenum sizedInternalFormat = IsSizedInternalFormat(internalFormat, clientVersion) ? internalFormat 554 : GetSizedInternalFormat(format, type, clientVersion); 555 redefineImage(level, sizedInternalFormat, width, height); 556 557 bool fastUnpacked = false; 558 559 // Attempt a fast gpu copy of the pixel data to the surface 560 if (isFastUnpackable(unpack, sizedInternalFormat) && isLevelComplete(level)) 561 { 562 // Will try to create RT storage if it does not exist 563 rx::RenderTarget *destRenderTarget = getRenderTarget(level); 564 Box destArea(0, 0, 0, getWidth(level), getHeight(level), 1); 565 566 if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type, destRenderTarget)) 567 { 568 // Ensure we don't overwrite our newly initialized data 569 mImageArray[level]->markClean(); 570 571 fastUnpacked = true; 572 } 573 } 574 575 if (!fastUnpacked) 576 { 577 Texture::setImage(unpack, type, pixels, mImageArray[level]); 578 } 579 } 580 581 void Texture2D::bindTexImage(egl::Surface *surface) 582 { 583 releaseTexImage(); 584 585 GLenum internalformat = surface->getFormat(); 586 587 mImageArray[0]->redefine(mRenderer, GL_TEXTURE_2D, internalformat, surface->getWidth(), surface->getHeight(), 1, true); 588 589 delete mTexStorage; 590 mTexStorage = new rx::TextureStorageInterface2D(mRenderer, surface->getSwapChain()); 591 592 mDirtyImages = true; 593 mSurface = surface; 594 mSurface->setBoundTexture(this); 595 } 596 597 void Texture2D::releaseTexImage() 598 { 599 if (mSurface) 600 { 601 mSurface->setBoundTexture(NULL); 602 mSurface = NULL; 603 604 if (mTexStorage) 605 { 606 delete mTexStorage; 607 mTexStorage = NULL; 608 } 609 610 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) 611 { 612 mImageArray[i]->redefine(mRenderer, GL_TEXTURE_2D, GL_NONE, 0, 0, 0, true); 613 } 614 } 615 } 616 617 void Texture2D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels) 618 { 619 // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly 620 redefineImage(level, format, width, height); 621 622 Texture::setCompressedImage(imageSize, pixels, mImageArray[level]); 623 } 624 625 void Texture2D::commitRect(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) 626 { 627 if (isValidLevel(level)) 628 { 629 rx::Image *image = mImageArray[level]; 630 if (image->copyToStorage(mTexStorage, level, xoffset, yoffset, width, height)) 631 { 632 image->markClean(); 633 } 634 } 635 } 636 637 void Texture2D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 638 { 639 bool fastUnpacked = false; 640 641 if (isFastUnpackable(unpack, getInternalFormat(level)) && isLevelComplete(level)) 642 { 643 rx::RenderTarget *renderTarget = getRenderTarget(level); 644 Box destArea(xoffset, yoffset, 0, width, height, 1); 645 646 if (renderTarget && fastUnpackPixels(unpack, pixels, destArea, getInternalFormat(level), type, renderTarget)) 647 { 648 // Ensure we don't overwrite our newly initialized data 649 mImageArray[level]->markClean(); 650 651 fastUnpacked = true; 652 } 653 } 654 655 if (!fastUnpacked && Texture::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels, mImageArray[level])) 656 { 657 commitRect(level, xoffset, yoffset, width, height); 658 } 659 } 660 661 void Texture2D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) 662 { 663 if (Texture::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, mImageArray[level])) 664 { 665 commitRect(level, xoffset, yoffset, width, height); 666 } 667 } 668 669 void Texture2D::copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) 670 { 671 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 672 GLenum sizedInternalFormat = IsSizedInternalFormat(format, clientVersion) ? format 673 : GetSizedInternalFormat(format, GL_UNSIGNED_BYTE, clientVersion); 674 redefineImage(level, sizedInternalFormat, width, height); 675 676 if (!mImageArray[level]->isRenderableFormat()) 677 { 678 mImageArray[level]->copy(0, 0, 0, x, y, width, height, source); 679 mDirtyImages = true; 680 } 681 else 682 { 683 ensureRenderTarget(); 684 mImageArray[level]->markClean(); 685 686 if (width != 0 && height != 0 && isValidLevel(level)) 687 { 688 gl::Rectangle sourceRect; 689 sourceRect.x = x; 690 sourceRect.width = width; 691 sourceRect.y = y; 692 sourceRect.height = height; 693 694 mRenderer->copyImage(source, sourceRect, format, 0, 0, mTexStorage, level); 695 } 696 } 697 } 698 699 void Texture2D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) 700 { 701 // can only make our texture storage to a render target if level 0 is defined (with a width & height) and 702 // the current level we're copying to is defined (with appropriate format, width & height) 703 bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0); 704 705 if (!mImageArray[level]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget)) 706 { 707 mImageArray[level]->copy(xoffset, yoffset, 0, x, y, width, height, source); 708 mDirtyImages = true; 709 } 710 else 711 { 712 ensureRenderTarget(); 713 714 if (isValidLevel(level)) 715 { 716 updateStorageLevel(level); 717 718 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 719 720 gl::Rectangle sourceRect; 721 sourceRect.x = x; 722 sourceRect.width = width; 723 sourceRect.y = y; 724 sourceRect.height = height; 725 726 mRenderer->copyImage(source, sourceRect, 727 gl::GetFormat(getBaseLevelInternalFormat(), clientVersion), 728 xoffset, yoffset, mTexStorage, level); 729 } 730 } 731 } 732 733 void Texture2D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) 734 { 735 for (int level = 0; level < levels; level++) 736 { 737 GLsizei levelWidth = std::max(1, width >> level); 738 GLsizei levelHeight = std::max(1, height >> level); 739 mImageArray[level]->redefine(mRenderer, GL_TEXTURE_2D, internalformat, levelWidth, levelHeight, 1, true); 740 } 741 742 for (int level = levels; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) 743 { 744 mImageArray[level]->redefine(mRenderer, GL_TEXTURE_2D, GL_NONE, 0, 0, 0, true); 745 } 746 747 mImmutable = true; 748 749 setCompleteTexStorage(new rx::TextureStorageInterface2D(mRenderer, internalformat, IsRenderTargetUsage(mUsage), width, height, levels)); 750 } 751 752 void Texture2D::setCompleteTexStorage(rx::TextureStorageInterface2D *newCompleteTexStorage) 753 { 754 SafeDelete(mTexStorage); 755 mTexStorage = newCompleteTexStorage; 756 757 if (mTexStorage && mTexStorage->isManaged()) 758 { 759 for (int level = 0; level < mTexStorage->getLevelCount(); level++) 760 { 761 mImageArray[level]->setManagedSurface(mTexStorage, level); 762 } 763 } 764 765 mDirtyImages = true; 766 } 767 768 // Tests for 2D texture sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 85. 769 bool Texture2D::isSamplerComplete(const SamplerState &samplerState) const 770 { 771 GLsizei width = getBaseLevelWidth(); 772 GLsizei height = getBaseLevelHeight(); 773 774 if (width <= 0 || height <= 0) 775 { 776 return false; 777 } 778 779 if (!IsTextureFilteringSupported(getInternalFormat(0), mRenderer)) 780 { 781 if (samplerState.magFilter != GL_NEAREST || 782 (samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST)) 783 { 784 return false; 785 } 786 } 787 788 bool npotSupport = mRenderer->getNonPower2TextureSupport(); 789 790 if (!npotSupport) 791 { 792 if ((samplerState.wrapS != GL_CLAMP_TO_EDGE && !isPow2(width)) || 793 (samplerState.wrapT != GL_CLAMP_TO_EDGE && !isPow2(height))) 794 { 795 return false; 796 } 797 } 798 799 if (IsMipmapFiltered(samplerState)) 800 { 801 if (!npotSupport) 802 { 803 if (!isPow2(width) || !isPow2(height)) 804 { 805 return false; 806 } 807 } 808 809 if (!isMipmapComplete()) 810 { 811 return false; 812 } 813 } 814 815 // OpenGLES 3.0.2 spec section 3.8.13 states that a texture is not mipmap complete if: 816 // The internalformat specified for the texture arrays is a sized internal depth or 817 // depth and stencil format (see table 3.13), the value of TEXTURE_COMPARE_- 818 // MODE is NONE, and either the magnification filter is not NEAREST or the mini- 819 // fication filter is neither NEAREST nor NEAREST_MIPMAP_NEAREST. 820 if (gl::GetDepthBits(getInternalFormat(0), mRenderer->getCurrentClientVersion()) > 0 && 821 mRenderer->getCurrentClientVersion() > 2) 822 { 823 if (mSamplerState.compareMode == GL_NONE) 824 { 825 if ((mSamplerState.minFilter != GL_NEAREST && mSamplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST) || 826 mSamplerState.magFilter != GL_NEAREST) 827 { 828 return false; 829 } 830 } 831 } 832 833 return true; 834 } 835 836 // Tests for 2D texture (mipmap) completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81. 837 bool Texture2D::isMipmapComplete() const 838 { 839 int levelCount = mipLevels(); 840 841 for (int level = 0; level < levelCount; level++) 842 { 843 if (!isLevelComplete(level)) 844 { 845 return false; 846 } 847 } 848 849 return true; 850 } 851 852 bool Texture2D::isLevelComplete(int level) const 853 { 854 if (isImmutable()) 855 { 856 return true; 857 } 858 859 const rx::Image *baseImage = getBaseLevelImage(); 860 861 GLsizei width = baseImage->getWidth(); 862 GLsizei height = baseImage->getHeight(); 863 864 if (width <= 0 || height <= 0) 865 { 866 return false; 867 } 868 869 // The base image level is complete if the width and height are positive 870 if (level == 0) 871 { 872 return true; 873 } 874 875 ASSERT(level >= 1 && level <= (int)ArraySize(mImageArray) && mImageArray[level] != NULL); 876 rx::Image *image = mImageArray[level]; 877 878 if (image->getInternalFormat() != baseImage->getInternalFormat()) 879 { 880 return false; 881 } 882 883 if (image->getWidth() != std::max(1, width >> level)) 884 { 885 return false; 886 } 887 888 if (image->getHeight() != std::max(1, height >> level)) 889 { 890 return false; 891 } 892 893 return true; 894 } 895 896 bool Texture2D::isCompressed(GLint level) const 897 { 898 return IsFormatCompressed(getInternalFormat(level), mRenderer->getCurrentClientVersion()); 899 } 900 901 bool Texture2D::isDepth(GLint level) const 902 { 903 return GetDepthBits(getInternalFormat(level), mRenderer->getCurrentClientVersion()) > 0; 904 } 905 906 // Constructs a native texture resource from the texture images 907 void Texture2D::initializeStorage(bool renderTarget) 908 { 909 // Only initialize the first time this texture is used as a render target or shader resource 910 if (mTexStorage) 911 { 912 return; 913 } 914 915 // do not attempt to create storage for nonexistant data 916 if (!isLevelComplete(0)) 917 { 918 return; 919 } 920 921 bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mUsage)); 922 923 setCompleteTexStorage(createCompleteStorage(createRenderTarget)); 924 ASSERT(mTexStorage); 925 926 // flush image data to the storage 927 updateStorage(); 928 } 929 930 rx::TextureStorageInterface2D *Texture2D::createCompleteStorage(bool renderTarget) const 931 { 932 GLsizei width = getBaseLevelWidth(); 933 GLsizei height = getBaseLevelHeight(); 934 935 ASSERT(width > 0 && height > 0); 936 937 // use existing storage level count, when previously specified by TexStorage*D 938 GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1)); 939 940 return new rx::TextureStorageInterface2D(mRenderer, getBaseLevelInternalFormat(), renderTarget, width, height, levels); 941 } 942 943 void Texture2D::updateStorage() 944 { 945 ASSERT(mTexStorage != NULL); 946 GLint storageLevels = mTexStorage->getLevelCount(); 947 for (int level = 0; level < storageLevels; level++) 948 { 949 if (mImageArray[level]->isDirty() && isLevelComplete(level)) 950 { 951 updateStorageLevel(level); 952 } 953 } 954 } 955 956 void Texture2D::updateStorageLevel(int level) 957 { 958 ASSERT(level <= (int)ArraySize(mImageArray) && mImageArray[level] != NULL); 959 ASSERT(isLevelComplete(level)); 960 961 if (mImageArray[level]->isDirty()) 962 { 963 commitRect(level, 0, 0, getWidth(level), getHeight(level)); 964 } 965 } 966 967 bool Texture2D::ensureRenderTarget() 968 { 969 initializeStorage(true); 970 971 if (getBaseLevelWidth() > 0 && getBaseLevelHeight() > 0) 972 { 973 ASSERT(mTexStorage); 974 if (!mTexStorage->isRenderTarget()) 975 { 976 rx::TextureStorageInterface2D *newRenderTargetStorage = createCompleteStorage(true); 977 978 if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage)) 979 { 980 delete newRenderTargetStorage; 981 return gl::error(GL_OUT_OF_MEMORY, false); 982 } 983 984 setCompleteTexStorage(newRenderTargetStorage); 985 } 986 } 987 988 return (mTexStorage && mTexStorage->isRenderTarget()); 989 } 990 991 void Texture2D::generateMipmaps() 992 { 993 // Purge array levels 1 through q and reset them to represent the generated mipmap levels. 994 int levelCount = mipLevels(); 995 for (int level = 1; level < levelCount; level++) 996 { 997 redefineImage(level, getBaseLevelInternalFormat(), 998 std::max(getBaseLevelWidth() >> level, 1), 999 std::max(getBaseLevelHeight() >> level, 1)); 1000 } 1001 1002 if (mTexStorage && mTexStorage->isRenderTarget()) 1003 { 1004 for (int level = 1; level < levelCount; level++) 1005 { 1006 mTexStorage->generateMipmap(level); 1007 1008 mImageArray[level]->markClean(); 1009 } 1010 } 1011 else 1012 { 1013 for (int level = 1; level < levelCount; level++) 1014 { 1015 mRenderer->generateMipmap(mImageArray[level], mImageArray[level - 1]); 1016 } 1017 } 1018 } 1019 1020 const rx::Image *Texture2D::getBaseLevelImage() const 1021 { 1022 return mImageArray[0]; 1023 } 1024 1025 rx::TextureStorageInterface *Texture2D::getBaseLevelStorage() 1026 { 1027 return mTexStorage; 1028 } 1029 1030 FramebufferAttachment *Texture2D::getAttachment(GLint level) 1031 { 1032 FramebufferAttachment *attachment = mRenderbufferProxies.get(level, 0); 1033 if (!attachment) 1034 { 1035 attachment = new FramebufferAttachment(mRenderer, id(), new Texture2DAttachment(this, level)); 1036 mRenderbufferProxies.add(level, 0, attachment); 1037 } 1038 1039 return attachment; 1040 } 1041 1042 unsigned int Texture2D::getRenderTargetSerial(GLint level) 1043 { 1044 return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level) : 0); 1045 } 1046 1047 rx::RenderTarget *Texture2D::getRenderTarget(GLint level) 1048 { 1049 // ensure the underlying texture is created 1050 if (!ensureRenderTarget()) 1051 { 1052 return NULL; 1053 } 1054 1055 updateStorageLevel(level); 1056 1057 // ensure this is NOT a depth texture 1058 if (isDepth(level)) 1059 { 1060 return NULL; 1061 } 1062 1063 return mTexStorage->getRenderTarget(level); 1064 } 1065 1066 rx::RenderTarget *Texture2D::getDepthSencil(GLint level) 1067 { 1068 // ensure the underlying texture is created 1069 if (!ensureRenderTarget()) 1070 { 1071 return NULL; 1072 } 1073 1074 updateStorageLevel(level); 1075 1076 // ensure this is actually a depth texture 1077 if (!isDepth(level)) 1078 { 1079 return NULL; 1080 } 1081 1082 return mTexStorage->getRenderTarget(level); 1083 } 1084 1085 bool Texture2D::isValidLevel(int level) const 1086 { 1087 return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : false); 1088 } 1089 1090 TextureCubeMap::TextureCubeMap(rx::Renderer *renderer, GLuint id) : Texture(renderer, id, GL_TEXTURE_CUBE_MAP) 1091 { 1092 mTexStorage = NULL; 1093 for (int i = 0; i < 6; i++) 1094 { 1095 for (int j = 0; j < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j) 1096 { 1097 mImageArray[i][j] = renderer->createImage(); 1098 } 1099 } 1100 } 1101 1102 TextureCubeMap::~TextureCubeMap() 1103 { 1104 for (int i = 0; i < 6; i++) 1105 { 1106 for (int j = 0; j < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j) 1107 { 1108 delete mImageArray[i][j]; 1109 } 1110 } 1111 1112 delete mTexStorage; 1113 mTexStorage = NULL; 1114 } 1115 1116 GLsizei TextureCubeMap::getWidth(GLenum target, GLint level) const 1117 { 1118 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 1119 return mImageArray[targetToIndex(target)][level]->getWidth(); 1120 else 1121 return 0; 1122 } 1123 1124 GLsizei TextureCubeMap::getHeight(GLenum target, GLint level) const 1125 { 1126 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 1127 return mImageArray[targetToIndex(target)][level]->getHeight(); 1128 else 1129 return 0; 1130 } 1131 1132 GLenum TextureCubeMap::getInternalFormat(GLenum target, GLint level) const 1133 { 1134 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 1135 return mImageArray[targetToIndex(target)][level]->getInternalFormat(); 1136 else 1137 return GL_NONE; 1138 } 1139 1140 GLenum TextureCubeMap::getActualFormat(GLenum target, GLint level) const 1141 { 1142 if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) 1143 return mImageArray[targetToIndex(target)][level]->getActualFormat(); 1144 else 1145 return GL_NONE; 1146 } 1147 1148 void TextureCubeMap::setImagePosX(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1149 { 1150 setImage(0, level, width, height, internalFormat, format, type, unpack, pixels); 1151 } 1152 1153 void TextureCubeMap::setImageNegX(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1154 { 1155 setImage(1, level, width, height, internalFormat, format, type, unpack, pixels); 1156 } 1157 1158 void TextureCubeMap::setImagePosY(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1159 { 1160 setImage(2, level, width, height, internalFormat, format, type, unpack, pixels); 1161 } 1162 1163 void TextureCubeMap::setImageNegY(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1164 { 1165 setImage(3, level, width, height, internalFormat, format, type, unpack, pixels); 1166 } 1167 1168 void TextureCubeMap::setImagePosZ(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1169 { 1170 setImage(4, level, width, height, internalFormat, format, type, unpack, pixels); 1171 } 1172 1173 void TextureCubeMap::setImageNegZ(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1174 { 1175 setImage(5, level, width, height, internalFormat, format, type, unpack, pixels); 1176 } 1177 1178 void TextureCubeMap::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels) 1179 { 1180 // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly 1181 int faceIndex = targetToIndex(target); 1182 redefineImage(faceIndex, level, format, width, height); 1183 1184 Texture::setCompressedImage(imageSize, pixels, mImageArray[faceIndex][level]); 1185 } 1186 1187 void TextureCubeMap::commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) 1188 { 1189 if (isValidFaceLevel(faceIndex, level)) 1190 { 1191 rx::Image *image = mImageArray[faceIndex][level]; 1192 if (image->copyToStorage(mTexStorage, faceIndex, level, xoffset, yoffset, width, height)) 1193 image->markClean(); 1194 } 1195 } 1196 1197 void TextureCubeMap::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1198 { 1199 int faceIndex = targetToIndex(target); 1200 if (Texture::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels, mImageArray[faceIndex][level])) 1201 { 1202 commitRect(faceIndex, level, xoffset, yoffset, width, height); 1203 } 1204 } 1205 1206 void TextureCubeMap::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) 1207 { 1208 int faceIndex = targetToIndex(target); 1209 if (Texture::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, mImageArray[faceIndex][level])) 1210 { 1211 commitRect(faceIndex, level, xoffset, yoffset, width, height); 1212 } 1213 } 1214 1215 // Tests for cube map sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 86. 1216 bool TextureCubeMap::isSamplerComplete(const SamplerState &samplerState) const 1217 { 1218 int size = getBaseLevelWidth(); 1219 1220 bool mipmapping = IsMipmapFiltered(samplerState); 1221 1222 if (!IsTextureFilteringSupported(getInternalFormat(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0), mRenderer)) 1223 { 1224 if (samplerState.magFilter != GL_NEAREST || 1225 (samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST)) 1226 { 1227 return false; 1228 } 1229 } 1230 1231 if (!isPow2(size) && !mRenderer->getNonPower2TextureSupport()) 1232 { 1233 if (samplerState.wrapS != GL_CLAMP_TO_EDGE || samplerState.wrapT != GL_CLAMP_TO_EDGE || mipmapping) 1234 { 1235 return false; 1236 } 1237 } 1238 1239 if (!mipmapping) 1240 { 1241 if (!isCubeComplete()) 1242 { 1243 return false; 1244 } 1245 } 1246 else 1247 { 1248 if (!isMipmapCubeComplete()) // Also tests for isCubeComplete() 1249 { 1250 return false; 1251 } 1252 } 1253 1254 return true; 1255 } 1256 1257 // Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81. 1258 bool TextureCubeMap::isCubeComplete() const 1259 { 1260 int baseWidth = getBaseLevelWidth(); 1261 int baseHeight = getBaseLevelHeight(); 1262 GLenum baseFormat = getBaseLevelInternalFormat(); 1263 1264 if (baseWidth <= 0 || baseWidth != baseHeight) 1265 { 1266 return false; 1267 } 1268 1269 for (int faceIndex = 1; faceIndex < 6; faceIndex++) 1270 { 1271 const rx::Image &faceBaseImage = *mImageArray[faceIndex][0]; 1272 1273 if (faceBaseImage.getWidth() != baseWidth || 1274 faceBaseImage.getHeight() != baseHeight || 1275 faceBaseImage.getInternalFormat() != baseFormat ) 1276 { 1277 return false; 1278 } 1279 } 1280 1281 return true; 1282 } 1283 1284 bool TextureCubeMap::isMipmapCubeComplete() const 1285 { 1286 if (isImmutable()) 1287 { 1288 return true; 1289 } 1290 1291 if (!isCubeComplete()) 1292 { 1293 return false; 1294 } 1295 1296 int levelCount = mipLevels(); 1297 1298 for (int face = 0; face < 6; face++) 1299 { 1300 for (int level = 1; level < levelCount; level++) 1301 { 1302 if (!isFaceLevelComplete(face, level)) 1303 { 1304 return false; 1305 } 1306 } 1307 } 1308 1309 return true; 1310 } 1311 1312 bool TextureCubeMap::isFaceLevelComplete(int faceIndex, int level) const 1313 { 1314 ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) && mImageArray[faceIndex][level] != NULL); 1315 1316 if (isImmutable()) 1317 { 1318 return true; 1319 } 1320 1321 int baseSize = getBaseLevelWidth(); 1322 1323 if (baseSize <= 0) 1324 { 1325 return false; 1326 } 1327 1328 // "isCubeComplete" checks for base level completeness and we must call that 1329 // to determine if any face at level 0 is complete. We omit that check here 1330 // to avoid re-checking cube-completeness for every face at level 0. 1331 if (level == 0) 1332 { 1333 return true; 1334 } 1335 1336 // Check that non-zero levels are consistent with the base level. 1337 const rx::Image *faceLevelImage = mImageArray[faceIndex][level]; 1338 1339 if (faceLevelImage->getInternalFormat() != getBaseLevelInternalFormat()) 1340 { 1341 return false; 1342 } 1343 1344 if (faceLevelImage->getWidth() != std::max(1, baseSize >> level)) 1345 { 1346 return false; 1347 } 1348 1349 return true; 1350 } 1351 1352 bool TextureCubeMap::isCompressed(GLenum target, GLint level) const 1353 { 1354 return IsFormatCompressed(getInternalFormat(target, level), mRenderer->getCurrentClientVersion()); 1355 } 1356 1357 bool TextureCubeMap::isDepth(GLenum target, GLint level) const 1358 { 1359 return GetDepthBits(getInternalFormat(target, level), mRenderer->getCurrentClientVersion()) > 0; 1360 } 1361 1362 void TextureCubeMap::initializeStorage(bool renderTarget) 1363 { 1364 // Only initialize the first time this texture is used as a render target or shader resource 1365 if (mTexStorage) 1366 { 1367 return; 1368 } 1369 1370 // do not attempt to create storage for nonexistant data 1371 if (!isFaceLevelComplete(0, 0)) 1372 { 1373 return; 1374 } 1375 1376 bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mUsage)); 1377 1378 setCompleteTexStorage(createCompleteStorage(createRenderTarget)); 1379 ASSERT(mTexStorage); 1380 1381 // flush image data to the storage 1382 updateStorage(); 1383 } 1384 1385 rx::TextureStorageInterfaceCube *TextureCubeMap::createCompleteStorage(bool renderTarget) const 1386 { 1387 GLsizei size = getBaseLevelWidth(); 1388 1389 ASSERT(size > 0); 1390 1391 // use existing storage level count, when previously specified by TexStorage*D 1392 GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(size, size, 1)); 1393 1394 return new rx::TextureStorageInterfaceCube(mRenderer, getBaseLevelInternalFormat(), renderTarget, size, levels); 1395 } 1396 1397 void TextureCubeMap::setCompleteTexStorage(rx::TextureStorageInterfaceCube *newCompleteTexStorage) 1398 { 1399 SafeDelete(mTexStorage); 1400 mTexStorage = newCompleteTexStorage; 1401 1402 if (mTexStorage && mTexStorage->isManaged()) 1403 { 1404 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1405 { 1406 for (int level = 0; level < mTexStorage->getLevelCount(); level++) 1407 { 1408 mImageArray[faceIndex][level]->setManagedSurface(mTexStorage, faceIndex, level); 1409 } 1410 } 1411 } 1412 1413 mDirtyImages = true; 1414 } 1415 1416 void TextureCubeMap::updateStorage() 1417 { 1418 ASSERT(mTexStorage != NULL); 1419 GLint storageLevels = mTexStorage->getLevelCount(); 1420 for (int face = 0; face < 6; face++) 1421 { 1422 for (int level = 0; level < storageLevels; level++) 1423 { 1424 if (mImageArray[face][level]->isDirty() && isFaceLevelComplete(face, level)) 1425 { 1426 updateStorageFaceLevel(face, level); 1427 } 1428 } 1429 } 1430 } 1431 1432 void TextureCubeMap::updateStorageFaceLevel(int faceIndex, int level) 1433 { 1434 ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) && mImageArray[faceIndex][level] != NULL); 1435 rx::Image *image = mImageArray[faceIndex][level]; 1436 1437 if (image->isDirty()) 1438 { 1439 commitRect(faceIndex, level, 0, 0, image->getWidth(), image->getHeight()); 1440 } 1441 } 1442 1443 bool TextureCubeMap::ensureRenderTarget() 1444 { 1445 initializeStorage(true); 1446 1447 if (getBaseLevelWidth() > 0) 1448 { 1449 ASSERT(mTexStorage); 1450 if (!mTexStorage->isRenderTarget()) 1451 { 1452 rx::TextureStorageInterfaceCube *newRenderTargetStorage = createCompleteStorage(true); 1453 1454 if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage)) 1455 { 1456 delete newRenderTargetStorage; 1457 return gl::error(GL_OUT_OF_MEMORY, false); 1458 } 1459 1460 setCompleteTexStorage(newRenderTargetStorage); 1461 } 1462 } 1463 1464 return (mTexStorage && mTexStorage->isRenderTarget()); 1465 } 1466 1467 void TextureCubeMap::setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1468 { 1469 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 1470 GLenum sizedInternalFormat = IsSizedInternalFormat(internalFormat, clientVersion) ? internalFormat 1471 : GetSizedInternalFormat(format, type, clientVersion); 1472 1473 redefineImage(faceIndex, level, sizedInternalFormat, width, height); 1474 1475 Texture::setImage(unpack, type, pixels, mImageArray[faceIndex][level]); 1476 } 1477 1478 int TextureCubeMap::targetToIndex(GLenum target) 1479 { 1480 META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 1); 1481 META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 2); 1482 META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 3); 1483 META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 4); 1484 META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 5); 1485 1486 return target - GL_TEXTURE_CUBE_MAP_POSITIVE_X; 1487 } 1488 1489 void TextureCubeMap::redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height) 1490 { 1491 // If there currently is a corresponding storage texture image, it has these parameters 1492 const int storageWidth = std::max(1, getBaseLevelWidth() >> level); 1493 const int storageHeight = std::max(1, getBaseLevelHeight() >> level); 1494 const GLenum storageFormat = getBaseLevelInternalFormat(); 1495 1496 mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, width, height, 1, false); 1497 1498 if (mTexStorage) 1499 { 1500 const int storageLevels = mTexStorage->getLevelCount(); 1501 1502 if ((level >= storageLevels && storageLevels != 0) || 1503 width != storageWidth || 1504 height != storageHeight || 1505 internalformat != storageFormat) // Discard mismatched storage 1506 { 1507 for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) 1508 { 1509 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1510 { 1511 mImageArray[faceIndex][level]->markDirty(); 1512 } 1513 } 1514 1515 delete mTexStorage; 1516 mTexStorage = NULL; 1517 1518 mDirtyImages = true; 1519 } 1520 } 1521 } 1522 1523 void TextureCubeMap::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) 1524 { 1525 int faceIndex = targetToIndex(target); 1526 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 1527 GLenum sizedInternalFormat = IsSizedInternalFormat(format, clientVersion) ? format 1528 : GetSizedInternalFormat(format, GL_UNSIGNED_BYTE, clientVersion); 1529 redefineImage(faceIndex, level, sizedInternalFormat, width, height); 1530 1531 if (!mImageArray[faceIndex][level]->isRenderableFormat()) 1532 { 1533 mImageArray[faceIndex][level]->copy(0, 0, 0, x, y, width, height, source); 1534 mDirtyImages = true; 1535 } 1536 else 1537 { 1538 ensureRenderTarget(); 1539 mImageArray[faceIndex][level]->markClean(); 1540 1541 ASSERT(width == height); 1542 1543 if (width > 0 && isValidFaceLevel(faceIndex, level)) 1544 { 1545 gl::Rectangle sourceRect; 1546 sourceRect.x = x; 1547 sourceRect.width = width; 1548 sourceRect.y = y; 1549 sourceRect.height = height; 1550 1551 mRenderer->copyImage(source, sourceRect, format, 0, 0, mTexStorage, target, level); 1552 } 1553 } 1554 } 1555 1556 void TextureCubeMap::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) 1557 { 1558 int faceIndex = targetToIndex(target); 1559 1560 // We can only make our texture storage to a render target if the level we're copying *to* is complete 1561 // and the base level is cube-complete. The base level must be cube complete (common case) because we cannot 1562 // rely on the "getBaseLevel*" methods reliably otherwise. 1563 bool canCreateRenderTarget = isFaceLevelComplete(faceIndex, level) && isCubeComplete(); 1564 1565 if (!mImageArray[faceIndex][level]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget)) 1566 { 1567 mImageArray[faceIndex][level]->copy(0, 0, 0, x, y, width, height, source); 1568 mDirtyImages = true; 1569 } 1570 else 1571 { 1572 ensureRenderTarget(); 1573 1574 if (isValidFaceLevel(faceIndex, level)) 1575 { 1576 updateStorageFaceLevel(faceIndex, level); 1577 1578 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 1579 1580 gl::Rectangle sourceRect; 1581 sourceRect.x = x; 1582 sourceRect.width = width; 1583 sourceRect.y = y; 1584 sourceRect.height = height; 1585 1586 mRenderer->copyImage(source, sourceRect, gl::GetFormat(getBaseLevelInternalFormat(), clientVersion), 1587 xoffset, yoffset, mTexStorage, target, level); 1588 } 1589 } 1590 } 1591 1592 void TextureCubeMap::storage(GLsizei levels, GLenum internalformat, GLsizei size) 1593 { 1594 for (int level = 0; level < levels; level++) 1595 { 1596 GLsizei mipSize = std::max(1, size >> level); 1597 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1598 { 1599 mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, mipSize, mipSize, 1, true); 1600 } 1601 } 1602 1603 for (int level = levels; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) 1604 { 1605 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1606 { 1607 mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, GL_NONE, 0, 0, 0, true); 1608 } 1609 } 1610 1611 mImmutable = true; 1612 1613 setCompleteTexStorage(new rx::TextureStorageInterfaceCube(mRenderer, internalformat, IsRenderTargetUsage(mUsage), size, levels)); 1614 } 1615 1616 void TextureCubeMap::generateMipmaps() 1617 { 1618 // Purge array levels 1 through q and reset them to represent the generated mipmap levels. 1619 int levelCount = mipLevels(); 1620 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1621 { 1622 for (int level = 1; level < levelCount; level++) 1623 { 1624 int faceLevelSize = (std::max(mImageArray[faceIndex][0]->getWidth() >> level, 1)); 1625 redefineImage(faceIndex, level, mImageArray[faceIndex][0]->getInternalFormat(), faceLevelSize, faceLevelSize); 1626 } 1627 } 1628 1629 if (mTexStorage && mTexStorage->isRenderTarget()) 1630 { 1631 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1632 { 1633 for (int level = 1; level < levelCount; level++) 1634 { 1635 mTexStorage->generateMipmap(faceIndex, level); 1636 1637 mImageArray[faceIndex][level]->markClean(); 1638 } 1639 } 1640 } 1641 else 1642 { 1643 for (int faceIndex = 0; faceIndex < 6; faceIndex++) 1644 { 1645 for (int level = 1; level < levelCount; level++) 1646 { 1647 mRenderer->generateMipmap(mImageArray[faceIndex][level], mImageArray[faceIndex][level - 1]); 1648 } 1649 } 1650 } 1651 } 1652 1653 const rx::Image *TextureCubeMap::getBaseLevelImage() const 1654 { 1655 // Note: if we are not cube-complete, there is no single base level image that can describe all 1656 // cube faces, so this method is only well-defined for a cube-complete base level. 1657 return mImageArray[0][0]; 1658 } 1659 1660 rx::TextureStorageInterface *TextureCubeMap::getBaseLevelStorage() 1661 { 1662 return mTexStorage; 1663 } 1664 1665 FramebufferAttachment *TextureCubeMap::getAttachment(GLenum target, GLint level) 1666 { 1667 ASSERT(!IsCubemapTextureTarget(target)); 1668 int faceIndex = targetToIndex(target); 1669 1670 FramebufferAttachment *attachment = mRenderbufferProxies.get(level, faceIndex); 1671 if (!attachment) 1672 { 1673 attachment = new FramebufferAttachment(mRenderer, id(), new TextureCubeMapAttachment(this, target, level)); 1674 mRenderbufferProxies.add(level, faceIndex, attachment); 1675 } 1676 1677 return attachment; 1678 } 1679 1680 unsigned int TextureCubeMap::getRenderTargetSerial(GLenum target, GLint level) 1681 { 1682 return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(target, level) : 0); 1683 } 1684 1685 rx::RenderTarget *TextureCubeMap::getRenderTarget(GLenum target, GLint level) 1686 { 1687 ASSERT(IsCubemapTextureTarget(target)); 1688 1689 // ensure the underlying texture is created 1690 if (!ensureRenderTarget()) 1691 { 1692 return NULL; 1693 } 1694 1695 updateStorageFaceLevel(targetToIndex(target), level); 1696 1697 // ensure this is NOT a depth texture 1698 if (isDepth(target, level)) 1699 { 1700 return NULL; 1701 } 1702 1703 return mTexStorage->getRenderTarget(target, level); 1704 } 1705 1706 rx::RenderTarget *TextureCubeMap::getDepthStencil(GLenum target, GLint level) 1707 { 1708 ASSERT(IsCubemapTextureTarget(target)); 1709 1710 // ensure the underlying texture is created 1711 if (!ensureRenderTarget()) 1712 { 1713 return NULL; 1714 } 1715 1716 updateStorageFaceLevel(targetToIndex(target), level); 1717 1718 // ensure this is a depth texture 1719 if (!isDepth(target, level)) 1720 { 1721 return NULL; 1722 } 1723 1724 return mTexStorage->getRenderTarget(target, level); 1725 } 1726 1727 bool TextureCubeMap::isValidFaceLevel(int faceIndex, int level) const 1728 { 1729 return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0); 1730 } 1731 1732 Texture3D::Texture3D(rx::Renderer *renderer, GLuint id) : Texture(renderer, id, GL_TEXTURE_3D) 1733 { 1734 mTexStorage = NULL; 1735 1736 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i) 1737 { 1738 mImageArray[i] = renderer->createImage(); 1739 } 1740 } 1741 1742 Texture3D::~Texture3D() 1743 { 1744 delete mTexStorage; 1745 mTexStorage = NULL; 1746 1747 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i) 1748 { 1749 delete mImageArray[i]; 1750 } 1751 } 1752 1753 GLsizei Texture3D::getWidth(GLint level) const 1754 { 1755 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mImageArray[level]->getWidth() : 0; 1756 } 1757 1758 GLsizei Texture3D::getHeight(GLint level) const 1759 { 1760 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mImageArray[level]->getHeight() : 0; 1761 } 1762 1763 GLsizei Texture3D::getDepth(GLint level) const 1764 { 1765 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mImageArray[level]->getDepth() : 0; 1766 } 1767 1768 GLenum Texture3D::getInternalFormat(GLint level) const 1769 { 1770 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mImageArray[level]->getInternalFormat() : GL_NONE; 1771 } 1772 1773 GLenum Texture3D::getActualFormat(GLint level) const 1774 { 1775 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mImageArray[level]->getActualFormat() : GL_NONE; 1776 } 1777 1778 bool Texture3D::isCompressed(GLint level) const 1779 { 1780 return IsFormatCompressed(getInternalFormat(level), mRenderer->getCurrentClientVersion()); 1781 } 1782 1783 bool Texture3D::isDepth(GLint level) const 1784 { 1785 return GetDepthBits(getInternalFormat(level), mRenderer->getCurrentClientVersion()) > 0; 1786 } 1787 1788 void Texture3D::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1789 { 1790 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 1791 GLenum sizedInternalFormat = IsSizedInternalFormat(internalFormat, clientVersion) ? internalFormat 1792 : GetSizedInternalFormat(format, type, clientVersion); 1793 redefineImage(level, sizedInternalFormat, width, height, depth); 1794 1795 bool fastUnpacked = false; 1796 1797 // Attempt a fast gpu copy of the pixel data to the surface if the app bound an unpack buffer 1798 if (isFastUnpackable(unpack, sizedInternalFormat)) 1799 { 1800 // Will try to create RT storage if it does not exist 1801 rx::RenderTarget *destRenderTarget = getRenderTarget(level); 1802 Box destArea(0, 0, 0, getWidth(level), getHeight(level), getDepth(level)); 1803 1804 if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type, destRenderTarget)) 1805 { 1806 // Ensure we don't overwrite our newly initialized data 1807 mImageArray[level]->markClean(); 1808 1809 fastUnpacked = true; 1810 } 1811 } 1812 1813 if (!fastUnpacked) 1814 { 1815 Texture::setImage(unpack, type, pixels, mImageArray[level]); 1816 } 1817 } 1818 1819 void Texture3D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) 1820 { 1821 // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly 1822 redefineImage(level, format, width, height, depth); 1823 1824 Texture::setCompressedImage(imageSize, pixels, mImageArray[level]); 1825 } 1826 1827 void Texture3D::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 1828 { 1829 bool fastUnpacked = false; 1830 1831 // Attempt a fast gpu copy of the pixel data to the surface if the app bound an unpack buffer 1832 if (isFastUnpackable(unpack, getInternalFormat(level))) 1833 { 1834 rx::RenderTarget *destRenderTarget = getRenderTarget(level); 1835 Box destArea(xoffset, yoffset, zoffset, width, height, depth); 1836 1837 if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, getInternalFormat(level), type, destRenderTarget)) 1838 { 1839 // Ensure we don't overwrite our newly initialized data 1840 mImageArray[level]->markClean(); 1841 1842 fastUnpacked = true; 1843 } 1844 } 1845 1846 if (!fastUnpacked && Texture::subImage(xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels, mImageArray[level])) 1847 { 1848 commitRect(level, xoffset, yoffset, zoffset, width, height, depth); 1849 } 1850 } 1851 1852 void Texture3D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) 1853 { 1854 if (Texture::subImageCompressed(xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels, mImageArray[level])) 1855 { 1856 commitRect(level, xoffset, yoffset, zoffset, width, height, depth); 1857 } 1858 } 1859 1860 void Texture3D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) 1861 { 1862 for (int level = 0; level < levels; level++) 1863 { 1864 GLsizei levelWidth = std::max(1, width >> level); 1865 GLsizei levelHeight = std::max(1, height >> level); 1866 GLsizei levelDepth = std::max(1, depth >> level); 1867 mImageArray[level]->redefine(mRenderer, GL_TEXTURE_3D, internalformat, levelWidth, levelHeight, levelDepth, true); 1868 } 1869 1870 for (int level = levels; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) 1871 { 1872 mImageArray[level]->redefine(mRenderer, GL_TEXTURE_3D, GL_NONE, 0, 0, 0, true); 1873 } 1874 1875 mImmutable = true; 1876 1877 setCompleteTexStorage(new rx::TextureStorageInterface3D(mRenderer, internalformat, IsRenderTargetUsage(mUsage), width, height, depth, levels)); 1878 } 1879 1880 void Texture3D::generateMipmaps() 1881 { 1882 // Purge array levels 1 through q and reset them to represent the generated mipmap levels. 1883 int levelCount = mipLevels(); 1884 for (int level = 1; level < levelCount; level++) 1885 { 1886 redefineImage(level, getBaseLevelInternalFormat(), 1887 std::max(getBaseLevelWidth() >> level, 1), 1888 std::max(getBaseLevelHeight() >> level, 1), 1889 std::max(getBaseLevelDepth() >> level, 1)); 1890 } 1891 1892 if (mTexStorage && mTexStorage->isRenderTarget()) 1893 { 1894 for (int level = 1; level < levelCount; level++) 1895 { 1896 mTexStorage->generateMipmap(level); 1897 1898 mImageArray[level]->markClean(); 1899 } 1900 } 1901 else 1902 { 1903 for (int level = 1; level < levelCount; level++) 1904 { 1905 mRenderer->generateMipmap(mImageArray[level], mImageArray[level - 1]); 1906 } 1907 } 1908 } 1909 1910 const rx::Image *Texture3D::getBaseLevelImage() const 1911 { 1912 return mImageArray[0]; 1913 } 1914 1915 rx::TextureStorageInterface *Texture3D::getBaseLevelStorage() 1916 { 1917 return mTexStorage; 1918 } 1919 1920 void Texture3D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) 1921 { 1922 // can only make our texture storage to a render target if level 0 is defined (with a width & height) and 1923 // the current level we're copying to is defined (with appropriate format, width & height) 1924 bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0); 1925 1926 if (!mImageArray[level]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget)) 1927 { 1928 mImageArray[level]->copy(xoffset, yoffset, zoffset, x, y, width, height, source); 1929 mDirtyImages = true; 1930 } 1931 else 1932 { 1933 ensureRenderTarget(); 1934 1935 if (isValidLevel(level)) 1936 { 1937 updateStorageLevel(level); 1938 1939 gl::Rectangle sourceRect; 1940 sourceRect.x = x; 1941 sourceRect.width = width; 1942 sourceRect.y = y; 1943 sourceRect.height = height; 1944 1945 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 1946 1947 mRenderer->copyImage(source, sourceRect, 1948 gl::GetFormat(getBaseLevelInternalFormat(), clientVersion), 1949 xoffset, yoffset, zoffset, mTexStorage, level); 1950 } 1951 } 1952 } 1953 1954 bool Texture3D::isSamplerComplete(const SamplerState &samplerState) const 1955 { 1956 GLsizei width = getBaseLevelWidth(); 1957 GLsizei height = getBaseLevelHeight(); 1958 GLsizei depth = getBaseLevelDepth(); 1959 1960 if (width <= 0 || height <= 0 || depth <= 0) 1961 { 1962 return false; 1963 } 1964 1965 if (!IsTextureFilteringSupported(getInternalFormat(0), mRenderer)) 1966 { 1967 if (samplerState.magFilter != GL_NEAREST || 1968 (samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST)) 1969 { 1970 return false; 1971 } 1972 } 1973 1974 if (IsMipmapFiltered(samplerState) && !isMipmapComplete()) 1975 { 1976 return false; 1977 } 1978 1979 return true; 1980 } 1981 1982 bool Texture3D::isMipmapComplete() const 1983 { 1984 int levelCount = mipLevels(); 1985 1986 for (int level = 0; level < levelCount; level++) 1987 { 1988 if (!isLevelComplete(level)) 1989 { 1990 return false; 1991 } 1992 } 1993 1994 return true; 1995 } 1996 1997 bool Texture3D::isLevelComplete(int level) const 1998 { 1999 ASSERT(level >= 0 && level < (int)ArraySize(mImageArray) && mImageArray[level] != NULL); 2000 2001 if (isImmutable()) 2002 { 2003 return true; 2004 } 2005 2006 GLsizei width = getBaseLevelWidth(); 2007 GLsizei height = getBaseLevelHeight(); 2008 GLsizei depth = getBaseLevelDepth(); 2009 2010 if (width <= 0 || height <= 0 || depth <= 0) 2011 { 2012 return false; 2013 } 2014 2015 if (level == 0) 2016 { 2017 return true; 2018 } 2019 2020 rx::Image *levelImage = mImageArray[level]; 2021 2022 if (levelImage->getInternalFormat() != getBaseLevelInternalFormat()) 2023 { 2024 return false; 2025 } 2026 2027 if (levelImage->getWidth() != std::max(1, width >> level)) 2028 { 2029 return false; 2030 } 2031 2032 if (levelImage->getHeight() != std::max(1, height >> level)) 2033 { 2034 return false; 2035 } 2036 2037 if (levelImage->getDepth() != std::max(1, depth >> level)) 2038 { 2039 return false; 2040 } 2041 2042 return true; 2043 } 2044 2045 FramebufferAttachment *Texture3D::getAttachment(GLint level, GLint layer) 2046 { 2047 FramebufferAttachment *attachment = mRenderbufferProxies.get(level, layer); 2048 if (!attachment) 2049 { 2050 attachment = new FramebufferAttachment(mRenderer, id(), new Texture3DAttachment(this, level, layer)); 2051 mRenderbufferProxies.add(level, 0, attachment); 2052 } 2053 2054 return attachment; 2055 } 2056 2057 unsigned int Texture3D::getRenderTargetSerial(GLint level, GLint layer) 2058 { 2059 return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level, layer) : 0); 2060 } 2061 2062 bool Texture3D::isValidLevel(int level) const 2063 { 2064 return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0); 2065 } 2066 2067 void Texture3D::initializeStorage(bool renderTarget) 2068 { 2069 // Only initialize the first time this texture is used as a render target or shader resource 2070 if (mTexStorage) 2071 { 2072 return; 2073 } 2074 2075 // do not attempt to create storage for nonexistant data 2076 if (!isLevelComplete(0)) 2077 { 2078 return; 2079 } 2080 2081 bool createRenderTarget = (renderTarget || mUsage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE); 2082 2083 setCompleteTexStorage(createCompleteStorage(createRenderTarget)); 2084 ASSERT(mTexStorage); 2085 2086 // flush image data to the storage 2087 updateStorage(); 2088 } 2089 2090 rx::TextureStorageInterface3D *Texture3D::createCompleteStorage(bool renderTarget) const 2091 { 2092 GLsizei width = getBaseLevelWidth(); 2093 GLsizei height = getBaseLevelHeight(); 2094 GLsizei depth = getBaseLevelDepth(); 2095 2096 ASSERT(width > 0 && height > 0 && depth > 0); 2097 2098 // use existing storage level count, when previously specified by TexStorage*D 2099 GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, depth)); 2100 2101 return new rx::TextureStorageInterface3D(mRenderer, getBaseLevelInternalFormat(), renderTarget, width, height, depth, levels); 2102 } 2103 2104 void Texture3D::setCompleteTexStorage(rx::TextureStorageInterface3D *newCompleteTexStorage) 2105 { 2106 SafeDelete(mTexStorage); 2107 mTexStorage = newCompleteTexStorage; 2108 mDirtyImages = true; 2109 2110 // We do not support managed 3D storage, as that is D3D9/ES2-only 2111 ASSERT(!mTexStorage->isManaged()); 2112 } 2113 2114 void Texture3D::updateStorage() 2115 { 2116 ASSERT(mTexStorage != NULL); 2117 GLint storageLevels = mTexStorage->getLevelCount(); 2118 for (int level = 0; level < storageLevels; level++) 2119 { 2120 if (mImageArray[level]->isDirty() && isLevelComplete(level)) 2121 { 2122 updateStorageLevel(level); 2123 } 2124 } 2125 } 2126 2127 void Texture3D::updateStorageLevel(int level) 2128 { 2129 ASSERT(level >= 0 && level < (int)ArraySize(mImageArray) && mImageArray[level] != NULL); 2130 ASSERT(isLevelComplete(level)); 2131 2132 if (mImageArray[level]->isDirty()) 2133 { 2134 commitRect(level, 0, 0, 0, getWidth(level), getHeight(level), getDepth(level)); 2135 } 2136 } 2137 2138 bool Texture3D::ensureRenderTarget() 2139 { 2140 initializeStorage(true); 2141 2142 if (getBaseLevelWidth() > 0 && getBaseLevelHeight() > 0 && getBaseLevelDepth() > 0) 2143 { 2144 ASSERT(mTexStorage); 2145 if (!mTexStorage->isRenderTarget()) 2146 { 2147 rx::TextureStorageInterface3D *newRenderTargetStorage = createCompleteStorage(true); 2148 2149 if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage)) 2150 { 2151 delete newRenderTargetStorage; 2152 return gl::error(GL_OUT_OF_MEMORY, false); 2153 } 2154 2155 setCompleteTexStorage(newRenderTargetStorage); 2156 } 2157 } 2158 2159 return (mTexStorage && mTexStorage->isRenderTarget()); 2160 } 2161 2162 rx::RenderTarget *Texture3D::getRenderTarget(GLint level) 2163 { 2164 // ensure the underlying texture is created 2165 if (!ensureRenderTarget()) 2166 { 2167 return NULL; 2168 } 2169 2170 updateStorageLevel(level); 2171 2172 // ensure this is NOT a depth texture 2173 if (isDepth(level)) 2174 { 2175 return NULL; 2176 } 2177 2178 return mTexStorage->getRenderTarget(level); 2179 } 2180 2181 rx::RenderTarget *Texture3D::getRenderTarget(GLint level, GLint layer) 2182 { 2183 // ensure the underlying texture is created 2184 if (!ensureRenderTarget()) 2185 { 2186 return NULL; 2187 } 2188 2189 updateStorage(); 2190 2191 // ensure this is NOT a depth texture 2192 if (isDepth(level)) 2193 { 2194 return NULL; 2195 } 2196 2197 return mTexStorage->getRenderTarget(level, layer); 2198 } 2199 2200 rx::RenderTarget *Texture3D::getDepthStencil(GLint level, GLint layer) 2201 { 2202 // ensure the underlying texture is created 2203 if (!ensureRenderTarget()) 2204 { 2205 return NULL; 2206 } 2207 2208 updateStorageLevel(level); 2209 2210 // ensure this is a depth texture 2211 if (!isDepth(level)) 2212 { 2213 return NULL; 2214 } 2215 2216 return mTexStorage->getRenderTarget(level, layer); 2217 } 2218 2219 void Texture3D::redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) 2220 { 2221 // If there currently is a corresponding storage texture image, it has these parameters 2222 const int storageWidth = std::max(1, getBaseLevelWidth() >> level); 2223 const int storageHeight = std::max(1, getBaseLevelHeight() >> level); 2224 const int storageDepth = std::max(1, getBaseLevelDepth() >> level); 2225 const GLenum storageFormat = getBaseLevelInternalFormat(); 2226 2227 mImageArray[level]->redefine(mRenderer, GL_TEXTURE_3D, internalformat, width, height, depth, false); 2228 2229 if (mTexStorage) 2230 { 2231 const int storageLevels = mTexStorage->getLevelCount(); 2232 2233 if ((level >= storageLevels && storageLevels != 0) || 2234 width != storageWidth || 2235 height != storageHeight || 2236 depth != storageDepth || 2237 internalformat != storageFormat) // Discard mismatched storage 2238 { 2239 for (int i = 0; i < IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++) 2240 { 2241 mImageArray[i]->markDirty(); 2242 } 2243 2244 delete mTexStorage; 2245 mTexStorage = NULL; 2246 mDirtyImages = true; 2247 } 2248 } 2249 } 2250 2251 void Texture3D::commitRect(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) 2252 { 2253 if (isValidLevel(level)) 2254 { 2255 rx::Image *image = mImageArray[level]; 2256 if (image->copyToStorage(mTexStorage, level, xoffset, yoffset, zoffset, width, height, depth)) 2257 { 2258 image->markClean(); 2259 } 2260 } 2261 } 2262 2263 Texture2DArray::Texture2DArray(rx::Renderer *renderer, GLuint id) : Texture(renderer, id, GL_TEXTURE_2D_ARRAY) 2264 { 2265 mTexStorage = NULL; 2266 2267 for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level) 2268 { 2269 mLayerCounts[level] = 0; 2270 mImageArray[level] = NULL; 2271 } 2272 } 2273 2274 Texture2DArray::~Texture2DArray() 2275 { 2276 delete mTexStorage; 2277 mTexStorage = NULL; 2278 2279 deleteImages(); 2280 } 2281 2282 void Texture2DArray::deleteImages() 2283 { 2284 for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level) 2285 { 2286 for (int layer = 0; layer < mLayerCounts[level]; ++layer) 2287 { 2288 delete mImageArray[level][layer]; 2289 } 2290 delete[] mImageArray[level]; 2291 mImageArray[level] = NULL; 2292 mLayerCounts[level] = 0; 2293 } 2294 } 2295 2296 GLsizei Texture2DArray::getWidth(GLint level) const 2297 { 2298 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getWidth() : 0; 2299 } 2300 2301 GLsizei Texture2DArray::getHeight(GLint level) const 2302 { 2303 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getHeight() : 0; 2304 } 2305 2306 GLsizei Texture2DArray::getLayers(GLint level) const 2307 { 2308 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mLayerCounts[level] : 0; 2309 } 2310 2311 GLenum Texture2DArray::getInternalFormat(GLint level) const 2312 { 2313 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getInternalFormat() : GL_NONE; 2314 } 2315 2316 GLenum Texture2DArray::getActualFormat(GLint level) const 2317 { 2318 return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getActualFormat() : GL_NONE; 2319 } 2320 2321 bool Texture2DArray::isCompressed(GLint level) const 2322 { 2323 return IsFormatCompressed(getInternalFormat(level), mRenderer->getCurrentClientVersion()); 2324 } 2325 2326 bool Texture2DArray::isDepth(GLint level) const 2327 { 2328 return GetDepthBits(getInternalFormat(level), mRenderer->getCurrentClientVersion()) > 0; 2329 } 2330 2331 void Texture2DArray::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 2332 { 2333 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 2334 GLenum sizedInternalFormat = IsSizedInternalFormat(internalFormat, clientVersion) ? internalFormat 2335 : GetSizedInternalFormat(format, type, clientVersion); 2336 redefineImage(level, sizedInternalFormat, width, height, depth); 2337 2338 GLsizei inputDepthPitch = gl::GetDepthPitch(sizedInternalFormat, type, clientVersion, width, height, unpack.alignment); 2339 2340 for (int i = 0; i < depth; i++) 2341 { 2342 const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL; 2343 Texture::setImage(unpack, type, layerPixels, mImageArray[level][i]); 2344 } 2345 } 2346 2347 void Texture2DArray::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) 2348 { 2349 // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly 2350 redefineImage(level, format, width, height, depth); 2351 2352 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 2353 GLsizei inputDepthPitch = gl::GetDepthPitch(format, GL_UNSIGNED_BYTE, clientVersion, width, height, 1); 2354 2355 for (int i = 0; i < depth; i++) 2356 { 2357 const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL; 2358 Texture::setCompressedImage(imageSize, layerPixels, mImageArray[level][i]); 2359 } 2360 } 2361 2362 void Texture2DArray::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels) 2363 { 2364 GLenum internalformat = getInternalFormat(level); 2365 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 2366 GLsizei inputDepthPitch = gl::GetDepthPitch(internalformat, type, clientVersion, width, height, unpack.alignment); 2367 2368 for (int i = 0; i < depth; i++) 2369 { 2370 int layer = zoffset + i; 2371 const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL; 2372 2373 if (Texture::subImage(xoffset, yoffset, zoffset, width, height, 1, format, type, unpack, layerPixels, mImageArray[level][layer])) 2374 { 2375 commitRect(level, xoffset, yoffset, layer, width, height); 2376 } 2377 } 2378 } 2379 2380 void Texture2DArray::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) 2381 { 2382 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 2383 GLsizei inputDepthPitch = gl::GetDepthPitch(format, GL_UNSIGNED_BYTE, clientVersion, width, height, 1); 2384 2385 for (int i = 0; i < depth; i++) 2386 { 2387 int layer = zoffset + i; 2388 const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL; 2389 2390 if (Texture::subImageCompressed(xoffset, yoffset, zoffset, width, height, 1, format, imageSize, layerPixels, mImageArray[level][layer])) 2391 { 2392 commitRect(level, xoffset, yoffset, layer, width, height); 2393 } 2394 } 2395 } 2396 2397 void Texture2DArray::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) 2398 { 2399 deleteImages(); 2400 2401 for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) 2402 { 2403 GLsizei levelWidth = std::max(1, width >> level); 2404 GLsizei levelHeight = std::max(1, height >> level); 2405 2406 mLayerCounts[level] = (level < levels ? depth : 0); 2407 2408 if (mLayerCounts[level] > 0) 2409 { 2410 // Create new images for this level 2411 mImageArray[level] = new rx::Image*[mLayerCounts[level]]; 2412 2413 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2414 { 2415 mImageArray[level][layer] = mRenderer->createImage(); 2416 mImageArray[level][layer]->redefine(mRenderer, GL_TEXTURE_2D_ARRAY, internalformat, levelWidth, 2417 levelHeight, 1, true); 2418 } 2419 } 2420 } 2421 2422 mImmutable = true; 2423 setCompleteTexStorage(new rx::TextureStorageInterface2DArray(mRenderer, internalformat, IsRenderTargetUsage(mUsage), width, height, depth, levels)); 2424 } 2425 2426 void Texture2DArray::generateMipmaps() 2427 { 2428 int baseWidth = getBaseLevelWidth(); 2429 int baseHeight = getBaseLevelHeight(); 2430 int baseDepth = getBaseLevelDepth(); 2431 GLenum baseFormat = getBaseLevelInternalFormat(); 2432 2433 // Purge array levels 1 through q and reset them to represent the generated mipmap levels. 2434 int levelCount = mipLevels(); 2435 for (int level = 1; level < levelCount; level++) 2436 { 2437 redefineImage(level, baseFormat, std::max(baseWidth >> level, 1), std::max(baseHeight >> level, 1), baseDepth); 2438 } 2439 2440 if (mTexStorage && mTexStorage->isRenderTarget()) 2441 { 2442 for (int level = 1; level < levelCount; level++) 2443 { 2444 mTexStorage->generateMipmap(level); 2445 2446 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2447 { 2448 mImageArray[level][layer]->markClean(); 2449 } 2450 } 2451 } 2452 else 2453 { 2454 for (int level = 1; level < levelCount; level++) 2455 { 2456 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2457 { 2458 mRenderer->generateMipmap(mImageArray[level][layer], mImageArray[level - 1][layer]); 2459 } 2460 } 2461 } 2462 } 2463 2464 const rx::Image *Texture2DArray::getBaseLevelImage() const 2465 { 2466 return (mLayerCounts[0] > 0 ? mImageArray[0][0] : NULL); 2467 } 2468 2469 rx::TextureStorageInterface *Texture2DArray::getBaseLevelStorage() 2470 { 2471 return mTexStorage; 2472 } 2473 2474 void Texture2DArray::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) 2475 { 2476 // can only make our texture storage to a render target if level 0 is defined (with a width & height) and 2477 // the current level we're copying to is defined (with appropriate format, width & height) 2478 bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0); 2479 2480 if (!mImageArray[level][0]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget)) 2481 { 2482 mImageArray[level][zoffset]->copy(xoffset, yoffset, 0, x, y, width, height, source); 2483 mDirtyImages = true; 2484 } 2485 else 2486 { 2487 ensureRenderTarget(); 2488 2489 if (isValidLevel(level)) 2490 { 2491 updateStorageLevel(level); 2492 2493 GLuint clientVersion = mRenderer->getCurrentClientVersion(); 2494 2495 gl::Rectangle sourceRect; 2496 sourceRect.x = x; 2497 sourceRect.width = width; 2498 sourceRect.y = y; 2499 sourceRect.height = height; 2500 2501 mRenderer->copyImage(source, sourceRect, gl::GetFormat(getInternalFormat(0), clientVersion), 2502 xoffset, yoffset, zoffset, mTexStorage, level); 2503 } 2504 } 2505 } 2506 2507 bool Texture2DArray::isSamplerComplete(const SamplerState &samplerState) const 2508 { 2509 GLsizei width = getBaseLevelWidth(); 2510 GLsizei height = getBaseLevelHeight(); 2511 GLsizei depth = getLayers(0); 2512 2513 if (width <= 0 || height <= 0 || depth <= 0) 2514 { 2515 return false; 2516 } 2517 2518 if (!IsTextureFilteringSupported(getBaseLevelInternalFormat(), mRenderer)) 2519 { 2520 if (samplerState.magFilter != GL_NEAREST || 2521 (samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST)) 2522 { 2523 return false; 2524 } 2525 } 2526 2527 if (IsMipmapFiltered(samplerState) && !isMipmapComplete()) 2528 { 2529 return false; 2530 } 2531 2532 return true; 2533 } 2534 2535 bool Texture2DArray::isMipmapComplete() const 2536 { 2537 int levelCount = mipLevels(); 2538 2539 for (int level = 1; level < levelCount; level++) 2540 { 2541 if (!isLevelComplete(level)) 2542 { 2543 return false; 2544 } 2545 } 2546 2547 return true; 2548 } 2549 2550 bool Texture2DArray::isLevelComplete(int level) const 2551 { 2552 ASSERT(level >= 0 && level < (int)ArraySize(mImageArray)); 2553 2554 if (isImmutable()) 2555 { 2556 return true; 2557 } 2558 2559 GLsizei width = getBaseLevelWidth(); 2560 GLsizei height = getBaseLevelHeight(); 2561 GLsizei layers = getLayers(0); 2562 2563 if (width <= 0 || height <= 0 || layers <= 0) 2564 { 2565 return false; 2566 } 2567 2568 if (level == 0) 2569 { 2570 return true; 2571 } 2572 2573 if (getInternalFormat(level) != getInternalFormat(0)) 2574 { 2575 return false; 2576 } 2577 2578 if (getWidth(level) != std::max(1, width >> level)) 2579 { 2580 return false; 2581 } 2582 2583 if (getHeight(level) != std::max(1, height >> level)) 2584 { 2585 return false; 2586 } 2587 2588 if (getLayers(level) != layers) 2589 { 2590 return false; 2591 } 2592 2593 return true; 2594 } 2595 2596 FramebufferAttachment *Texture2DArray::getAttachment(GLint level, GLint layer) 2597 { 2598 FramebufferAttachment *attachment = mRenderbufferProxies.get(level, layer); 2599 if (!attachment) 2600 { 2601 attachment = new FramebufferAttachment(mRenderer, id(), new Texture2DArrayAttachment(this, level, layer)); 2602 mRenderbufferProxies.add(level, 0, attachment); 2603 } 2604 2605 return attachment; 2606 } 2607 2608 unsigned int Texture2DArray::getRenderTargetSerial(GLint level, GLint layer) 2609 { 2610 return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level, layer) : 0); 2611 } 2612 2613 bool Texture2DArray::isValidLevel(int level) const 2614 { 2615 return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0); 2616 } 2617 2618 void Texture2DArray::initializeStorage(bool renderTarget) 2619 { 2620 // Only initialize the first time this texture is used as a render target or shader resource 2621 if (mTexStorage) 2622 { 2623 return; 2624 } 2625 2626 // do not attempt to create storage for nonexistant data 2627 if (!isLevelComplete(0)) 2628 { 2629 return; 2630 } 2631 2632 bool createRenderTarget = (renderTarget || mUsage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE); 2633 2634 setCompleteTexStorage(createCompleteStorage(createRenderTarget)); 2635 ASSERT(mTexStorage); 2636 2637 // flush image data to the storage 2638 updateStorage(); 2639 } 2640 2641 rx::TextureStorageInterface2DArray *Texture2DArray::createCompleteStorage(bool renderTarget) const 2642 { 2643 GLsizei width = getBaseLevelWidth(); 2644 GLsizei height = getBaseLevelHeight(); 2645 GLsizei depth = getLayers(0); 2646 2647 ASSERT(width > 0 && height > 0 && depth > 0); 2648 2649 // use existing storage level count, when previously specified by TexStorage*D 2650 GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1)); 2651 2652 return new rx::TextureStorageInterface2DArray(mRenderer, getBaseLevelInternalFormat(), renderTarget, width, height, depth, levels); 2653 } 2654 2655 void Texture2DArray::setCompleteTexStorage(rx::TextureStorageInterface2DArray *newCompleteTexStorage) 2656 { 2657 SafeDelete(mTexStorage); 2658 mTexStorage = newCompleteTexStorage; 2659 mDirtyImages = true; 2660 2661 // We do not support managed 2D array storage, as managed storage is ES2/D3D9 only 2662 ASSERT(!mTexStorage->isManaged()); 2663 } 2664 2665 void Texture2DArray::updateStorage() 2666 { 2667 ASSERT(mTexStorage != NULL); 2668 GLint storageLevels = mTexStorage->getLevelCount(); 2669 for (int level = 0; level < storageLevels; level++) 2670 { 2671 if (isLevelComplete(level)) 2672 { 2673 updateStorageLevel(level); 2674 } 2675 } 2676 } 2677 2678 void Texture2DArray::updateStorageLevel(int level) 2679 { 2680 ASSERT(level >= 0 && level < (int)ArraySize(mLayerCounts)); 2681 ASSERT(isLevelComplete(level)); 2682 2683 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2684 { 2685 ASSERT(mImageArray[level] != NULL && mImageArray[level][layer] != NULL); 2686 if (mImageArray[level][layer]->isDirty()) 2687 { 2688 commitRect(level, 0, 0, layer, getWidth(level), getHeight(level)); 2689 } 2690 } 2691 } 2692 2693 bool Texture2DArray::ensureRenderTarget() 2694 { 2695 initializeStorage(true); 2696 2697 if (getBaseLevelWidth() > 0 && getBaseLevelHeight() > 0 && getLayers(0) > 0) 2698 { 2699 ASSERT(mTexStorage); 2700 if (!mTexStorage->isRenderTarget()) 2701 { 2702 rx::TextureStorageInterface2DArray *newRenderTargetStorage = createCompleteStorage(true); 2703 2704 if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage)) 2705 { 2706 delete newRenderTargetStorage; 2707 return gl::error(GL_OUT_OF_MEMORY, false); 2708 } 2709 2710 setCompleteTexStorage(newRenderTargetStorage); 2711 } 2712 } 2713 2714 return (mTexStorage && mTexStorage->isRenderTarget()); 2715 } 2716 2717 rx::RenderTarget *Texture2DArray::getRenderTarget(GLint level, GLint layer) 2718 { 2719 // ensure the underlying texture is created 2720 if (!ensureRenderTarget()) 2721 { 2722 return NULL; 2723 } 2724 2725 updateStorageLevel(level); 2726 2727 // ensure this is NOT a depth texture 2728 if (isDepth(level)) 2729 { 2730 return NULL; 2731 } 2732 2733 return mTexStorage->getRenderTarget(level, layer); 2734 } 2735 2736 rx::RenderTarget *Texture2DArray::getDepthStencil(GLint level, GLint layer) 2737 { 2738 // ensure the underlying texture is created 2739 if (!ensureRenderTarget()) 2740 { 2741 return NULL; 2742 } 2743 2744 updateStorageLevel(level); 2745 2746 // ensure this is a depth texture 2747 if (!isDepth(level)) 2748 { 2749 return NULL; 2750 } 2751 2752 return mTexStorage->getRenderTarget(level, layer); 2753 } 2754 2755 void Texture2DArray::redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) 2756 { 2757 // If there currently is a corresponding storage texture image, it has these parameters 2758 const int storageWidth = std::max(1, getBaseLevelWidth() >> level); 2759 const int storageHeight = std::max(1, getBaseLevelHeight() >> level); 2760 const int storageDepth = getLayers(0); 2761 const GLenum storageFormat = getBaseLevelInternalFormat(); 2762 2763 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2764 { 2765 delete mImageArray[level][layer]; 2766 } 2767 delete[] mImageArray[level]; 2768 mImageArray[level] = NULL; 2769 mLayerCounts[level] = depth; 2770 2771 if (depth > 0) 2772 { 2773 mImageArray[level] = new rx::Image*[depth](); 2774 2775 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2776 { 2777 mImageArray[level][layer] = mRenderer->createImage(); 2778 mImageArray[level][layer]->redefine(mRenderer, GL_TEXTURE_2D_ARRAY, internalformat, width, height, 1, false); 2779 } 2780 } 2781 2782 if (mTexStorage) 2783 { 2784 const int storageLevels = mTexStorage->getLevelCount(); 2785 2786 if ((level >= storageLevels && storageLevels != 0) || 2787 width != storageWidth || 2788 height != storageHeight || 2789 depth != storageDepth || 2790 internalformat != storageFormat) // Discard mismatched storage 2791 { 2792 for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++) 2793 { 2794 for (int layer = 0; layer < mLayerCounts[level]; layer++) 2795 { 2796 mImageArray[level][layer]->markDirty(); 2797 } 2798 } 2799 2800 delete mTexStorage; 2801 mTexStorage = NULL; 2802 mDirtyImages = true; 2803 } 2804 } 2805 } 2806 2807 void Texture2DArray::commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height) 2808 { 2809 if (isValidLevel(level) && layerTarget < getLayers(level)) 2810 { 2811 rx::Image *image = mImageArray[level][layerTarget]; 2812 if (image->copyToStorage(mTexStorage, level, xoffset, yoffset, layerTarget, width, height)) 2813 { 2814 image->markClean(); 2815 } 2816 } 2817 } 2818 2819 } 2820
