unsigned Texture::GetComponents() const
{
if (!width_ || IsCompressed())
return 0;
else
return GetRowDataSize(width_) / width_;
}
bool TextureCube::GetData(CubeMapFace face, unsigned level, void* dest) const
{
if (!object_)
{
LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Getting texture data while device is lost");
return false;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
D3DLOCKED_RECT d3dLockedRect;
RECT d3dRect;
d3dRect.left = 0;
d3dRect.top = 0;
d3dRect.right = levelWidth;
d3dRect.bottom = levelHeight;
if (FAILED(((IDirect3DCubeTexture9*)object_)->LockRect((D3DCUBEMAP_FACES)face, level, &d3dLockedRect, &d3dRect, D3DLOCK_READONLY)))
{
LOGERROR("Could not lock texture");
return false;
}
int height = levelHeight;
if (IsCompressed())
height = (height + 3) >> 2;
unsigned char* destPtr = (unsigned char*)dest;
unsigned rowSize = GetRowDataSize(levelWidth);
// GetRowDataSize() returns CPU-side (destination) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion to RGB / RGBA as necessary
switch (format_)
{
default:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
memcpy(destPtr, src, rowSize);
destPtr += rowSize;
}
break;
case D3DFMT_X8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++; destPtr[1] = *src++; destPtr[0] = *src++; ++src;
destPtr += 3;
}
}
break;
case D3DFMT_A8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++; destPtr[1] = *src++; destPtr[0] = *src++; destPtr[3] = *src++;
destPtr += 4;
}
}
break;
}
((IDirect3DCubeTexture9*)object_)->UnlockRect((D3DCUBEMAP_FACES)face, level);
return true;
}
bool TextureCube::SetData(CubeMapFace face, unsigned level, int x, int y, int width, int height, const void* data)
{
if (!object_)
{
LOGERROR("No texture created, can not set data");
return false;
}
if (!data)
{
LOGERROR("Null source for setting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for setting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Texture data assignment while device is lost");
dataPending_ = true;
return true;
}
if (IsCompressed())
{
x &= ~3;
y &= ~3;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || width <= 0 || height <= 0)
{
LOGERROR("Illegal dimensions for setting data");
return false;
}
D3DLOCKED_RECT d3dLockedRect;
RECT d3dRect;
d3dRect.left = x;
d3dRect.top = y;
d3dRect.right = x + width;
d3dRect.bottom = y + height;
DWORD flags = 0;
if (level == 0 && x == 0 && y == 0 && width == levelWidth && height == levelHeight && pool_ == D3DPOOL_DEFAULT)
flags |= D3DLOCK_DISCARD;
if (FAILED(((IDirect3DCubeTexture9*)object_)->LockRect((D3DCUBEMAP_FACES)face, level, &d3dLockedRect, (flags &
D3DLOCK_DISCARD) ? 0 : &d3dRect, flags)))
{
LOGERROR("Could not lock texture");
return false;
}
if (IsCompressed())
{
height = (height + 3) >> 2;
y >>= 2;
}
unsigned char* src = (unsigned char*)data;
unsigned rowSize = GetRowDataSize(width);
// GetRowDataSize() returns CPU-side (source) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion from RGB / RGBA as necessary
switch (format_)
{
default:
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
memcpy(dest, src, rowSize);
src += rowSize;
}
break;
case D3DFMT_X8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < width; ++j)
{
*dest++ = src[2]; *dest++ = src[1]; *dest++ = src[0]; *dest++ = 255;
src += 3;
}
}
break;
case D3DFMT_A8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < width; ++j)
{
*dest++ = src[2]; *dest++ = src[1]; *dest++ = src[0]; *dest++ = src[3];
src += 4;
}
}
break;
}
((IDirect3DCubeTexture9*)object_)->UnlockRect((D3DCUBEMAP_FACES)face, level);
return true;
}
bool Texture2D::GetData(unsigned level, void* dest) const
{
if (!object_.ptr_)
{
ATOMIC_LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
ATOMIC_LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
ATOMIC_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
ATOMIC_LOGWARNING("Getting texture data while device is lost");
return false;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
D3DLOCKED_RECT d3dLockedRect;
RECT d3dRect;
d3dRect.left = 0;
d3dRect.top = 0;
d3dRect.right = levelWidth;
d3dRect.bottom = levelHeight;
IDirect3DSurface9* offscreenSurface = 0;
// Need to use a offscreen surface & GetRenderTargetData() for rendertargets
if (renderSurface_)
{
if (level != 0)
{
ATOMIC_LOGERROR("Can only get mip level 0 data from a rendertarget");
return false;
}
IDirect3DDevice9* device = graphics_->GetImpl()->GetDevice();
HRESULT hr = device->CreateOffscreenPlainSurface((UINT)width_, (UINT)height_, (D3DFORMAT)format_,
D3DPOOL_SYSTEMMEM, &offscreenSurface, 0);
if (FAILED(hr))
{
ATOMIC_SAFE_RELEASE(offscreenSurface);
ATOMIC_LOGD3DERROR("Could not create surface for getting rendertarget data", hr);
return false;
}
hr = device->GetRenderTargetData((IDirect3DSurface9*)renderSurface_->GetSurface(), offscreenSurface);
if (FAILED(hr))
{
ATOMIC_LOGD3DERROR("Could not get rendertarget data", hr);
offscreenSurface->Release();
return false;
}
hr = offscreenSurface->LockRect(&d3dLockedRect, &d3dRect, D3DLOCK_READONLY);
if (FAILED(hr))
{
ATOMIC_LOGD3DERROR("Could not lock surface for getting rendertarget data", hr);
offscreenSurface->Release();
return false;
}
}
else
{
HRESULT hr = ((IDirect3DTexture9*)object_.ptr_)->LockRect(level, &d3dLockedRect, &d3dRect, D3DLOCK_READONLY);
if (FAILED(hr))
{
ATOMIC_LOGD3DERROR("Could not lock texture", hr);
return false;
}
}
int height = levelHeight;
if (IsCompressed())
height = (height + 3) >> 2;
unsigned char* destPtr = (unsigned char*)dest;
unsigned rowSize = GetRowDataSize(levelWidth);
// GetRowDataSize() returns CPU-side (destination) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion to RGB / RGBA as necessary
switch (format_)
{
default:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
memcpy(destPtr, src, rowSize);
destPtr += rowSize;
}
break;
case D3DFMT_X8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++;
destPtr[1] = *src++;
destPtr[0] = *src++;
++src;
destPtr += 3;
}
}
break;
case D3DFMT_A8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++;
destPtr[1] = *src++;
destPtr[0] = *src++;
destPtr[3] = *src++;
destPtr += 4;
}
}
break;
}
if (offscreenSurface)
{
offscreenSurface->UnlockRect();
offscreenSurface->Release();
}
else
((IDirect3DTexture9*)object_.ptr_)->UnlockRect(level);
return true;
}
bool Texture3D::SetData(unsigned level, int x, int y, int z, int width, int height, int depth, const void* data)
{
PROFILE(SetTextureData);
if (!object_)
{
LOGERROR("No texture created, can not set data");
return false;
}
if (!data)
{
LOGERROR("Null source for setting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for setting data");
return false;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
int levelDepth = GetLevelDepth(level);
if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || z < 0 || z + depth > levelDepth || width <= 0 ||
height <= 0 || depth <= 0)
{
LOGERROR("Illegal dimensions for setting data");
return false;
}
// If compressed, align the update region on a block
if (IsCompressed())
{
x &= ~3;
y &= ~3;
width += 3;
width &= 0xfffffffc;
height += 3;
height &= 0xfffffffc;
}
unsigned char* src = (unsigned char*)data;
unsigned rowSize = GetRowDataSize(width);
unsigned rowStart = GetRowDataSize(x);
unsigned subResource = D3D11CalcSubresource(level, 0, levels_);
if (usage_ == TEXTURE_DYNAMIC)
{
if (IsCompressed())
{
height = (height + 3) >> 2;
y >>= 2;
}
D3D11_MAPPED_SUBRESOURCE mappedData;
mappedData.pData = 0;
graphics_->GetImpl()->GetDeviceContext()->Map((ID3D11Resource*)object_, subResource, D3D11_MAP_WRITE_DISCARD, 0,
&mappedData);
if (mappedData.pData)
{
for (int page = 0; page < depth; ++page)
{
for (int row = 0; row < height; ++row)
{
memcpy((unsigned char*)mappedData.pData + (page + z) * mappedData.DepthPitch + (row + y) * mappedData.RowPitch +
rowStart, src + row * rowSize, rowSize);
}
}
graphics_->GetImpl()->GetDeviceContext()->Unmap((ID3D11Resource*)object_, subResource);
}
else
{
LOGERROR("Failed to map texture for update");
return false;
}
}
else
{
if (IsCompressed())
bool TextureCube::GetData(CubeMapFace face, unsigned level, void* dest) const
{
if (!object_.ptr_)
{
URHO3D_LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
URHO3D_LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Getting texture data while device is lost");
return false;
}
if (resolveDirty_)
graphics_->ResolveToTexture(const_cast<TextureCube*>(this));
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
D3DLOCKED_RECT d3dLockedRect;
RECT d3dRect;
d3dRect.left = 0;
d3dRect.top = 0;
d3dRect.right = levelWidth;
d3dRect.bottom = levelHeight;
IDirect3DSurface9* offscreenSurface = nullptr;
// Need to use a offscreen surface & GetRenderTargetData() for rendertargets
if (renderSurfaces_[face])
{
if (level != 0)
{
URHO3D_LOGERROR("Can only get mip level 0 data from a rendertarget");
return false;
}
// If multisampled, must copy the surface of the resolve texture instead of the multisampled surface
IDirect3DSurface9* resolveSurface = nullptr;
if (multiSample_ > 1)
{
HRESULT hr = ((IDirect3DCubeTexture9*)object_.ptr_)->GetCubeMapSurface((D3DCUBEMAP_FACES)face, 0,
(IDirect3DSurface9**)&resolveSurface);
if (FAILED(hr))
{
URHO3D_LOGD3DERROR("Could not get surface of the resolve texture", hr);
URHO3D_SAFE_RELEASE(resolveSurface);
return false;
}
}
IDirect3DDevice9* device = graphics_->GetImpl()->GetDevice();
HRESULT hr = device->CreateOffscreenPlainSurface((UINT)width_, (UINT)height_, (D3DFORMAT)format_, D3DPOOL_SYSTEMMEM, &offscreenSurface, nullptr);
if (FAILED(hr))
{
URHO3D_LOGD3DERROR("Could not create surface for getting rendertarget data", hr);
URHO3D_SAFE_RELEASE(offscreenSurface);
URHO3D_SAFE_RELEASE(resolveSurface);
return false;
}
if (resolveSurface)
hr = device->GetRenderTargetData(resolveSurface, offscreenSurface);
else
hr = device->GetRenderTargetData((IDirect3DSurface9*)renderSurfaces_[face]->GetSurface(), offscreenSurface);
URHO3D_SAFE_RELEASE(resolveSurface);
if (FAILED(hr))
{
URHO3D_LOGD3DERROR("Could not get rendertarget data", hr);
URHO3D_SAFE_RELEASE(offscreenSurface);
return false;
}
if (FAILED(offscreenSurface->LockRect(&d3dLockedRect, &d3dRect, D3DLOCK_READONLY)))
{
URHO3D_LOGD3DERROR("Could not lock surface for getting rendertarget data", hr);
URHO3D_SAFE_RELEASE(offscreenSurface);
return false;
}
}
else
{
HRESULT hr = ((IDirect3DCubeTexture9*)object_.ptr_)->LockRect((D3DCUBEMAP_FACES)face, level, &d3dLockedRect, &d3dRect, D3DLOCK_READONLY);
if (FAILED(hr))
{
URHO3D_LOGD3DERROR("Could not lock texture", hr);
return false;
}
}
int height = levelHeight;
if (IsCompressed())
height = (height + 3) >> 2;
unsigned char* destPtr = (unsigned char*)dest;
unsigned rowSize = GetRowDataSize(levelWidth);
// GetRowDataSize() returns CPU-side (destination) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion to RGB / RGBA as necessary
switch (format_)
{
default:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
memcpy(destPtr, src, rowSize);
destPtr += rowSize;
}
break;
case D3DFMT_X8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++;
destPtr[1] = *src++;
destPtr[0] = *src++;
++src;
destPtr += 3;
}
}
break;
case D3DFMT_A8R8G8B8:
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedRect.pBits + i * d3dLockedRect.Pitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++;
destPtr[1] = *src++;
destPtr[0] = *src++;
destPtr[3] = *src++;
destPtr += 4;
}
}
break;
}
if (offscreenSurface)
offscreenSurface->UnlockRect();
else
((IDirect3DCubeTexture9*)object_.ptr_)->UnlockRect((D3DCUBEMAP_FACES)face, level);
URHO3D_SAFE_RELEASE(offscreenSurface);
return true;
}
bool Texture3D::GetData(unsigned level, void* dest) const
{
if (!object_)
{
LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Getting texture data while device is lost");
return false;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
int levelDepth = GetLevelDepth(level);
D3DLOCKED_BOX d3dLockedBox;
D3DBOX d3dBox;
d3dBox.Left = 0;
d3dBox.Top = 0;
d3dBox.Front = 0;
d3dBox.Right = levelWidth;
d3dBox.Bottom = levelHeight;
d3dBox.Back = levelDepth;
if (FAILED(((IDirect3DVolumeTexture9*)object_)->LockBox(level, &d3dLockedBox, &d3dBox, D3DLOCK_READONLY)))
{
LOGERROR("Could not lock texture");
return false;
}
int height = levelHeight;
if (IsCompressed())
height = (height + 3) >> 2;
unsigned char* destPtr = (unsigned char*)dest;
unsigned rowSize = GetRowDataSize(levelWidth);
// GetRowDataSize() returns CPU-side (destination) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion to RGB / RGBA as necessary
switch (format_)
{
default:
for (int k = 0; k < levelDepth; ++k)
{
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedBox.pBits + (k * d3dLockedBox.SlicePitch) + i * d3dLockedBox.RowPitch;
memcpy(destPtr, src, rowSize);
destPtr += rowSize;
}
}
break;
case D3DFMT_X8R8G8B8:
for (int k = 0; k < levelDepth; ++k)
{
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedBox.pBits + (k * d3dLockedBox.SlicePitch) + i * d3dLockedBox.RowPitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++; destPtr[1] = *src++; destPtr[0] = *src++; ++src;
destPtr += 3;
}
}
}
break;
case D3DFMT_A8R8G8B8:
for (int k = 0; k < levelDepth; ++k)
{
for (int i = 0; i < height; ++i)
{
unsigned char* src = (unsigned char*)d3dLockedBox.pBits + (k * d3dLockedBox.SlicePitch) + i * d3dLockedBox.RowPitch;
for (int j = 0; j < levelWidth; ++j)
{
destPtr[2] = *src++; destPtr[1] = *src++; destPtr[0] = *src++; destPtr[3] = *src++;
destPtr += 4;
}
}
}
break;
}
((IDirect3DVolumeTexture9*)object_)->UnlockBox(level);
return true;
}
bool Texture3D::SetData(unsigned level, int x, int y, int z, int width, int height, int depth, const void* data)
{
PROFILE(SetTextureData);
if (!object_)
{
LOGERROR("No texture created, can not set data");
return false;
}
if (!data)
{
LOGERROR("Null source for setting data");
return false;
}
if (level >= levels_)
{
LOGERROR("Illegal mip level for setting data");
return false;
}
if (graphics_->IsDeviceLost())
{
LOGWARNING("Texture data assignment while device is lost");
dataPending_ = true;
return true;
}
if (IsCompressed())
{
x &= ~3;
y &= ~3;
}
int levelWidth = GetLevelWidth(level);
int levelHeight = GetLevelHeight(level);
int levelDepth = GetLevelDepth(level);
if (x < 0 || x + width > levelWidth || y < 0 || y + height > levelHeight || z < 0 || z + depth > levelDepth || width <= 0 || height <= 0 || depth <= 0)
{
LOGERROR("Illegal dimensions for setting data");
return false;
}
D3DLOCKED_BOX d3dLockedBox;
D3DBOX d3dBox;
d3dBox.Left = x;
d3dBox.Top = y;
d3dBox.Front = z;
d3dBox.Right = x + width;
d3dBox.Bottom = y + height;
d3dBox.Back = z + depth;
DWORD flags = 0;
if (level == 0 && x == 0 && y == 0 && z == 0 && width == levelWidth && height == levelHeight && depth == levelDepth && pool_ == D3DPOOL_DEFAULT)
flags |= D3DLOCK_DISCARD;
if (FAILED(((IDirect3DVolumeTexture9*)object_)->LockBox(level, &d3dLockedBox, (flags & D3DLOCK_DISCARD) ? 0 : &d3dBox, flags)))
{
LOGERROR("Could not lock texture");
return false;
}
if (IsCompressed())
{
height = (height + 3) >> 2;
y >>= 2;
}
unsigned char* src = (unsigned char*)data;
unsigned rowSize = GetRowDataSize(width);
// GetRowDataSize() returns CPU-side (source) data size, so need to convert for X8R8G8B8
if (format_ == D3DFMT_X8R8G8B8)
rowSize = rowSize / 3 * 4;
// Perform conversion from RGB / RGBA as necessary
switch (format_)
{
default:
for (int k = 0; k < levelDepth; ++k)
{
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedBox.pBits + (k * d3dLockedBox.SlicePitch) + i * d3dLockedBox.RowPitch;
memcpy(dest, src, rowSize);
src += rowSize;
}
}
break;
case D3DFMT_X8R8G8B8:
for (int k = 0; k < levelDepth; ++k)
{
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedBox.pBits + (k * d3dLockedBox.SlicePitch) + i * d3dLockedBox.RowPitch;
for (int j = 0; j < width; ++j)
{
*dest++ = src[2]; *dest++ = src[1]; *dest++ = src[0]; *dest++ = 255;
src += 3;
}
}
}
break;
case D3DFMT_A8R8G8B8:
for (int k = 0; k < levelDepth; ++k)
{
for (int i = 0; i < height; ++i)
{
unsigned char* dest = (unsigned char*)d3dLockedBox.pBits + (k * d3dLockedBox.SlicePitch) + i * d3dLockedBox.RowPitch;
for (int j = 0; j < width; ++j)
{
*dest++ = src[2]; *dest++ = src[1]; *dest++ = src[0]; *dest++ = src[3];
src += 4;
}
}
}
break;
}
((IDirect3DVolumeTexture9*)object_)->UnlockBox(level);
return true;
}
