// Increments refcount on surface.
// caller must Release() the returned surface
gl::Error TextureStorage9_2D::getSurfaceLevel(GLenum target,
int level,
bool dirty,
IDirect3DSurface9 **outSurface)
{
ASSERT(target == GL_TEXTURE_2D);
UNUSED_ASSERTION_VARIABLE(target);
IDirect3DBaseTexture9 *baseTexture = NULL;
gl::Error error = getBaseTexture(&baseTexture);
if (error.isError())
{
return error;
}
IDirect3DTexture9 *texture = static_cast<IDirect3DTexture9*>(baseTexture);
HRESULT result = texture->GetSurfaceLevel(level + mTopLevel, outSurface);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::Error(GL_OUT_OF_MEMORY, "Failed to get the surface from a texture, result: 0x%X.", result);
}
// With managed textures the driver needs to be informed of updates to the lower mipmap levels
if (level + mTopLevel != 0 && isManaged() && dirty)
{
texture->AddDirtyRect(NULL);
}
return gl::Error(GL_NO_ERROR);
}
FileManager::Status FileManager::unmanage(const QString &pFileName)
{
QString nativeFileName = nativeCanonicalFileName(pFileName);
if (QFileInfo(nativeFileName).exists()) {
File *file = isManaged(nativeFileName);
if (file) {
// The file is managed, so we can remove it
mFiles.removeAt(mFiles.indexOf(file));
delete file;
emit fileUnmanaged(nativeFileName);
return Removed;
} else {
// The file isn't managed, so...
return NotManaged;
}
} else {
// The file doesn't exist, so...
return NotManaged;
}
}
// Increments refcount on surface.
// caller must Release() the returned surface
gl::Error TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, int level, bool dirty, IDirect3DSurface9 **outSurface)
{
IDirect3DBaseTexture9 *baseTexture = NULL;
gl::Error error = getBaseTexture(&baseTexture);
if (error.isError())
{
return error;
}
IDirect3DCubeTexture9 *texture = static_cast<IDirect3DCubeTexture9*>(baseTexture);
D3DCUBEMAP_FACES face = gl_d3d9::ConvertCubeFace(faceTarget);
HRESULT result = texture->GetCubeMapSurface(face, level + mTopLevel, outSurface);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::Error(GL_OUT_OF_MEMORY, "Failed to get the surface from a texture, result: 0x%X.", result);
}
// With managed textures the driver needs to be informed of updates to the lower mipmap levels
if (level != 0 && isManaged() && dirty)
{
texture->AddDirtyRect(face, NULL);
}
return gl::Error(GL_NO_ERROR);
}
bool FileManager::isModified(const QString &pFileName) const
{
// Return whether the file, if it is being managed, has been modified
File *file = isManaged(pFileName);
if (file)
return file->isModified();
else
return false;
}
// Increments refcount on surface.
// caller must Release() the returned surface
IDirect3DSurface9 *TextureStorage9_2D::getSurfaceLevel(int level, bool dirty)
{
IDirect3DSurface9 *surface = NULL;
if (mTexture)
{
HRESULT result = mTexture->GetSurfaceLevel(level + mTopLevel, &surface);
ASSERT(SUCCEEDED(result));
// With managed textures the driver needs to be informed of updates to the lower mipmap levels
if (level + mTopLevel != 0 && isManaged() && dirty)
{
mTexture->AddDirtyRect(NULL);
}
}
return surface;
}
// Increments refcount on surface.
// caller must Release() the returned surface
IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, int level, bool dirty)
{
IDirect3DSurface9 *surface = NULL;
if (mTexture)
{
D3DCUBEMAP_FACES face = gl_d3d9::ConvertCubeFace(faceTarget);
HRESULT result = mTexture->GetCubeMapSurface(face, level + mTopLevel, &surface);
ASSERT(SUCCEEDED(result));
// With managed textures the driver needs to be informed of updates to the lower mipmap levels
if (level != 0 && isManaged() && dirty)
{
mTexture->AddDirtyRect(face, NULL);
}
}
return surface;
}
void FileManager::setModified(const QString &pFileName, const bool &pModified)
{
// Set the modified status of the file, should it be managed
File *file = isManaged(pFileName);
if (file) {
// We are dealing with a managed file, so we can check its modified
// status and update it, if necessary, and then let people know about
// the new modified status
if (pModified == file->isModified())
return;
file->setModified(pModified);
emit fileModified(nativeCanonicalFileName(pFileName), pModified);
}
}
gl::Error TextureStorage9_Cube::copyToStorage(TextureStorage *destStorage)
{
ASSERT(destStorage);
TextureStorage9_Cube *dest9 = TextureStorage9_Cube::makeTextureStorage9_Cube(destStorage);
int levels = getLevelCount();
for (int f = 0; f < CUBE_FACE_COUNT; f++)
{
for (int i = 0; i < levels; i++)
{
IDirect3DSurface9 *srcSurf = NULL;
gl::Error error = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, false, &srcSurf);
if (error.isError())
{
return error;
}
IDirect3DSurface9 *dstSurf = NULL;
error = dest9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, true, &dstSurf);
if (error.isError())
{
SafeRelease(srcSurf);
return error;
}
error = mRenderer->copyToRenderTarget(dstSurf, srcSurf, isManaged());
SafeRelease(srcSurf);
SafeRelease(dstSurf);
if (error.isError())
{
return error;
}
}
}
return gl::Error(GL_NO_ERROR);
}
gl::Error TextureStorage9_2D::copyToStorage(TextureStorage *destStorage)
{
ASSERT(destStorage);
TextureStorage9_2D *dest9 = TextureStorage9_2D::makeTextureStorage9_2D(destStorage);
int levels = getLevelCount();
for (int i = 0; i < levels; ++i)
{
IDirect3DSurface9 *srcSurf = NULL;
gl::Error error = getSurfaceLevel(i, false, &srcSurf);
if (error.isError())
{
return error;
}
IDirect3DSurface9 *dstSurf = NULL;
error = dest9->getSurfaceLevel(i, true, &dstSurf);
if (error.isError())
{
SafeRelease(srcSurf);
return error;
}
error = mRenderer->copyToRenderTarget(dstSurf, srcSurf, isManaged());
SafeRelease(srcSurf);
SafeRelease(dstSurf);
if (error.isError())
{
return error;
}
}
return gl::Error(GL_NO_ERROR);
}
FileManager::Status FileManager::rename(const QString &pOldFileName,
const QString &pNewFileName)
{
// Check whether the 'old' file is managed
QString oldFileName = nativeCanonicalFileName(pOldFileName);
QString newFileName = nativeCanonicalFileName(pNewFileName);
File *file = isManaged(oldFileName);
if (!file) {
// The 'old' file is not managed, so...
return NotManaged;
} else {
// The 'old' file is managed, so we can rename it
file->setFileName(newFileName);
emit fileRenamed(oldFileName, newFileName);
return Renamed;
}
}
// Increments refcount on surface.
// caller must Release() the returned surface
angle::Result TextureStorage9_2D::getSurfaceLevel(const gl::Context *context,
gl::TextureTarget target,
int level,
bool dirty,
IDirect3DSurface9 **outSurface)
{
ASSERT(target == gl::TextureTarget::_2D);
IDirect3DBaseTexture9 *baseTexture = nullptr;
ANGLE_TRY(getBaseTexture(context, &baseTexture));
IDirect3DTexture9 *texture = static_cast<IDirect3DTexture9 *>(baseTexture);
HRESULT result = texture->GetSurfaceLevel(level + mTopLevel, outSurface);
ANGLE_TRY_HR(GetImplAs<Context9>(context), result, "Failed to get the surface from a texture");
// With managed textures the driver needs to be informed of updates to the lower mipmap levels
if (level + mTopLevel != 0 && isManaged() && dirty)
{
texture->AddDirtyRect(nullptr);
}
return angle::Result::Continue;
}
