Skip to content

A
angle
Commit 0511e808 by Brandon Jones
Options

Refactored TextureCubeMap, separated out D3D logic

BUG=angle:688 Change-Id: I2300aaad4fab25df484e0bc3613ac3b176addc93 Reviewed-on: https://chromium-review.googlesource.com/208191Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Tested-by: 's avatarBrandon Jones <bajones@chromium.org>
parent 11c26b9c
Showing with 786 additions and 530 deletions
src/libGLESv2/Context.cpp
......@@ -69,7 +69,7 @@ Context::Context(int clientVersion, const gl::Context *shareContext, rx::Rendere
// objects all of whose names are 0.
mTexture2DZero.set(new Texture2D(mRenderer->createTexture2D(), 0));
mTextureCubeMapZero.set(new TextureCubeMap(mRenderer, 0));
mTextureCubeMapZero.set(new TextureCubeMap(mRenderer->createTextureCube(), 0));
mTexture3DZero.set(new Texture3D(mRenderer, 0));
mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0));
......@@ -2159,7 +2159,7 @@ Texture *Context::getIncompleteTexture(TextureType type)
case TEXTURE_CUBE:
{
TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer->createTextureCube(), Texture::INCOMPLETE_TEXTURE_ID);
incompleteCube->setImagePosX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
incompleteCube->setImageNegX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
......
src/libGLESv2/ResourceManager.cpp
......@@ -381,7 +381,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
}
else if (type == TEXTURE_CUBE)
{
textureObject = new TextureCubeMap(mRenderer, texture);
textureObject = new TextureCubeMap(mRenderer->createTextureCube(), texture);
}
else if (type == TEXTURE_3D)
{
......
src/libGLESv2/Texture.cpp
......@@ -484,37 +484,42 @@ rx::RenderTarget *Texture2D::getDepthSencil(GLint level)
return mTexture->getDepthSencil(level);
}
TextureCubeMap::TextureCubeMap(rx::Renderer *renderer, GLuint id)
: TextureWithRenderer(renderer, id, GL_TEXTURE_CUBE_MAP)
TextureCubeMap::TextureCubeMap(rx::TextureCubeImpl *impl, GLuint id)
: Texture(id, GL_TEXTURE_CUBE_MAP),
mTexture(impl)
{
mTexStorage = NULL;
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
{
mImageArray[i][j] = renderer->createImage();
}
}
}
TextureCubeMap::~TextureCubeMap()
{
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
{
delete mImageArray[i][j];
}
}
SafeDelete(mTexture);
}
delete mTexStorage;
mTexStorage = NULL;
rx::TextureStorageInterface *TextureCubeMap::getNativeTexture()
{
return mTexture->getNativeTexture();
}
void TextureCubeMap::setUsage(GLenum usage)
{
mUsage = usage;
mTexture->setUsage(usage);
}
bool TextureCubeMap::hasDirtyImages() const
{
return mTexture->hasDirtyImages();
}
void TextureCubeMap::resetDirty()
{
mTexture->resetDirty();
}
GLsizei TextureCubeMap::getWidth(GLenum target, GLint level) const
{
if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
return mImageArray[targetToIndex(target)][level]->getWidth();
return mTexture->getImage(target, level)->getWidth();
else
return 0;
}
......@@ -522,7 +527,7 @@ GLsizei TextureCubeMap::getWidth(GLenum target, GLint level) const
GLsizei TextureCubeMap::getHeight(GLenum target, GLint level) const
{
if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
return mImageArray[targetToIndex(target)][level]->getHeight();
return mTexture->getImage(target, level)->getHeight();
else
return 0;
}
......@@ -530,7 +535,7 @@ GLsizei TextureCubeMap::getHeight(GLenum target, GLint level) const
GLenum TextureCubeMap::getInternalFormat(GLenum target, GLint level) const
{
if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
return mImageArray[targetToIndex(target)][level]->getInternalFormat();
return mTexture->getImage(target, level)->getInternalFormat();
else
return GL_NONE;
}
......@@ -538,215 +543,66 @@ GLenum TextureCubeMap::getInternalFormat(GLenum target, GLint level) const
GLenum TextureCubeMap::getActualFormat(GLenum target, GLint level) const
{
if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
return mImageArray[targetToIndex(target)][level]->getActualFormat();
return mTexture->getImage(target, level)->getActualFormat();
else
return GL_NONE;
}
void TextureCubeMap::setImagePosX(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
setImage(0, level, width, height, internalFormat, format, type, unpack, pixels);
mTexture->setImage(0, level, width, height, internalFormat, format, type, unpack, pixels);
}
void TextureCubeMap::setImageNegX(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
setImage(1, level, width, height, internalFormat, format, type, unpack, pixels);
mTexture->setImage(1, level, width, height, internalFormat, format, type, unpack, pixels);
}
void TextureCubeMap::setImagePosY(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
setImage(2, level, width, height, internalFormat, format, type, unpack, pixels);
mTexture->setImage(2, level, width, height, internalFormat, format, type, unpack, pixels);
}
void TextureCubeMap::setImageNegY(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
setImage(3, level, width, height, internalFormat, format, type, unpack, pixels);
mTexture->setImage(3, level, width, height, internalFormat, format, type, unpack, pixels);
}
void TextureCubeMap::setImagePosZ(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
setImage(4, level, width, height, internalFormat, format, type, unpack, pixels);
mTexture->setImage(4, level, width, height, internalFormat, format, type, unpack, pixels);
}
void TextureCubeMap::setImageNegZ(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
setImage(5, level, width, height, internalFormat, format, type, unpack, pixels);
mTexture->setImage(5, level, width, height, internalFormat, format, type, unpack, pixels);
}
void TextureCubeMap::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
{
// compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
int faceIndex = targetToIndex(target);
redefineImage(faceIndex, level, format, width, height);
TextureWithRenderer::setCompressedImage(imageSize, pixels, mImageArray[faceIndex][level]);
}
void TextureCubeMap::commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
{
if (isValidFaceLevel(faceIndex, level))
{
rx::ImageD3D *image = rx::ImageD3D::makeImageD3D(mImageArray[faceIndex][level]);
if (image->copyToStorage(mTexStorage, faceIndex, level, xoffset, yoffset, width, height))
image->markClean();
}
mTexture->setCompressedImage(target, level, format, width, height, imageSize, pixels);
}
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)
{
int faceIndex = targetToIndex(target);
if (TextureWithRenderer::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels, mImageArray[faceIndex][level]))
{
commitRect(faceIndex, level, xoffset, yoffset, width, height);
}
mTexture->subImage(target, level, xoffset, yoffset, width, height, format, type, unpack, pixels);
}
void TextureCubeMap::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
{
int faceIndex = targetToIndex(target);
if (TextureWithRenderer::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, mImageArray[faceIndex][level]))
{
commitRect(faceIndex, level, xoffset, yoffset, width, height);
}
mTexture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, pixels);
}
// Tests for cube map sampling completeness. [OpenGL ES 2.0.24] section 3.8.2 page 86.
bool TextureCubeMap::isSamplerComplete(const SamplerState &samplerState) const
{
int size = getBaseLevelWidth();
bool mipmapping = IsMipmapFiltered(samplerState);
// TODO(geofflang): use context's texture caps
if (!mRenderer->getRendererTextureCaps().get(getInternalFormat(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0)).filtering)
{
if (samplerState.magFilter != GL_NEAREST ||
(samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST))
{
return false;
}
}
// TODO(geofflang): use context's extensions
if (!isPow2(size) && !mRenderer->getRendererExtensions().textureNPOT)
{
if (samplerState.wrapS != GL_CLAMP_TO_EDGE || samplerState.wrapT != GL_CLAMP_TO_EDGE || mipmapping)
{
return false;
}
}
if (!mipmapping)
{
if (!isCubeComplete())
{
return false;
}
}
else
{
if (!isMipmapCubeComplete()) // Also tests for isCubeComplete()
{
return false;
}
}
return true;
return mTexture->isSamplerComplete(samplerState);
}
// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
bool TextureCubeMap::isCubeComplete() const
{
int baseWidth = getBaseLevelWidth();
int baseHeight = getBaseLevelHeight();
GLenum baseFormat = getBaseLevelInternalFormat();
if (baseWidth <= 0 || baseWidth != baseHeight)
{
return false;
}
for (int faceIndex = 1; faceIndex < 6; faceIndex++)
{
const rx::Image &faceBaseImage = *mImageArray[faceIndex][0];
if (faceBaseImage.getWidth() != baseWidth ||
faceBaseImage.getHeight() != baseHeight ||
faceBaseImage.getInternalFormat() != baseFormat )
{
return false;
}
}
return true;
}
bool TextureCubeMap::isMipmapCubeComplete() const
{
if (isImmutable())
{
return true;
}
if (!isCubeComplete())
{
return false;
}
int levelCount = mipLevels();
for (int face = 0; face < 6; face++)
{
for (int level = 1; level < levelCount; level++)
{
if (!isFaceLevelComplete(face, level))
{
return false;
}
}
}
return true;
}
bool TextureCubeMap::isFaceLevelComplete(int faceIndex, int level) const
{
ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) && mImageArray[faceIndex][level] != NULL);
if (isImmutable())
{
return true;
}
int baseSize = getBaseLevelWidth();
if (baseSize <= 0)
{
return false;
}
// "isCubeComplete" checks for base level completeness and we must call that
// to determine if any face at level 0 is complete. We omit that check here
// to avoid re-checking cube-completeness for every face at level 0.
if (level == 0)
{
return true;
}
// Check that non-zero levels are consistent with the base level.
const rx::Image *faceLevelImage = mImageArray[faceIndex][level];
if (faceLevelImage->getInternalFormat() != getBaseLevelInternalFormat())
{
return false;
}
if (faceLevelImage->getWidth() != std::max(1, baseSize >> level))
{
return false;
}
return true;
return mTexture->isCubeComplete();
}
bool TextureCubeMap::isCompressed(GLenum target, GLint level) const
......@@ -759,355 +615,48 @@ bool TextureCubeMap::isDepth(GLenum target, GLint level) const
return GetDepthBits(getInternalFormat(target, level)) > 0;
}
void TextureCubeMap::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 (!isFaceLevelComplete(0, 0))
{
return;
}
bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mUsage));
setCompleteTexStorage(createCompleteStorage(createRenderTarget));
ASSERT(mTexStorage);
// flush image data to the storage
updateStorage();
}
rx::TextureStorageInterfaceCube *TextureCubeMap::createCompleteStorage(bool renderTarget) const
{
GLsizei size = getBaseLevelWidth();
ASSERT(size > 0);
// use existing storage level count, when previously specified by TexStorage*D
GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(size, size, 1));
return new rx::TextureStorageInterfaceCube(mRenderer, getBaseLevelInternalFormat(), renderTarget, size, levels);
}
void TextureCubeMap::setCompleteTexStorage(rx::TextureStorageInterfaceCube *newCompleteTexStorage)
{
SafeDelete(mTexStorage);
mTexStorage = newCompleteTexStorage;
if (mTexStorage && mTexStorage->isManaged())
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 0; level < mTexStorage->getLevelCount(); level++)
{
rx::ImageD3D::makeImageD3D(mImageArray[faceIndex][level])->setManagedSurface(mTexStorage, faceIndex, level);
}
}
}
mDirtyImages = true;
}
void TextureCubeMap::updateStorage()
{
ASSERT(mTexStorage != NULL);
GLint storageLevels = mTexStorage->getLevelCount();
for (int face = 0; face < 6; face++)
{
for (int level = 0; level < storageLevels; level++)
{
if (mImageArray[face][level]->isDirty() && isFaceLevelComplete(face, level))
{
updateStorageFaceLevel(face, level);
}
}
}
}
void TextureCubeMap::updateStorageFaceLevel(int faceIndex, int level)
{
ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) && mImageArray[faceIndex][level] != NULL);
rx::Image *image = mImageArray[faceIndex][level];
if (image->isDirty())
{
commitRect(faceIndex, level, 0, 0, image->getWidth(), image->getHeight());
}
}
bool TextureCubeMap::ensureRenderTarget()
{
initializeStorage(true);
if (getBaseLevelWidth() > 0)
{
ASSERT(mTexStorage);
if (!mTexStorage->isRenderTarget())
{
rx::TextureStorageInterfaceCube *newRenderTargetStorage = createCompleteStorage(true);
if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage))
{
delete newRenderTargetStorage;
return gl::error(GL_OUT_OF_MEMORY, false);
}
setCompleteTexStorage(newRenderTargetStorage);
}
}
return (mTexStorage && mTexStorage->isRenderTarget());
}
void TextureCubeMap::setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
{
GLenum sizedInternalFormat = IsSizedInternalFormat(internalFormat) ? internalFormat
: GetSizedInternalFormat(format, type);
redefineImage(faceIndex, level, sizedInternalFormat, width, height);
TextureWithRenderer::setImage(unpack, type, pixels, mImageArray[faceIndex][level]);
}
int TextureCubeMap::targetToIndex(GLenum target)
{
META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 1);
META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 2);
META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 3);
META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 4);
META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 5);
return target - GL_TEXTURE_CUBE_MAP_POSITIVE_X;
}
void TextureCubeMap::redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height)
{
// 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 GLenum storageFormat = getBaseLevelInternalFormat();
mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, width, height, 1, false);
if (mTexStorage)
{
const int storageLevels = mTexStorage->getLevelCount();
if ((level >= storageLevels && storageLevels != 0) ||
width != storageWidth ||
height != storageHeight ||
internalformat != storageFormat) // Discard mismatched storage
{
for (int level = 0; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
mImageArray[faceIndex][level]->markDirty();
}
}
delete mTexStorage;
mTexStorage = NULL;
mDirtyImages = true;
}
}
}
void TextureCubeMap::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
{
int faceIndex = targetToIndex(target);
GLenum sizedInternalFormat = IsSizedInternalFormat(format) ? format
: GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
redefineImage(faceIndex, level, sizedInternalFormat, width, height);
if (!mImageArray[faceIndex][level]->isRenderableFormat())
{
mImageArray[faceIndex][level]->copy(0, 0, 0, x, y, width, height, source);
mDirtyImages = true;
}
else
{
ensureRenderTarget();
mImageArray[faceIndex][level]->markClean();
ASSERT(width == height);
if (width > 0 && isValidFaceLevel(faceIndex, level))
{
gl::Rectangle sourceRect;
sourceRect.x = x;
sourceRect.width = width;
sourceRect.y = y;
sourceRect.height = height;
mRenderer->copyImage(source, sourceRect, format, 0, 0, mTexStorage, target, level);
}
}
mTexture->copyImage(target, level, format, x, y, width, height, source);
}
void TextureCubeMap::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
{
int faceIndex = targetToIndex(target);
// We can only make our texture storage to a render target if the level we're copying *to* is complete
// and the base level is cube-complete. The base level must be cube complete (common case) because we cannot
// rely on the "getBaseLevel*" methods reliably otherwise.
bool canCreateRenderTarget = isFaceLevelComplete(faceIndex, level) && isCubeComplete();
if (!mImageArray[faceIndex][level]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget))
{
mImageArray[faceIndex][level]->copy(0, 0, 0, x, y, width, height, source);
mDirtyImages = true;
}
else
{
ensureRenderTarget();
if (isValidFaceLevel(faceIndex, level))
{
updateStorageFaceLevel(faceIndex, level);
gl::Rectangle sourceRect;
sourceRect.x = x;
sourceRect.width = width;
sourceRect.y = y;
sourceRect.height = height;
mRenderer->copyImage(source, sourceRect, gl::GetFormat(getBaseLevelInternalFormat()),
xoffset, yoffset, mTexStorage, target, level);
}
}
mTexture->copySubImage(target, level, xoffset, yoffset, zoffset, x, y, width, height, source);
}
void TextureCubeMap::storage(GLsizei levels, GLenum internalformat, GLsizei size)
{
for (int level = 0; level < levels; level++)
{
GLsizei mipSize = std::max(1, size >> level);
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, mipSize, mipSize, 1, true);
}
}
for (int level = levels; level < IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, GL_NONE, 0, 0, 0, true);
}
}
mImmutable = true;
setCompleteTexStorage(new rx::TextureStorageInterfaceCube(mRenderer, internalformat, IsRenderTargetUsage(mUsage), size, levels));
mTexture->storage(levels, internalformat, size);
}
void TextureCubeMap::generateMipmaps()
{
// Purge array levels 1 through q and reset them to represent the generated mipmap levels.
int levelCount = mipLevels();
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 1; level < levelCount; level++)
{
int faceLevelSize = (std::max(mImageArray[faceIndex][0]->getWidth() >> level, 1));
redefineImage(faceIndex, level, mImageArray[faceIndex][0]->getInternalFormat(), faceLevelSize, faceLevelSize);
}
}
if (mTexStorage && mTexStorage->isRenderTarget())
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 1; level < levelCount; level++)
{
mTexStorage->generateMipmap(faceIndex, level);
mImageArray[faceIndex][level]->markClean();
}
}
}
else
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 1; level < levelCount; level++)
{
mRenderer->generateMipmap(mImageArray[faceIndex][level], mImageArray[faceIndex][level - 1]);
}
}
}
mTexture->generateMipmaps();
}
const rx::Image *TextureCubeMap::getBaseLevelImage() const
{
// Note: if we are not cube-complete, there is no single base level image that can describe all
// cube faces, so this method is only well-defined for a cube-complete base level.
return mImageArray[0][0];
}
rx::TextureStorageInterface *TextureCubeMap::getBaseLevelStorage()
{
return mTexStorage;
return mTexture->getImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0);
}
unsigned int TextureCubeMap::getRenderTargetSerial(GLenum target, GLint level)
{
return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(target, level) : 0);
return mTexture->getRenderTargetSerial(target, level);
}
rx::RenderTarget *TextureCubeMap::getRenderTarget(GLenum target, GLint level)
{
ASSERT(IsCubemapTextureTarget(target));
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageFaceLevel(targetToIndex(target), level);
// ensure this is NOT a depth texture
if (isDepth(target, level))
{
return NULL;
}
return mTexStorage->getRenderTarget(target, level);
return mTexture->getRenderTarget(target, level);
}
rx::RenderTarget *TextureCubeMap::getDepthStencil(GLenum target, GLint level)
{
ASSERT(IsCubemapTextureTarget(target));
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageFaceLevel(targetToIndex(target), level);
// ensure this is a depth texture
if (!isDepth(target, level))
{
return NULL;
}
return mTexStorage->getRenderTarget(target, level);
}
bool TextureCubeMap::isValidFaceLevel(int faceIndex, int level) const
{
return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0);
return mTexture->getDepthStencil(target, level);
}
Texture3D::Texture3D(rx::Renderer *renderer, GLuint id)
......
src/libGLESv2/Texture.h
......@@ -29,9 +29,8 @@ namespace rx
{
class Renderer;
class Texture2DImpl;
class TextureCubeImpl;
class TextureStorageInterface;
class TextureStorageInterface2D;
class TextureStorageInterfaceCube;
class TextureStorageInterface3D;
class TextureStorageInterface2DArray;
class RenderTarget;
......@@ -187,13 +186,18 @@ class Texture2D : public Texture
egl::Surface *mSurface;
};
class TextureCubeMap : public TextureWithRenderer
class TextureCubeMap : public Texture
{
public:
TextureCubeMap(rx::Renderer *renderer, GLuint id);
TextureCubeMap(rx::TextureCubeImpl *impl, GLuint id);
~TextureCubeMap();
virtual rx::TextureStorageInterface *getNativeTexture();
virtual void setUsage(GLenum usage);
virtual bool hasDirtyImages() const;
virtual void resetDirty();
GLsizei getWidth(GLenum target, GLint level) const;
GLsizei getHeight(GLenum target, GLint level) const;
GLenum getInternalFormat(GLenum target, GLint level) const;
......@@ -223,8 +227,6 @@ class TextureCubeMap : public TextureWithRenderer
unsigned int getRenderTargetSerial(GLenum target, GLint level);
static int targetToIndex(GLenum target);
protected:
friend class TextureCubeMapAttachment;
rx::RenderTarget *getRenderTarget(GLenum target, GLint level);
......@@ -233,27 +235,9 @@ class TextureCubeMap : public TextureWithRenderer
private:
DISALLOW_COPY_AND_ASSIGN(TextureCubeMap);
virtual void initializeStorage(bool renderTarget);
rx::TextureStorageInterfaceCube *createCompleteStorage(bool renderTarget) const;
void setCompleteTexStorage(rx::TextureStorageInterfaceCube *newCompleteTexStorage);
virtual void updateStorage();
virtual bool ensureRenderTarget();
virtual rx::TextureStorageInterface *getBaseLevelStorage();
virtual const rx::Image *getBaseLevelImage() const;
bool isMipmapCubeComplete() const;
bool isValidFaceLevel(int faceIndex, int level) const;
bool isFaceLevelComplete(int faceIndex, int level) const;
void updateStorageFaceLevel(int faceIndex, int level);
void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels);
void commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
void redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height);
rx::Image *mImageArray[6][IMPLEMENTATION_MAX_TEXTURE_LEVELS];
rx::TextureStorageInterfaceCube *mTexStorage;
rx::TextureCubeImpl *mTexture;
};
class Texture3D : public TextureWithRenderer
......
src/libGLESv2/renderer/Renderer.h
......@@ -59,6 +59,7 @@ class TextureStorage;
class UniformStorage;
class Texture2DImpl;
class TextureCubeImpl;
struct ConfigDesc
{
......@@ -229,6 +230,7 @@ class Renderer
// Texture creation
virtual Texture2DImpl *createTexture2D() = 0;
virtual TextureCubeImpl *createTextureCube() = 0;
// Buffer creation
virtual BufferImpl *createBuffer() = 0;
......
src/libGLESv2/renderer/TextureImpl.h
......@@ -11,9 +11,15 @@
#include "common/angleutils.h"
namespace egl
{
class Surface;
}
namespace gl
{
class Framebuffer;
struct PixelUnpackState;
struct SamplerState;
}
......@@ -24,7 +30,6 @@ class Image;
class RenderTarget;
class Renderer;
class TextureStorageInterface;
class TextureStorageInterface2D;
class Texture2DImpl
{
......@@ -63,6 +68,37 @@ class Texture2DImpl
virtual void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height) = 0;
};
class TextureCubeImpl
{
public:
virtual ~TextureCubeImpl() {}
virtual TextureStorageInterface *getNativeTexture() = 0;
virtual Image *getImage(GLenum target, 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 isCubeComplete() const = 0;
virtual void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels) = 0;
virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) = 0;
virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 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 size) = 0;
virtual void generateMipmaps() = 0;
virtual unsigned int getRenderTargetSerial(GLenum target, GLint level) = 0;
virtual RenderTarget *getRenderTarget(GLenum target, GLint level) = 0;
virtual RenderTarget *getDepthStencil(GLenum target, GLint level) = 0;
};
}
#endif // LIBGLESV2_RENDERER_TEXTUREIMPL_H_
src/libGLESv2/renderer/d3d/TextureD3D.cpp
......@@ -8,6 +8,7 @@
// TextureD3D.cpp: Implementations of the Texture interfaces shared betweeen the D3D backends.
#include "common/mathutil.h"
#include "common/utilities.h"
#include "libEGL/Surface.h"
#include "libGLESv2/Buffer.h"
#include "libGLESv2/Framebuffer.h"
......@@ -815,4 +816,607 @@ void TextureD3D_2D::commitRect(GLint level, GLint xoffset, GLint yoffset, GLsize
}
}
TextureD3D_Cube::TextureD3D_Cube(rx::Renderer *renderer)
: TextureCubeImpl(),
TextureD3D(renderer),
mTexStorage(NULL)
{
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
{
mImageArray[i][j] = ImageD3D::makeImageD3D(renderer->createImage());
}
}
}
TextureD3D_Cube::~TextureD3D_Cube()
{
SafeDelete(mTexStorage);
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++j)
{
SafeDelete(mImageArray[i][j]);
}
}
}
TextureD3D_Cube *TextureD3D_Cube::makeTextureD3D_Cube(TextureCubeImpl *texture)
{
ASSERT(HAS_DYNAMIC_TYPE(TextureD3D_Cube*, texture));
return static_cast<TextureD3D_Cube*>(texture);
}
TextureStorageInterface *TextureD3D_Cube::getNativeTexture()
{
// ensure the underlying texture is created
initializeStorage(false);
rx::TextureStorageInterface *storage = getBaseLevelStorage();
if (storage)
{
updateStorage();
}
return storage;
}
Image *TextureD3D_Cube::getImage(GLenum target, int level) const
{
ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
return mImageArray[targetToIndex(target)][level];
}
void TextureD3D_Cube::setUsage(GLenum usage)
{
mUsage = usage;
}
void TextureD3D_Cube::resetDirty()
{
mDirtyImages = false;
}
GLenum TextureD3D_Cube::getInternalFormat(GLenum target, GLint level) const
{
if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
return mImageArray[targetToIndex(target)][level]->getInternalFormat();
else
return GL_NONE;
}
bool TextureD3D_Cube::isDepth(GLenum target, GLint level) const
{
return gl::GetDepthBits(getInternalFormat(target, level)) > 0;
}
void TextureD3D_Cube::setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
{
GLenum sizedInternalFormat = gl::IsSizedInternalFormat(internalFormat) ? internalFormat
: gl::GetSizedInternalFormat(format, type);
redefineImage(faceIndex, level, sizedInternalFormat, width, height);
TextureD3D::setImage(unpack, type, pixels, mImageArray[faceIndex][level]);
}
void TextureD3D_Cube::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
{
// compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
int faceIndex = targetToIndex(target);
redefineImage(faceIndex, level, format, width, height);
TextureD3D::setCompressedImage(imageSize, pixels, mImageArray[faceIndex][level]);
}
void TextureD3D_Cube::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
{
int faceIndex = targetToIndex(target);
if (TextureD3D::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels, mImageArray[faceIndex][level]))
{
commitRect(faceIndex, level, xoffset, yoffset, width, height);
}
}
void TextureD3D_Cube::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
{
int faceIndex = targetToIndex(target);
if (TextureD3D::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, mImageArray[faceIndex][level]))
{
commitRect(faceIndex, level, xoffset, yoffset, width, height);
}
}
void TextureD3D_Cube::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
{
int faceIndex = targetToIndex(target);
GLenum sizedInternalFormat = gl::IsSizedInternalFormat(format) ? format
: gl::GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
redefineImage(faceIndex, level, sizedInternalFormat, width, height);
if (!mImageArray[faceIndex][level]->isRenderableFormat())
{
mImageArray[faceIndex][level]->copy(0, 0, 0, x, y, width, height, source);
mDirtyImages = true;
}
else
{
ensureRenderTarget();
mImageArray[faceIndex][level]->markClean();
ASSERT(width == height);
if (width > 0 && isValidFaceLevel(faceIndex, level))
{
gl::Rectangle sourceRect;
sourceRect.x = x;
sourceRect.width = width;
sourceRect.y = y;
sourceRect.height = height;
mRenderer->copyImage(source, sourceRect, format, 0, 0, mTexStorage, target, level);
}
}
}
void TextureD3D_Cube::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
{
int faceIndex = targetToIndex(target);
// We can only make our texture storage to a render target if the level we're copying *to* is complete
// and the base level is cube-complete. The base level must be cube complete (common case) because we cannot
// rely on the "getBaseLevel*" methods reliably otherwise.
bool canCreateRenderTarget = isFaceLevelComplete(faceIndex, level) && isCubeComplete();
if (!mImageArray[faceIndex][level]->isRenderableFormat() || (!mTexStorage && !canCreateRenderTarget))
{
mImageArray[faceIndex][level]->copy(0, 0, 0, x, y, width, height, source);
mDirtyImages = true;
}
else
{
ensureRenderTarget();
if (isValidFaceLevel(faceIndex, level))
{
updateStorageFaceLevel(faceIndex, level);
gl::Rectangle sourceRect;
sourceRect.x = x;
sourceRect.width = width;
sourceRect.y = y;
sourceRect.height = height;
mRenderer->copyImage(source, sourceRect, gl::GetFormat(getBaseLevelInternalFormat()),
xoffset, yoffset, mTexStorage, target, level);
}
}
}
void TextureD3D_Cube::storage(GLsizei levels, GLenum internalformat, GLsizei size)
{
for (int level = 0; level < levels; level++)
{
GLsizei mipSize = std::max(1, size >> level);
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, mipSize, mipSize, 1, true);
}
}
for (int level = levels; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, GL_NONE, 0, 0, 0, true);
}
}
mImmutable = true;
setCompleteTexStorage(new rx::TextureStorageInterfaceCube(mRenderer, internalformat, IsRenderTargetUsage(mUsage), size, levels));
}
bool TextureD3D_Cube::isSamplerComplete(const gl::SamplerState &samplerState) const
{
int size = getBaseLevelWidth();
bool mipmapping = IsMipmapFiltered(samplerState);
// TODO(geofflang): use context's texture caps
if (!mRenderer->getRendererTextureCaps().get(getInternalFormat(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0)).filtering)
{
if (samplerState.magFilter != GL_NEAREST ||
(samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST))
{
return false;
}
}
// TODO(geofflang): use context's extensions
if (!gl::isPow2(size) && !mRenderer->getRendererExtensions().textureNPOT)
{
if (samplerState.wrapS != GL_CLAMP_TO_EDGE || samplerState.wrapT != GL_CLAMP_TO_EDGE || mipmapping)
{
return false;
}
}
if (!mipmapping)
{
if (!isCubeComplete())
{
return false;
}
}
else
{
if (!isMipmapCubeComplete()) // Also tests for isCubeComplete()
{
return false;
}
}
return true;
}
// Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
bool TextureD3D_Cube::isCubeComplete() const
{
int baseWidth = getBaseLevelWidth();
int baseHeight = getBaseLevelHeight();
GLenum baseFormat = getBaseLevelInternalFormat();
if (baseWidth <= 0 || baseWidth != baseHeight)
{
return false;
}
for (int faceIndex = 1; faceIndex < 6; faceIndex++)
{
const ImageD3D &faceBaseImage = *mImageArray[faceIndex][0];
if (faceBaseImage.getWidth() != baseWidth ||
faceBaseImage.getHeight() != baseHeight ||
faceBaseImage.getInternalFormat() != baseFormat )
{
return false;
}
}
return true;
}
void TextureD3D_Cube::generateMipmaps()
{
// Purge array levels 1 through q and reset them to represent the generated mipmap levels.
int levelCount = mipLevels();
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 1; level < levelCount; level++)
{
int faceLevelSize = (std::max(mImageArray[faceIndex][0]->getWidth() >> level, 1));
redefineImage(faceIndex, level, mImageArray[faceIndex][0]->getInternalFormat(), faceLevelSize, faceLevelSize);
}
}
if (mTexStorage && mTexStorage->isRenderTarget())
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 1; level < levelCount; level++)
{
mTexStorage->generateMipmap(faceIndex, level);
mImageArray[faceIndex][level]->markClean();
}
}
}
else
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 1; level < levelCount; level++)
{
mRenderer->generateMipmap(mImageArray[faceIndex][level], mImageArray[faceIndex][level - 1]);
}
}
}
}
unsigned int TextureD3D_Cube::getRenderTargetSerial(GLenum target, GLint level)
{
return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(target, level) : 0);
}
RenderTarget *TextureD3D_Cube::getRenderTarget(GLenum target, GLint level)
{
ASSERT(gl::IsCubemapTextureTarget(target));
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageFaceLevel(targetToIndex(target), level);
// ensure this is NOT a depth texture
if (isDepth(target, level))
{
return NULL;
}
return mTexStorage->getRenderTarget(target, level);
}
RenderTarget *TextureD3D_Cube::getDepthStencil(GLenum target, GLint level)
{
ASSERT(gl::IsCubemapTextureTarget(target));
// ensure the underlying texture is created
if (!ensureRenderTarget())
{
return NULL;
}
updateStorageFaceLevel(targetToIndex(target), level);
// ensure this is a depth texture
if (!isDepth(target, level))
{
return NULL;
}
return mTexStorage->getRenderTarget(target, level);
}
int TextureD3D_Cube::targetToIndex(GLenum target)
{
META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 1);
META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 2);
META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 3);
META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 4);
META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 5);
return target - GL_TEXTURE_CUBE_MAP_POSITIVE_X;
}
void TextureD3D_Cube::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 (!isFaceLevelComplete(0, 0))
{
return;
}
bool createRenderTarget = (renderTarget || IsRenderTargetUsage(mUsage));
setCompleteTexStorage(createCompleteStorage(createRenderTarget));
ASSERT(mTexStorage);
// flush image data to the storage
updateStorage();
}
TextureStorageInterfaceCube *TextureD3D_Cube::createCompleteStorage(bool renderTarget) const
{
GLsizei size = getBaseLevelWidth();
ASSERT(size > 0);
// use existing storage level count, when previously specified by TexStorage*D
GLint levels = (mTexStorage ? mTexStorage->getLevelCount() : creationLevels(size, size, 1));
return new TextureStorageInterfaceCube(mRenderer, getBaseLevelInternalFormat(), renderTarget, size, levels);
}
void TextureD3D_Cube::setCompleteTexStorage(TextureStorageInterfaceCube *newCompleteTexStorage)
{
SafeDelete(mTexStorage);
mTexStorage = newCompleteTexStorage;
if (mTexStorage && mTexStorage->isManaged())
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
for (int level = 0; level < mTexStorage->getLevelCount(); level++)
{
mImageArray[faceIndex][level]->setManagedSurface(mTexStorage, faceIndex, level);
}
}
}
mDirtyImages = true;
}
void TextureD3D_Cube::updateStorage()
{
ASSERT(mTexStorage != NULL);
GLint storageLevels = mTexStorage->getLevelCount();
for (int face = 0; face < 6; face++)
{
for (int level = 0; level < storageLevels; level++)
{
if (mImageArray[face][level]->isDirty() && isFaceLevelComplete(face, level))
{
updateStorageFaceLevel(face, level);
}
}
}
}
bool TextureD3D_Cube::ensureRenderTarget()
{
initializeStorage(true);
if (getBaseLevelWidth() > 0)
{
ASSERT(mTexStorage);
if (!mTexStorage->isRenderTarget())
{
TextureStorageInterfaceCube *newRenderTargetStorage = createCompleteStorage(true);
if (!mRenderer->copyToRenderTarget(newRenderTargetStorage, mTexStorage))
{
delete newRenderTargetStorage;
return gl::error(GL_OUT_OF_MEMORY, false);
}
setCompleteTexStorage(newRenderTargetStorage);
}
}
return (mTexStorage && mTexStorage->isRenderTarget());
}
TextureStorageInterface *TextureD3D_Cube::getBaseLevelStorage()
{
return mTexStorage;
}
const ImageD3D *TextureD3D_Cube::getBaseLevelImage() const
{
// Note: if we are not cube-complete, there is no single base level image that can describe all
// cube faces, so this method is only well-defined for a cube-complete base level.
return mImageArray[0][0];
}
bool TextureD3D_Cube::isMipmapCubeComplete() const
{
if (isImmutable())
{
return true;
}
if (!isCubeComplete())
{
return false;
}
int levelCount = mipLevels();
for (int face = 0; face < 6; face++)
{
for (int level = 1; level < levelCount; level++)
{
if (!isFaceLevelComplete(face, level))
{
return false;
}
}
}
return true;
}
bool TextureD3D_Cube::isValidFaceLevel(int faceIndex, int level) const
{
return (mTexStorage ? (level >= 0 && level < mTexStorage->getLevelCount()) : 0);
}
bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const
{
ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) && mImageArray[faceIndex][level] != NULL);
if (isImmutable())
{
return true;
}
int baseSize = getBaseLevelWidth();
if (baseSize <= 0)
{
return false;
}
// "isCubeComplete" checks for base level completeness and we must call that
// to determine if any face at level 0 is complete. We omit that check here
// to avoid re-checking cube-completeness for every face at level 0.
if (level == 0)
{
return true;
}
// Check that non-zero levels are consistent with the base level.
const ImageD3D *faceLevelImage = mImageArray[faceIndex][level];
if (faceLevelImage->getInternalFormat() != getBaseLevelInternalFormat())
{
return false;
}
if (faceLevelImage->getWidth() != std::max(1, baseSize >> level))
{
return false;
}
return true;
}
void TextureD3D_Cube::updateStorageFaceLevel(int faceIndex, int level)
{
ASSERT(level >= 0 && faceIndex < 6 && level < (int)ArraySize(mImageArray[faceIndex]) && mImageArray[faceIndex][level] != NULL);
ImageD3D *image = mImageArray[faceIndex][level];
if (image->isDirty())
{
commitRect(faceIndex, level, 0, 0, image->getWidth(), image->getHeight());
}
}
void TextureD3D_Cube::redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height)
{
// 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 GLenum storageFormat = getBaseLevelInternalFormat();
mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, width, height, 1, false);
if (mTexStorage)
{
const int storageLevels = mTexStorage->getLevelCount();
if ((level >= storageLevels && storageLevels != 0) ||
width != storageWidth ||
height != storageHeight ||
internalformat != storageFormat) // Discard mismatched storage
{
for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
{
for (int faceIndex = 0; faceIndex < 6; faceIndex++)
{
mImageArray[faceIndex][level]->markDirty();
}
}
SafeDelete(mTexStorage);
mDirtyImages = true;
}
}
}
void TextureD3D_Cube::commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
{
if (isValidFaceLevel(faceIndex, level))
{
ImageD3D *image = mImageArray[faceIndex][level];
if (image->copyToStorage(mTexStorage, faceIndex, level, xoffset, yoffset, width, height))
image->markClean();
}
}
}
\ No newline at end of file
src/libGLESv2/renderer/d3d/TextureD3D.h
......@@ -26,6 +26,7 @@ class ImageD3D;
class Renderer;
class TextureStorageInterface;
class TextureStorageInterface2D;
class TextureStorageInterfaceCube;
class TextureD3D
{
......@@ -135,6 +136,70 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
};
class TextureD3D_Cube : public TextureCubeImpl, public TextureD3D
{
public:
TextureD3D_Cube(rx::Renderer *renderer);
virtual ~TextureD3D_Cube();
static TextureD3D_Cube *makeTextureD3D_Cube(TextureCubeImpl *texture);
virtual TextureStorageInterface *getNativeTexture();
virtual Image *getImage(GLenum target, int level) const;
virtual void setUsage(GLenum usage);
virtual bool hasDirtyImages() const { return mDirtyImages; }
virtual void resetDirty();
GLenum getInternalFormat(GLenum target, GLint level) const;
bool isDepth(GLenum target, GLint level) const;
virtual void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
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 size);
virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
virtual bool isCubeComplete() const;
virtual void generateMipmaps();
virtual unsigned int getRenderTargetSerial(GLenum target, GLint level);
virtual RenderTarget *getRenderTarget(GLenum target, GLint level);
virtual RenderTarget *getDepthStencil(GLenum target, GLint level);
static int targetToIndex(GLenum target);
private:
DISALLOW_COPY_AND_ASSIGN(TextureD3D_Cube);
void initializeStorage(bool renderTarget);
TextureStorageInterfaceCube *createCompleteStorage(bool renderTarget) const;
void setCompleteTexStorage(TextureStorageInterfaceCube *newCompleteTexStorage);
void updateStorage();
bool ensureRenderTarget();
virtual TextureStorageInterface *getBaseLevelStorage();
virtual const ImageD3D *getBaseLevelImage() const;
bool isMipmapCubeComplete() const;
bool isValidFaceLevel(int faceIndex, int level) const;
bool isFaceLevelComplete(int faceIndex, int level) const;
void updateStorageFaceLevel(int faceIndex, int level);
void redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height);
void commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
ImageD3D *mImageArray[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
TextureStorageInterfaceCube *mTexStorage;
};
}
#endif // LIBGLESV2_RENDERER_TEXTURED3D_H_
src/libGLESv2/renderer/d3d/TextureStorage.cpp
......@@ -10,6 +10,7 @@
// GPU-side texture.
#include "libGLESv2/renderer/d3d/TextureStorage.h"
#include "libGLESv2/renderer/d3d/TextureD3D.h"
#include "libGLESv2/renderer/Renderer.h"
#include "libGLESv2/Renderbuffer.h"
#include "libGLESv2/Texture.h"
......@@ -116,7 +117,7 @@ void TextureStorageInterfaceCube::generateMipmap(int faceIndex, int level)
unsigned int TextureStorageInterfaceCube::getRenderTargetSerial(GLenum target, GLint level) const
{
return mFirstRenderTargetSerial + (level * 6) + gl::TextureCubeMap::targetToIndex(target);
return mFirstRenderTargetSerial + (level * 6) + TextureD3D_Cube::targetToIndex(target);
}
TextureStorageInterface3D::TextureStorageInterface3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
......
src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
......@@ -2906,6 +2906,11 @@ Texture2DImpl *Renderer11::createTexture2D()
return new TextureD3D_2D(this);
}
TextureCubeImpl *Renderer11::createTextureCube()
{
return new TextureD3D_Cube(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
......@@ -179,6 +179,7 @@ class Renderer11 : public Renderer
// Texture creation
virtual Texture2DImpl *createTexture2D();
virtual TextureCubeImpl *createTextureCube();
// Buffer creation
virtual BufferImpl *createBuffer();
......
src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
......@@ -10,6 +10,7 @@
#include "libGLESv2/renderer/d3d/d3d11/TextureStorage11.h"
#include "libGLESv2/renderer/d3d/TextureD3D.h"
#include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
#include "libGLESv2/renderer/d3d/d3d11/RenderTarget11.h"
#include "libGLESv2/renderer/d3d/d3d11/SwapChain11.h"
......@@ -770,7 +771,7 @@ RenderTarget *TextureStorage11_Cube::getRenderTargetFace(GLenum faceTarget, int
{
if (level >= 0 && level < getLevelCount())
{
int faceIndex = gl::TextureCubeMap::targetToIndex(faceTarget);
int faceIndex = TextureD3D_Cube::targetToIndex(faceTarget);
if (!mRenderTarget[faceIndex][level])
{
ID3D11Device *device = mRenderer->getDevice();
......
src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
......@@ -3199,6 +3199,11 @@ Texture2DImpl *Renderer9::createTexture2D()
return new TextureD3D_2D(this);
}
TextureCubeImpl *Renderer9::createTextureCube()
{
return new TextureD3D_Cube(this);
}
bool Renderer9::getLUID(LUID *adapterLuid) const
{
adapterLuid->HighPart = 0;
......
src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
......@@ -181,6 +181,7 @@ class Renderer9 : public Renderer
// Texture creation
virtual Texture2DImpl *createTexture2D();
virtual TextureCubeImpl *createTextureCube();
// Buffer creation
virtual BufferImpl *createBuffer();
......
src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
......@@ -10,6 +10,7 @@
// D3D9 texture.
#include "libGLESv2/main.h"
#include "libGLESv2/renderer/d3d/TextureD3D.h"
#include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
#include "libGLESv2/renderer/d3d/d3d9/TextureStorage9.h"
#include "libGLESv2/renderer/d3d/d3d9/SwapChain9.h"
......@@ -264,7 +265,7 @@ IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, in
RenderTarget *TextureStorage9_Cube::getRenderTargetFace(GLenum faceTarget, int level)
{
return mRenderTarget[gl::TextureCubeMap::targetToIndex(faceTarget)];
return mRenderTarget[TextureD3D_Cube::targetToIndex(faceTarget)];
}
void TextureStorage9_Cube::generateMipmap(int faceIndex, int level)
......
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