Skip to content

A
angle
Commit 142ec426 by Brandon Jones
Options

Refactored Texture2DArray, separated out D3D logic

BUG=angle:688 Change-Id: Ie3e5ac2bedcffb816ef1537575f09afb3f5e7a35 Reviewed-on: https://chromium-review.googlesource.com/208381Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Tested-by: 's avatarBrandon Jones <bajones@chromium.org>
parent 2f5469c2
Showing with 744 additions and 696 deletions
src/libGLESv2/Context.cpp
......@@ -69,7 +69,7 @@ Context::Context(int clientVersion, const gl::Context *shareContext, rx::Rendere
mTexture2DZero.set(new Texture2D(mRenderer->createTexture2D(), 0));
mTextureCubeMapZero.set(new TextureCubeMap(mRenderer->createTextureCube(), 0));
mTexture3DZero.set(new Texture3D(mRenderer->createTexture3D(), 0));
mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0));
mTexture2DArrayZero.set(new Texture2DArray(mRenderer->createTexture2DArray(), 0));
bindVertexArray(0);
bindArrayBuffer(0);
......@@ -2176,7 +2176,7 @@ Texture *Context::getIncompleteTexture(TextureType type)
case TEXTURE_2D_ARRAY:
{
Texture2DArray *incomplete2darray = new Texture2DArray(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
Texture2DArray *incomplete2darray = new Texture2DArray(mRenderer->createTexture2DArray(), Texture::INCOMPLETE_TEXTURE_ID);
incomplete2darray->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
t = incomplete2darray;
......
src/libGLESv2/ResourceManager.cpp
......@@ -389,7 +389,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
}
else if (type == TEXTURE_2D_ARRAY)
{
textureObject = new Texture2DArray(mRenderer, texture);
textureObject = new Texture2DArray(mRenderer->createTexture2DArray(), texture);
}
else
{
......
src/libGLESv2/Texture.cpp
......@@ -17,40 +17,14 @@
#include "libGLESv2/formatutils.h"
#include "libGLESv2/Renderbuffer.h"
#include "libGLESv2/renderer/Image.h"
#include "libGLESv2/renderer/Renderer.h"
#include "libGLESv2/renderer/d3d/ImageD3D.h"
#include "libGLESv2/renderer/d3d/TextureStorage.h"
#include "libEGL/Surface.h"
#include "libGLESv2/Buffer.h"
#include "libGLESv2/renderer/BufferImpl.h"
#include "libGLESv2/renderer/RenderTarget.h"
#include "libGLESv2/renderer/TextureImpl.h"
namespace gl
{
bool IsMipmapFiltered(const SamplerState &samplerState)
{
switch (samplerState.minFilter)
{
case GL_NEAREST:
case GL_LINEAR:
return false;
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
return true;
default: UNREACHABLE();
return false;
}
}
bool IsRenderTargetUsage(GLenum usage)
{
return (usage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
}
Texture::Texture(GLuint id, GLenum target)
: RefCountObject(id),
mUsage(GL_NONE),
......@@ -136,157 +110,6 @@ int Texture::mipLevels() const
return log2(std::max(std::max(getBaseLevelWidth(), getBaseLevelHeight()), getBaseLevelDepth())) + 1;
}
TextureWithRenderer::TextureWithRenderer(rx::Renderer *renderer, GLuint id, GLenum target)
: Texture(id, target),
mRenderer(renderer),
mDirtyImages(true)
{
}
TextureWithRenderer::~TextureWithRenderer()
{
}
// TODO: This is only used by the D3D backends and FramebufferAttachment. Once
// FramebufferAttachment has been refactored this function should be pushed
// down to TextureD3D.
rx::TextureStorageInterface *TextureWithRenderer::getNativeTexture()
{
// ensure the underlying texture is created
initializeStorage(false);
rx::TextureStorageInterface *storage = getBaseLevelStorage();
if (storage)
{
updateStorage();
}
return storage;
}
bool TextureWithRenderer::hasDirtyImages() const
{
return mDirtyImages;
}
void TextureWithRenderer::resetDirty()
{
mDirtyImages = false;
}
void TextureWithRenderer::setImage(const PixelUnpackState &unpack, GLenum type, const void *pixels, rx::Image *image)
{
// No-op
if (image->getWidth() == 0 || image->getHeight() == 0 || image->getDepth() == 0)
{
return;
}
// We no longer need the "GLenum format" parameter to TexImage to determine what data format "pixels" contains.
// From our image internal format we know how many channels to expect, and "type" gives the format of pixel's components.
const void *pixelData = pixels;
if (unpack.pixelBuffer.id() != 0)
{
// Do a CPU readback here, if we have an unpack buffer bound and the fast GPU path is not supported
Buffer *pixelBuffer = unpack.pixelBuffer.get();
ptrdiff_t offset = reinterpret_cast<ptrdiff_t>(pixels);
// TODO: setImage/subImage is the only place outside of renderer that asks for a buffers raw data.
// This functionality should be moved into renderer and the getData method of BufferImpl removed.
const void *bufferData = pixelBuffer->getImplementation()->getData();
pixelData = static_cast<const unsigned char *>(bufferData) + offset;
}
if (pixelData != NULL)
{
image->loadData(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth(), unpack.alignment, type, pixelData);
mDirtyImages = true;
}
}
bool TextureWithRenderer::isFastUnpackable(const PixelUnpackState &unpack, GLenum sizedInternalFormat)
{
return unpack.pixelBuffer.id() != 0 && mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat);
}
bool TextureWithRenderer::fastUnpackPixels(const PixelUnpackState &unpack, const void *pixels, const Box &destArea,
GLenum sizedInternalFormat, GLenum type, rx::RenderTarget *destRenderTarget)
{
if (destArea.width <= 0 && destArea.height <= 0 && destArea.depth <= 0)
{
return true;
}
// In order to perform the fast copy through the shader, we must have the right format, and be able
// to create a render target.
ASSERT(mRenderer->supportsFastCopyBufferToTexture(sizedInternalFormat));
unsigned int offset = reinterpret_cast<unsigned int>(pixels);
return mRenderer->fastCopyBufferToTexture(unpack, offset, destRenderTarget, sizedInternalFormat, type, destArea);
}
void TextureWithRenderer::setCompressedImage(GLsizei imageSize, const void *pixels, rx::Image *image)
{
if (pixels != NULL)
{
image->loadCompressedData(0, 0, 0, image->getWidth(), image->getHeight(), image->getDepth(), pixels);
mDirtyImages = true;
}
}
bool TextureWithRenderer::subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels, rx::Image *image)
{
const void *pixelData = pixels;
// CPU readback & copy where direct GPU copy is not supported
if (unpack.pixelBuffer.id() != 0)
{
Buffer *pixelBuffer = unpack.pixelBuffer.get();
unsigned int offset = reinterpret_cast<unsigned int>(pixels);
// TODO: setImage/subImage is the only place outside of renderer that asks for a buffers raw data.
// This functionality should be moved into renderer and the getData method of BufferImpl removed.
const void *bufferData = pixelBuffer->getImplementation()->getData();
pixelData = static_cast<const unsigned char *>(bufferData) + offset;
}
if (pixelData != NULL)
{
image->loadData(xoffset, yoffset, zoffset, width, height, depth, unpack.alignment, type, pixelData);
mDirtyImages = true;
}
return true;
}
bool TextureWithRenderer::subImageCompressed(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLsizei imageSize, const void *pixels, rx::Image *image)
{
if (pixels != NULL)
{
image->loadCompressedData(xoffset, yoffset, zoffset, width, height, depth, pixels);
mDirtyImages = true;
}
return true;
}
GLint TextureWithRenderer::creationLevels(GLsizei width, GLsizei height, GLsizei depth) const
{
// TODO(geofflang): use context's extensions
if ((isPow2(width) && isPow2(height) && isPow2(depth)) || mRenderer->getRendererExtensions().textureNPOT)
{
// Maximum number of levels
return log2(std::max(std::max(width, height), depth)) + 1;
}
else
{
// OpenGL ES 2.0 without GL_OES_texture_npot does not permit NPOT mipmaps.
return 1;
}
}
Texture2D::Texture2D(rx::Texture2DImpl *impl, GLuint id)
: Texture(id, GL_TEXTURE_2D),
mTexture(impl)
......@@ -798,63 +621,61 @@ rx::RenderTarget *Texture3D::getDepthStencil(GLint level, GLint layer)
return mTexture->getDepthStencil(level, layer);
}
Texture2DArray::Texture2DArray(rx::Renderer *renderer, GLuint id)
: TextureWithRenderer(renderer, id, GL_TEXTURE_2D_ARRAY)
Texture2DArray::Texture2DArray(rx::Texture2DArrayImpl *impl, GLuint id)
: Texture(id, GL_TEXTURE_2D_ARRAY),
mTexture(impl)
{
mTexStorage = NULL;
for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level)
{
mLayerCounts[level] = 0;
mImageArray[level] = NULL;
}
}
Texture2DArray::~Texture2DArray()
{
delete mTexStorage;
mTexStorage = NULL;
SafeDelete(mTexture);
}
deleteImages();
rx::TextureStorageInterface *Texture2DArray::getNativeTexture()
{
return mTexture->getNativeTexture();
}
void Texture2DArray::deleteImages()
void Texture2DArray::setUsage(GLenum usage)
{
for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level)
{
for (int layer = 0; layer < mLayerCounts[level]; ++layer)
{
delete mImageArray[level][layer];
}
delete[] mImageArray[level];
mImageArray[level] = NULL;
mLayerCounts[level] = 0;
}
mUsage = usage;
mTexture->setUsage(usage);
}
bool Texture2DArray::hasDirtyImages() const
{
return mTexture->hasDirtyImages();
}
void Texture2DArray::resetDirty()
{
mTexture->resetDirty();
}
GLsizei Texture2DArray::getWidth(GLint level) const
{
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getWidth() : 0;
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mTexture->getLayerCount(level) > 0) ? mTexture->getImage(level, 0)->getWidth() : 0;
}
GLsizei Texture2DArray::getHeight(GLint level) const
{
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getHeight() : 0;
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mTexture->getLayerCount(level) > 0) ? mTexture->getImage(level, 0)->getHeight() : 0;
}
GLsizei Texture2DArray::getLayers(GLint level) const
{
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mLayerCounts[level] : 0;
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getLayerCount(level) : 0;
}
GLenum Texture2DArray::getInternalFormat(GLint level) const
{
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getInternalFormat() : GL_NONE;
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mTexture->getLayerCount(level) > 0) ? mTexture->getImage(level, 0)->getInternalFormat() : GL_NONE;
}
GLenum Texture2DArray::getActualFormat(GLint level) const
{
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getActualFormat() : GL_NONE;
return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mTexture->getLayerCount(level) > 0) ? mTexture->getImage(level, 0)->getActualFormat() : GL_NONE;
}
bool Texture2DArray::isCompressed(GLint level) const
......@@ -869,473 +690,69 @@ bool Texture2DArray::isDepth(GLint level) const
void Texture2DArray::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
GLenum sizedInternalFormat = IsSizedInternalFormat(internalFormat) ? internalFormat
: GetSizedInternalFormat(format, type);
redefineImage(level, sizedInternalFormat, width, height, depth);
GLsizei inputDepthPitch = gl::GetDepthPitch(sizedInternalFormat, type, width, height, unpack.alignment);
for (int i = 0; i < depth; i++)
{
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
TextureWithRenderer::setImage(unpack, type, layerPixels, mImageArray[level][i]);
}
mTexture->setImage(level, width, height, depth, internalFormat, format, type, unpack, pixels);
}
void Texture2DArray::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
{
// compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
redefineImage(level, format, width, height, depth);
GLsizei inputDepthPitch = gl::GetDepthPitch(format, GL_UNSIGNED_BYTE, width, height, 1);
for (int i = 0; i < depth; i++)
{
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
TextureWithRenderer::setCompressedImage(imageSize, layerPixels, mImageArray[level][i]);
}
mTexture->setCompressedImage(level, format, width, height, depth, imageSize, pixels);
}
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)
{
GLenum internalformat = getInternalFormat(level);
GLsizei inputDepthPitch = gl::GetDepthPitch(internalformat, type, width, height, unpack.alignment);
for (int i = 0; i < depth; i++)
{
int layer = zoffset + i;
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
if (TextureWithRenderer::subImage(xoffset, yoffset, zoffset, width, height, 1, format, type, unpack, layerPixels, mImageArray[level][layer]))
{
commitRect(level, xoffset, yoffset, layer, width, height);
}
}
mTexture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels);
}
void Texture2DArray::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
{
GLsizei inputDepthPitch = gl::GetDepthPitch(format, GL_UNSIGNED_BYTE, width, height, 1);
for (int i = 0; i < depth; i++)
{
int layer = zoffset + i;
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
if (TextureWithRenderer::subImageCompressed(xoffset, yoffset, zoffset, width, height, 1, format, imageSize, layerPixels, mImageArray[level][layer]))
{
commitRect(level, xoffset, yoffset, layer, width, height);
}
}
mTexture->subImageCompressed(level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels);
}
void Texture2DArray::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
deleteImages();
for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
GLsizei levelWidth = std::max(1, width >> level);
GLsizei levelHeight = std::max(1, height >> level);
mLayerCounts[level] = (level < levels ? depth : 0);
if (mLayerCounts[level] > 0)
{
// Create new images for this level
mImageArray[level] = new rx::Image*[mLayerCounts[level]];
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer] = mRenderer->createImage();
mImageArray[level][layer]->redefine(mRenderer, GL_TEXTURE_2D_ARRAY, internalformat, levelWidth,
levelHeight, 1, true);
}
}
}
mImmutable = true;
setCompleteTexStorage(new rx::TextureStorageInterface2DArray(mRenderer, internalformat, IsRenderTargetUsage(mUsage), width, height, depth, levels));
mTexture->storage(levels, internalformat, width, height, depth);
}
void Texture2DArray::generateMipmaps()
{
int baseWidth = getBaseLevelWidth();
int baseHeight = getBaseLevelHeight();
int baseDepth = getBaseLevelDepth();
GLenum baseFormat = getBaseLevelInternalFormat();
// Purge array levels 1 through q and reset them to represent the generated mipmap levels.
int levelCount = mipLevels();
for (int level = 1; level < levelCount; level++)
{
redefineImage(level, baseFormat, std::max(baseWidth >> level, 1), std::max(baseHeight >> level, 1), baseDepth);
}
if (mTexStorage && mTexStorage->isRenderTarget())
{
for (int level = 1; level < levelCount; level++)
{
mTexStorage->generateMipmap(level);
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer]->markClean();
}
}
}
else
{
for (int level = 1; level < levelCount; level++)
{
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mRenderer->generateMipmap(mImageArray[level][layer], mImageArray[level - 1][layer]);
}
}
}
mTexture->generateMipmaps();
}
const rx::Image *Texture2DArray::getBaseLevelImage() const
{
return (mLayerCounts[0] > 0 ? mImageArray[0][0] : NULL);
}
rx::TextureStorageInterface *Texture2DArray::getBaseLevelStorage()
{
return mTexStorage;
return (mTexture->getLayerCount(0) > 0 ? mTexture->getImage(0, 0) : NULL);
}
void Texture2DArray::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
{
// can only make our texture storage to a render target if level 0 is defined (with a width & height) and
// the current level we're copying to is defined (with appropriate format, width & height)
bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0);
if (!mImageArray[level][0]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget))
{
mImageArray[level][zoffset]->copy(xoffset, yoffset, 0, x, y, width, height, source);
mDirtyImages = true;
}
else
{
ensureRenderTarget();
if (isValidLevel(level))
{
updateStorageLevel(level);
gl::Rectangle sourceRect;
sourceRect.x = x;
sourceRect.width = width;
sourceRect.y = y;
sourceRect.height = height;
mRenderer->copyImage(source, sourceRect, gl::GetFormat(getInternalFormat(0)),
xoffset, yoffset, zoffset, mTexStorage, level);
}
}
mTexture->copySubImage(target, level, xoffset, yoffset, zoffset, x, y, width, height, source);
}
bool Texture2DArray::isSamplerComplete(const SamplerState &samplerState) const
{
GLsizei width = getBaseLevelWidth();
GLsizei height = getBaseLevelHeight();
GLsizei depth = getLayers(0);
if (width <= 0 || height <= 0 || depth <= 0)
{
return false;
}
// TODO(geofflang): use context's texture caps
if (!mRenderer->getRendererTextureCaps().get(getBaseLevelInternalFormat()).filterable)
{
if (samplerState.magFilter != GL_NEAREST ||
(samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST))
{
return false;
}
}
if (IsMipmapFiltered(samplerState) && !isMipmapComplete())
{
return false;
}
return true;
return mTexture->isSamplerComplete(samplerState);
}
bool Texture2DArray::isMipmapComplete() const
{
int levelCount = mipLevels();
for (int level = 1; level < levelCount; level++)
{
if (!isLevelComplete(level))
{
return false;
}
}
return true;
}
bool Texture2DArray::isLevelComplete(int level) const
{
ASSERT(level >= 0 && level < (int)ArraySize(mImageArray));
if (isImmutable())
{
return true;
}
GLsizei width = getBaseLevelWidth();
GLsizei height = getBaseLevelHeight();
GLsizei layers = getLayers(0);
if (width <= 0 || height <= 0 || layers <= 0)
{
return false;
}
if (level == 0)
{
return true;
}
if (getInternalFormat(level) != getInternalFormat(0))
{
return false;
}
if (getWidth(level) != std::max(1, width >> level))
{
return false;
}
if (getHeight(level) != std::max(1, height >> level))
{
return false;
}
if (getLayers(level) != layers)
{
return false;
}
return true;
return mTexture->isMipmapComplete();
}
unsigned int Texture2DArray::getRenderTargetSerial(GLint level, GLint layer)
{
return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level, layer) : 0);
}
bool Texture2DArray::isValidLevel(int level) const
{
return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0);
}
void Texture2DArray::initializeStorage(bool renderTarget)
{
// Only initialize the first time this texture is used as a render target or shader resource
if (mTexStorage)
{
return;
}
// do not attempt to create storage for nonexistant data
if (!isLevelComplete(0))
{
return;
}
bool createRenderTarget = (renderTarget || mUsage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
setCompleteTexStorage(createCompleteStorage(createRenderTarget));
ASSERT(mTexStorage);
// flush image data to the storage
updateStorage();
}
rx::TextureStorageInterface2DArray *Texture2DArray::createCompleteStorage(bool renderTarget) const
{
GLsizei width = getBaseLevelWidth();
GLsizei height = getBaseLevelHeight();
GLsizei depth = getLayers(0);
ASSERT(width > 0 && height > 0 && depth > 0);
// use existing storage level count, when previously specified by TexStorage*D
GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1));
return new rx::TextureStorageInterface2DArray(mRenderer, getBaseLevelInternalFormat(), renderTarget, width, height, depth, levels);
}
void Texture2DArray::setCompleteTexStorage(rx::TextureStorageInterface2DArray *newCompleteTexStorage)
{
SafeDelete(mTexStorage);
mTexStorage = newCompleteTexStorage;
mDirtyImages = true;
// We do not support managed 2D array storage, as managed storage is ES2/D3D9 only
ASSERT(!mTexStorage->isManaged());
}
void Texture2DArray::updateStorage()
{
ASSERT(mTexStorage != NULL);
GLint storageLevels = mTexStorage->getLevelCount();
for (int level = 0; level < storageLevels; level++)
{
if (isLevelComplete(level))
{
updateStorageLevel(level);
}
}
}
void Texture2DArray::updateStorageLevel(int level)
{
ASSERT(level >= 0 && level < (int)ArraySize(mLayerCounts));
ASSERT(isLevelComplete(level));
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
ASSERT(mImageArray[level] != NULL && mImageArray[level][layer] != NULL);
if (mImageArray[level][layer]->isDirty())
{
commitRect(level, 0, 0, layer, getWidth(level), getHeight(level));
}
}
}
bool Texture2DArray::ensureRenderTarget()
{
initializeStorage(true);
if (getBaseLevelWidth() > 0 && getBaseLevelHeight() > 0 && getLayers(0) > 0)
{
ASSERT(mTexStorage);
if (!mTexStorage->isRenderTarget())
{
rx::TextureStorageInterface2DArray *newRenderTargetStorage = createCompleteStorage(true);
if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage))
{
delete newRenderTargetStorage;
return gl::error(GL_OUT_OF_MEMORY, false);
}
setCompleteTexStorage(newRenderTargetStorage);
}
}
return (mTexStorage && mTexStorage->isRenderTarget());
return mTexture->getRenderTargetSerial(level, layer);
}
rx::RenderTarget *Texture2DArray::getRenderTarget(GLint level, GLint layer)
{
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageLevel(level);
// ensure this is NOT a depth texture
if (isDepth(level))
{
return NULL;
}
return mTexStorage->getRenderTarget(level, layer);
return mTexture->getRenderTarget(level, layer);
}
rx::RenderTarget *Texture2DArray::getDepthStencil(GLint level, GLint layer)
{
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageLevel(level);
// ensure this is a depth texture
if (!isDepth(level))
{
return NULL;
}
return mTexStorage->getRenderTarget(level, layer);
}
void Texture2DArray::redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
// If there currently is a corresponding storage texture image, it has these parameters
const int storageWidth = std::max(1, getBaseLevelWidth() >> level);
const int storageHeight = std::max(1, getBaseLevelHeight() >> level);
const int storageDepth = getLayers(0);
const GLenum storageFormat = getBaseLevelInternalFormat();
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
delete mImageArray[level][layer];
}
delete[] mImageArray[level];
mImageArray[level] = NULL;
mLayerCounts[level] = depth;
if (depth > 0)
{
mImageArray[level] = new rx::Image*[depth]();
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer] = mRenderer->createImage();
mImageArray[level][layer]->redefine(mRenderer, GL_TEXTURE_2D_ARRAY, internalformat, width, height, 1, false);
}
}
if (mTexStorage)
{
const int storageLevels = mTexStorage->getLevelCount();
if ((level >= storageLevels && storageLevels != 0) ||
width != storageWidth ||
height != storageHeight ||
depth != storageDepth ||
internalformat != storageFormat) // Discard mismatched storage
{
for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer]->markDirty();
}
}
delete mTexStorage;
mTexStorage = NULL;
mDirtyImages = true;
}
}
}
void Texture2DArray::commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height)
{
if (isValidLevel(level) && layerTarget < getLayers(level))
{
rx::ImageD3D *image = rx::ImageD3D::makeImageD3D(mImageArray[level][layerTarget]);
if (image->copyToStorage(mTexStorage, level, xoffset, yoffset, layerTarget, width, height))
{
image->markClean();
}
}
return mTexture->getDepthStencil(level, layer);
}
}
src/libGLESv2/Texture.h
......@@ -27,13 +27,11 @@ class Surface;
namespace rx
{
class Renderer;
class Texture2DImpl;
class TextureCubeImpl;
class Texture3DImpl;
class Texture2DArrayImpl;
class TextureStorageInterface;
class TextureStorageInterface3D;
class TextureStorageInterface2DArray;
class RenderTarget;
class Image;
}
......@@ -43,8 +41,6 @@ namespace gl
class Framebuffer;
class FramebufferAttachment;
bool IsMipmapFiltered(const SamplerState &samplerState);
class Texture : public RefCountObject
{
public:
......@@ -98,44 +94,6 @@ class Texture : public RefCountObject
virtual const rx::Image *getBaseLevelImage() const = 0;
};
// TODO: This class is only here to make incremental Texture refactoring easier
class TextureWithRenderer : public Texture
{
public:
TextureWithRenderer(rx::Renderer *renderer, GLuint id, GLenum target);
virtual ~TextureWithRenderer();
virtual rx::TextureStorageInterface *getNativeTexture();
virtual bool hasDirtyImages() const;
virtual void resetDirty();
protected:
void setImage(const PixelUnpackState &unpack, GLenum type, const void *pixels, rx::Image *image);
bool subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels, rx::Image *image);
void setCompressedImage(GLsizei imageSize, const void *pixels, rx::Image *image);
bool subImageCompressed(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLenum format, GLsizei imageSize, const void *pixels, rx::Image *image);
bool isFastUnpackable(const PixelUnpackState &unpack, GLenum sizedInternalFormat);
bool fastUnpackPixels(const PixelUnpackState &unpack, const void *pixels, const Box &destArea,
GLenum sizedInternalFormat, GLenum type, rx::RenderTarget *destRenderTarget);
GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const;
virtual void initializeStorage(bool renderTarget) = 0;
virtual void updateStorage() = 0;
virtual bool ensureRenderTarget() = 0;
rx::Renderer *mRenderer;
bool mDirtyImages;
private:
DISALLOW_COPY_AND_ASSIGN(TextureWithRenderer);
virtual rx::TextureStorageInterface *getBaseLevelStorage() = 0;
};
class Texture2D : public Texture
{
public:
......@@ -289,13 +247,18 @@ class Texture3D : public Texture
rx::Texture3DImpl *mTexture;
};
class Texture2DArray : public TextureWithRenderer
class Texture2DArray : public Texture
{
public:
Texture2DArray(rx::Renderer *renderer, GLuint id);
Texture2DArray(rx::Texture2DArrayImpl *impl, GLuint id);
~Texture2DArray();
virtual rx::TextureStorageInterface *getNativeTexture();
virtual void setUsage(GLenum usage);
virtual bool hasDirtyImages() const;
virtual void resetDirty();
GLsizei getWidth(GLint level) const;
GLsizei getHeight(GLint level) const;
GLsizei getLayers(GLint level) const;
......@@ -326,32 +289,9 @@ class Texture2DArray : public TextureWithRenderer
private:
DISALLOW_COPY_AND_ASSIGN(Texture2DArray);
virtual void initializeStorage(bool renderTarget);
rx::TextureStorageInterface2DArray *createCompleteStorage(bool renderTarget) const;
void setCompleteTexStorage(rx::TextureStorageInterface2DArray *newCompleteTexStorage);
virtual void updateStorage();
virtual bool ensureRenderTarget();
virtual rx::TextureStorageInterface *getBaseLevelStorage();
virtual const rx::Image *getBaseLevelImage() const;
void deleteImages();
void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
void commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height);
bool isValidLevel(int level) const;
bool isLevelComplete(int level) const;
void updateStorageLevel(int level);
// Storing images as an array of single depth textures since D3D11 treats each array level of a
// Texture2D object as a separate subresource. Each layer would have to be looped over
// to update all the texture layers since they cannot all be updated at once and it makes the most
// sense for the Image class to not have to worry about layer subresource as well as mip subresources.
GLsizei mLayerCounts[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
rx::Image **mImageArray[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
rx::TextureStorageInterface2DArray *mTexStorage;
rx::Texture2DArrayImpl *mTexture;
};
}
......
src/libGLESv2/renderer/Renderer.h
......@@ -60,6 +60,7 @@ class UniformStorage;
class Texture2DImpl;
class TextureCubeImpl;
class Texture3DImpl;
class Texture2DArrayImpl;
struct ConfigDesc
{
......@@ -232,6 +233,7 @@ class Renderer
virtual Texture2DImpl *createTexture2D() = 0;
virtual TextureCubeImpl *createTextureCube() = 0;
virtual Texture3DImpl *createTexture3D() = 0;
virtual Texture2DArrayImpl *createTexture2DArray() = 0;
// Buffer creation
virtual BufferImpl *createBuffer() = 0;
......
src/libGLESv2/renderer/TextureImpl.h
......@@ -130,6 +130,37 @@ class Texture3DImpl
virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
};
class Texture2DArrayImpl
{
public:
virtual ~Texture2DArrayImpl() {}
virtual TextureStorageInterface *getNativeTexture() = 0;
virtual Image *getImage(int level, int layer) const = 0;
virtual GLsizei getLayerCount(int level) const = 0;
virtual void setUsage(GLenum usage) = 0;
virtual bool hasDirtyImages() const = 0;
virtual void resetDirty() = 0;
virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const = 0;
virtual bool isMipmapComplete() const = 0;
virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) = 0;
virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) = 0;
virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 0;
virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = 0;
virtual void generateMipmaps() = 0;
virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) = 0;
virtual RenderTarget *getRenderTarget(GLint level, GLint layer) = 0;
virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
};
}
#endif // LIBGLESV2_RENDERER_TEXTUREIMPL_H_
src/libGLESv2/renderer/d3d/TextureD3D.cpp
......@@ -1974,4 +1974,577 @@ void TextureD3D_3D::commitRect(GLint level, GLint xoffset, GLint yoffset, GLint
}
}
TextureD3D_2DArray::TextureD3D_2DArray(Renderer *renderer)
: Texture2DArrayImpl(),
TextureD3D(renderer),
mTexStorage(NULL)
{
for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level)
{
mLayerCounts[level] = 0;
mImageArray[level] = NULL;
}
}
TextureD3D_2DArray::~TextureD3D_2DArray()
{
SafeDelete(mTexStorage);
deleteImages();
}
TextureD3D_2DArray *TextureD3D_2DArray::makeTextureD3D_2DArray(Texture2DArrayImpl *texture)
{
ASSERT(HAS_DYNAMIC_TYPE(TextureD3D_2DArray*, texture));
return static_cast<TextureD3D_2DArray*>(texture);
}
TextureStorageInterface *TextureD3D_2DArray::getNativeTexture()
{
// ensure the underlying texture is created
initializeStorage(false);
TextureStorageInterface *storage = getBaseLevelStorage();
if (storage)
{
updateStorage();
}
return storage;
}
Image *TextureD3D_2DArray::getImage(int level, int layer) const
{
ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
ASSERT(layer < mLayerCounts[level]);
return mImageArray[level][layer];
}
GLsizei TextureD3D_2DArray::getLayerCount(int level) const
{
ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
return mLayerCounts[level];
}
void TextureD3D_2DArray::setUsage(GLenum usage)
{
mUsage = usage;
}
void TextureD3D_2DArray::resetDirty()
{
mDirtyImages = false;
}
GLsizei TextureD3D_2DArray::getWidth(GLint level) const
{
return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getWidth() : 0;
}
GLsizei TextureD3D_2DArray::getHeight(GLint level) const
{
return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getHeight() : 0;
}
GLsizei TextureD3D_2DArray::getLayers(GLint level) const
{
return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mLayerCounts[level] : 0;
}
GLenum TextureD3D_2DArray::getInternalFormat(GLint level) const
{
return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getInternalFormat() : GL_NONE;
}
bool TextureD3D_2DArray::isDepth(GLint level) const
{
return gl::GetDepthBits(getInternalFormat(level)) > 0;
}
void TextureD3D_2DArray::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
{
GLenum sizedInternalFormat = gl::IsSizedInternalFormat(internalFormat) ? internalFormat
: gl::GetSizedInternalFormat(format, type);
redefineImage(level, sizedInternalFormat, width, height, depth);
GLsizei inputDepthPitch = gl::GetDepthPitch(sizedInternalFormat, type, width, height, unpack.alignment);
for (int i = 0; i < depth; i++)
{
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
TextureD3D::setImage(unpack, type, layerPixels, mImageArray[level][i]);
}
}
void TextureD3D_2DArray::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
{
// compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
redefineImage(level, format, width, height, depth);
GLsizei inputDepthPitch = gl::GetDepthPitch(format, GL_UNSIGNED_BYTE, width, height, 1);
for (int i = 0; i < depth; i++)
{
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
TextureD3D::setCompressedImage(imageSize, layerPixels, mImageArray[level][i]);
}
}
void TextureD3D_2DArray::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
{
GLenum internalformat = getInternalFormat(level);
GLsizei inputDepthPitch = gl::GetDepthPitch(internalformat, type, width, height, unpack.alignment);
for (int i = 0; i < depth; i++)
{
int layer = zoffset + i;
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
if (TextureD3D::subImage(xoffset, yoffset, zoffset, width, height, 1, format, type, unpack, layerPixels, mImageArray[level][layer]))
{
commitRect(level, xoffset, yoffset, layer, width, height);
}
}
}
void TextureD3D_2DArray::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
{
GLsizei inputDepthPitch = gl::GetDepthPitch(format, GL_UNSIGNED_BYTE, width, height, 1);
for (int i = 0; i < depth; i++)
{
int layer = zoffset + i;
const void *layerPixels = pixels ? (reinterpret_cast<const unsigned char*>(pixels) + (inputDepthPitch * i)) : NULL;
if (TextureD3D::subImageCompressed(xoffset, yoffset, zoffset, width, height, 1, format, imageSize, layerPixels, mImageArray[level][layer]))
{
commitRect(level, xoffset, yoffset, layer, width, height);
}
}
}
void TextureD3D_2DArray::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
{
// can only make our texture storage to a render target if level 0 is defined (with a width & height) and
// the current level we're copying to is defined (with appropriate format, width & height)
bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0);
if (!mImageArray[level][0]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget))
{
mImageArray[level][zoffset]->copy(xoffset, yoffset, 0, x, y, width, height, source);
mDirtyImages = true;
}
else
{
ensureRenderTarget();
if (isValidLevel(level))
{
updateStorageLevel(level);
gl::Rectangle sourceRect;
sourceRect.x = x;
sourceRect.width = width;
sourceRect.y = y;
sourceRect.height = height;
mRenderer->copyImage(source, sourceRect, gl::GetFormat(getInternalFormat(0)),
xoffset, yoffset, zoffset, mTexStorage, level);
}
}
}
void TextureD3D_2DArray::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
deleteImages();
for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
GLsizei levelWidth = std::max(1, width >> level);
GLsizei levelHeight = std::max(1, height >> level);
mLayerCounts[level] = (level < levels ? depth : 0);
if (mLayerCounts[level] > 0)
{
// Create new images for this level
mImageArray[level] = new ImageD3D*[mLayerCounts[level]];
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer] = ImageD3D::makeImageD3D(mRenderer->createImage());
mImageArray[level][layer]->redefine(mRenderer, GL_TEXTURE_2D_ARRAY, internalformat, levelWidth,
levelHeight, 1, true);
}
}
}
mImmutable = true;
setCompleteTexStorage(new TextureStorageInterface2DArray(mRenderer, internalformat, IsRenderTargetUsage(mUsage), width, height, depth, levels));
}
bool TextureD3D_2DArray::isSamplerComplete(const gl::SamplerState &samplerState) const
{
GLsizei width = getBaseLevelWidth();
GLsizei height = getBaseLevelHeight();
GLsizei depth = getLayers(0);
if (width <= 0 || height <= 0 || depth <= 0)
{
return false;
}
// TODO(geofflang): use context's texture caps
if (!mRenderer->getRendererTextureCaps().get(getBaseLevelInternalFormat()).filterable)
{
if (samplerState.magFilter != GL_NEAREST ||
(samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST))
{
return false;
}
}
if (IsMipmapFiltered(samplerState) && !isMipmapComplete())
{
return false;
}
return true;
}
bool TextureD3D_2DArray::isMipmapComplete() const
{
int levelCount = mipLevels();
for (int level = 1; level < levelCount; level++)
{
if (!isLevelComplete(level))
{
return false;
}
}
return true;
}
void TextureD3D_2DArray::generateMipmaps()
{
int baseWidth = getBaseLevelWidth();
int baseHeight = getBaseLevelHeight();
int baseDepth = getBaseLevelDepth();
GLenum baseFormat = getBaseLevelInternalFormat();
// Purge array levels 1 through q and reset them to represent the generated mipmap levels.
int levelCount = mipLevels();
for (int level = 1; level < levelCount; level++)
{
redefineImage(level, baseFormat, std::max(baseWidth >> level, 1), std::max(baseHeight >> level, 1), baseDepth);
}
if (mTexStorage && mTexStorage->isRenderTarget())
{
for (int level = 1; level < levelCount; level++)
{
mTexStorage->generateMipmap(level);
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer]->markClean();
}
}
}
else
{
for (int level = 1; level < levelCount; level++)
{
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mRenderer->generateMipmap(mImageArray[level][layer], mImageArray[level - 1][layer]);
}
}
}
}
unsigned int TextureD3D_2DArray::getRenderTargetSerial(GLint level, GLint layer)
{
return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level, layer) : 0);
}
RenderTarget *TextureD3D_2DArray::getRenderTarget(GLint level, GLint layer)
{
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageLevel(level);
// ensure this is NOT a depth texture
if (isDepth(level))
{
return NULL;
}
return mTexStorage->getRenderTarget(level, layer);
}
RenderTarget *TextureD3D_2DArray::getDepthStencil(GLint level, GLint layer)
{
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageLevel(level);
// ensure this is a depth texture
if (!isDepth(level))
{
return NULL;
}
return mTexStorage->getRenderTarget(level, layer);
}
void TextureD3D_2DArray::initializeStorage(bool renderTarget)
{
// Only initialize the first time this texture is used as a render target or shader resource
if (mTexStorage)
{
return;
}
// do not attempt to create storage for nonexistant data
if (!isLevelComplete(0))
{
return;
}
bool createRenderTarget = (renderTarget || mUsage == GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
setCompleteTexStorage(createCompleteStorage(createRenderTarget));
ASSERT(mTexStorage);
// flush image data to the storage
updateStorage();
}
TextureStorageInterface2DArray *TextureD3D_2DArray::createCompleteStorage(bool renderTarget) const
{
GLsizei width = getBaseLevelWidth();
GLsizei height = getBaseLevelHeight();
GLsizei depth = getLayers(0);
ASSERT(width > 0 && height > 0 && depth > 0);
// use existing storage level count, when previously specified by TexStorage*D
GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(width, height, 1));
return new TextureStorageInterface2DArray(mRenderer, getBaseLevelInternalFormat(), renderTarget, width, height, depth, levels);
}
void TextureD3D_2DArray::setCompleteTexStorage(TextureStorageInterface2DArray *newCompleteTexStorage)
{
SafeDelete(mTexStorage);
mTexStorage = newCompleteTexStorage;
mDirtyImages = true;
// We do not support managed 2D array storage, as managed storage is ES2/D3D9 only
ASSERT(!mTexStorage->isManaged());
}
void TextureD3D_2DArray::updateStorage()
{
ASSERT(mTexStorage != NULL);
GLint storageLevels = mTexStorage->getLevelCount();
for (int level = 0; level < storageLevels; level++)
{
if (isLevelComplete(level))
{
updateStorageLevel(level);
}
}
}
bool TextureD3D_2DArray::ensureRenderTarget()
{
initializeStorage(true);
if (getBaseLevelWidth() > 0 && getBaseLevelHeight() > 0 && getLayers(0) > 0)
{
ASSERT(mTexStorage);
if (!mTexStorage->isRenderTarget())
{
TextureStorageInterface2DArray *newRenderTargetStorage = createCompleteStorage(true);
if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage))
{
delete newRenderTargetStorage;
return gl::error(GL_OUT_OF_MEMORY, false);
}
setCompleteTexStorage(newRenderTargetStorage);
}
}
return (mTexStorage && mTexStorage->isRenderTarget());
}
const ImageD3D *TextureD3D_2DArray::getBaseLevelImage() const
{
return (mLayerCounts[0] > 0 ? mImageArray[0][0] : NULL);
}
TextureStorageInterface *TextureD3D_2DArray::getBaseLevelStorage()
{
return mTexStorage;
}
bool TextureD3D_2DArray::isValidLevel(int level) const
{
return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0);
}
bool TextureD3D_2DArray::isLevelComplete(int level) const
{
ASSERT(level >= 0 && level < (int)ArraySize(mImageArray));
if (isImmutable())
{
return true;
}
GLsizei width = getBaseLevelWidth();
GLsizei height = getBaseLevelHeight();
GLsizei layers = getLayers(0);
if (width <= 0 || height <= 0 || layers <= 0)
{
return false;
}
if (level == 0)
{
return true;
}
if (getInternalFormat(level) != getInternalFormat(0))
{
return false;
}
if (getWidth(level) != std::max(1, width >> level))
{
return false;
}
if (getHeight(level) != std::max(1, height >> level))
{
return false;
}
if (getLayers(level) != layers)
{
return false;
}
return true;
}
void TextureD3D_2DArray::updateStorageLevel(int level)
{
ASSERT(level >= 0 && level < (int)ArraySize(mLayerCounts));
ASSERT(isLevelComplete(level));
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
ASSERT(mImageArray[level] != NULL && mImageArray[level][layer] != NULL);
if (mImageArray[level][layer]->isDirty())
{
commitRect(level, 0, 0, layer, getWidth(level), getHeight(level));
}
}
}
void TextureD3D_2DArray::deleteImages()
{
for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level)
{
for (int layer = 0; layer < mLayerCounts[level]; ++layer)
{
delete mImageArray[level][layer];
}
delete[] mImageArray[level];
mImageArray[level] = NULL;
mLayerCounts[level] = 0;
}
}
void TextureD3D_2DArray::redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
// If there currently is a corresponding storage texture image, it has these parameters
const int storageWidth = std::max(1, getBaseLevelWidth() >> level);
const int storageHeight = std::max(1, getBaseLevelHeight() >> level);
const int storageDepth = getLayers(0);
const GLenum storageFormat = getBaseLevelInternalFormat();
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
delete mImageArray[level][layer];
}
delete[] mImageArray[level];
mImageArray[level] = NULL;
mLayerCounts[level] = depth;
if (depth > 0)
{
mImageArray[level] = new ImageD3D*[depth]();
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer] = ImageD3D::makeImageD3D(mRenderer->createImage());
mImageArray[level][layer]->redefine(mRenderer, GL_TEXTURE_2D_ARRAY, internalformat, width, height, 1, false);
}
}
if (mTexStorage)
{
const int storageLevels = mTexStorage->getLevelCount();
if ((level >= storageLevels && storageLevels != 0) ||
width != storageWidth ||
height != storageHeight ||
depth != storageDepth ||
internalformat != storageFormat) // Discard mismatched storage
{
for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
for (int layer = 0; layer < mLayerCounts[level]; layer++)
{
mImageArray[level][layer]->markDirty();
}
}
delete mTexStorage;
mTexStorage = NULL;
mDirtyImages = true;
}
}
}
void TextureD3D_2DArray::commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height)
{
if (isValidLevel(level) && layerTarget < getLayers(level))
{
ImageD3D *image = mImageArray[level][layerTarget];
if (image->copyToStorage(mTexStorage, level, xoffset, yoffset, layerTarget, width, height))
{
image->markClean();
}
}
}
}
src/libGLESv2/renderer/d3d/TextureD3D.h
......@@ -28,6 +28,9 @@ class TextureStorageInterface;
class TextureStorageInterface2D;
class TextureStorageInterfaceCube;
class TextureStorageInterface3D;
class TextureStorageInterface2DArray;
bool IsMipmapFiltered(const gl::SamplerState &samplerState);
class TextureD3D
{
......@@ -265,6 +268,76 @@ class TextureD3D_3D : public Texture3DImpl, public TextureD3D
TextureStorageInterface3D *mTexStorage;
};
class TextureD3D_2DArray : public Texture2DArrayImpl, public TextureD3D
{
public:
TextureD3D_2DArray(Renderer *renderer);
virtual ~TextureD3D_2DArray();
static TextureD3D_2DArray *makeTextureD3D_2DArray(Texture2DArrayImpl *texture);
virtual TextureStorageInterface *getNativeTexture();
virtual Image *getImage(int level, int layer) const;
virtual GLsizei getLayerCount(int level) const;
virtual void setUsage(GLenum usage);
virtual bool hasDirtyImages() const { return mDirtyImages; }
virtual void resetDirty();
GLsizei getWidth(GLint level) const;
GLsizei getHeight(GLint level) const;
GLsizei getLayers(GLint level) const;
GLenum getInternalFormat(GLint level) const;
bool isDepth(GLint level) const;
virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
virtual bool isMipmapComplete() const;
virtual void generateMipmaps();
virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
virtual RenderTarget *getDepthStencil(GLint level, GLint layer);
private:
DISALLOW_COPY_AND_ASSIGN(TextureD3D_2DArray);
virtual void initializeStorage(bool renderTarget);
TextureStorageInterface2DArray *createCompleteStorage(bool renderTarget) const;
void setCompleteTexStorage(TextureStorageInterface2DArray *newCompleteTexStorage);
void updateStorage();
bool ensureRenderTarget();
virtual TextureStorageInterface *getBaseLevelStorage();
virtual const ImageD3D *getBaseLevelImage() const;
bool isValidLevel(int level) const;
bool isLevelComplete(int level) const;
void updateStorageLevel(int level);
void deleteImages();
void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
void commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height);
// Storing images as an array of single depth textures since D3D11 treats each array level of a
// Texture2D object as a separate subresource. Each layer would have to be looped over
// to update all the texture layers since they cannot all be updated at once and it makes the most
// sense for the Image class to not have to worry about layer subresource as well as mip subresources.
GLsizei mLayerCounts[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
ImageD3D **mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
TextureStorageInterface2DArray *mTexStorage;
};
}
#endif // LIBGLESV2_RENDERER_TEXTURED3D_H_
src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
......@@ -2925,6 +2925,11 @@ Texture3DImpl *Renderer11::createTexture3D()
return new TextureD3D_3D(this);
}
Texture2DArrayImpl *Renderer11::createTexture2DArray()
{
return new TextureD3D_2DArray(this);
}
void Renderer11::readTextureData(ID3D11Texture2D *texture, unsigned int subResource, const gl::Rectangle &area, GLenum format,
GLenum type, GLuint outputPitch, const gl::PixelPackState &pack, void *pixels)
{
......
src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
......@@ -181,6 +181,7 @@ class Renderer11 : public Renderer
virtual Texture2DImpl *createTexture2D();
virtual TextureCubeImpl *createTextureCube();
virtual Texture3DImpl *createTexture3D();
virtual Texture2DArrayImpl *createTexture2DArray();
// Buffer creation
virtual BufferImpl *createBuffer();
......
src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
......@@ -195,7 +195,7 @@ UINT TextureStorage11::getSubresourceIndex(int mipLevel, int layerTarget) const
ID3D11ShaderResourceView *TextureStorage11::getSRV(const gl::SamplerState &samplerState)
{
bool swizzleRequired = samplerState.swizzleRequired();
bool mipmapping = gl::IsMipmapFiltered(samplerState);
bool mipmapping = IsMipmapFiltered(samplerState);
unsigned int mipLevels = mipmapping ? (samplerState.maxLevel - samplerState.baseLevel) : 1;
// Make sure there's 'mipLevels' mipmap levels below the base level (offset by the top level, which corresponds to GL level 0)
......
src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
......@@ -3211,6 +3211,11 @@ Texture3DImpl *Renderer9::createTexture3D()
return new TextureD3D_3D(this);
}
Texture2DArrayImpl *Renderer9::createTexture2DArray()
{
return new TextureD3D_2DArray(this);
}
bool Renderer9::getLUID(LUID *adapterLuid) const
{
adapterLuid->HighPart = 0;
......
src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
......@@ -183,6 +183,7 @@ class Renderer9 : public Renderer
virtual Texture2DImpl *createTexture2D();
virtual TextureCubeImpl *createTextureCube();
virtual Texture3DImpl *createTexture3D();
virtual Texture2DArrayImpl *createTexture2DArray();
// Buffer creation
virtual BufferImpl *createBuffer();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment