////////////////////////////////////////////////////////////////
//
// CPixelsManager::SetPixelColor
//
// Only works on PLAIN pixels
//
////////////////////////////////////////////////////////////////
bool CPixelsManager::SetPixelColor ( CPixels& pixels, uint uiPosX, uint uiPosY, const SColor color )
{
uint uiWidth, uiHeight;
if ( !GetPlainDimensions ( pixels, uiWidth, uiHeight ) )
return false;
if ( uiPosX >= uiWidth || uiPosY >= uiHeight )
return false;
uint uiOffset = uiPosX + uiPosY * uiWidth;
SColor* pColorArray = (SColor*)pixels.GetData ();
pColorArray [ uiOffset ] = color;
return true;
}
////////////////////////////////////////////////////////////////
//
// CPixelsManager::GetPixelColor
//
// Only works on PLAIN pixels
//
////////////////////////////////////////////////////////////////
bool CPixelsManager::GetPixelColor ( const CPixels& pixels, uint uiPosX, uint uiPosY, SColor& outColor )
{
uint uiWidth, uiHeight;
if ( !GetPlainDimensions ( pixels, uiWidth, uiHeight ) )
return false;
if ( uiPosX >= uiWidth || uiPosY >= uiHeight )
return false;
uint uiOffset = uiPosX + uiPosY * uiWidth;
const SColor* pColorArray = (const SColor*)pixels.GetData ();
outColor = pColorArray [ uiOffset ];
return true;
}
////////////////////////////////////////////////////////////////
//
// CPixelsManager::GetPixelsSize
//
//
//
////////////////////////////////////////////////////////////////
bool CPixelsManager::GetPixelsSize ( const CPixels& pixels, uint& uiOutWidth, uint& uiOutHeight )
{
EPixelsFormatType format = GetPixelsFormat ( pixels );
if ( format == EPixelsFormat::PLAIN )
{
return GetPlainDimensions ( pixels, uiOutWidth, uiOutHeight );
}
else
if ( format == EPixelsFormat::PNG )
{
return PngGetDimensions ( pixels.GetData (), pixels.GetSize (), uiOutWidth, uiOutHeight );
}
else
if ( format == EPixelsFormat::JPEG )
{
return JpegGetDimensions ( pixels.GetData (), pixels.GetSize (), uiOutWidth, uiOutHeight );
}
return false;
}
////////////////////////////////////////////////////////////////
//
// CPixelsManager::GetPixelsFormat
//
// Auto detect PNG, JPEG or PLAIN
//
////////////////////////////////////////////////////////////////
EPixelsFormatType CPixelsManager::GetPixelsFormat ( const CPixels& pixels )
{
uint uiDataSize = pixels.GetSize ();
const char* pData = pixels.GetData ();
// Check if png
if ( IsPng ( pData, uiDataSize ) )
return EPixelsFormat::PNG;
// Check if jpeg
if ( IsJpeg ( pData, uiDataSize ) )
return EPixelsFormat::JPEG;
// Check if plain
if ( uiDataSize >= 8 )
{
uint uiWidth, uiHeight;
if ( GetPlainDimensions ( pixels, uiWidth, uiHeight ) )
return EPixelsFormat::PLAIN;
}
return EPixelsFormat::UNKNOWN;
}
////////////////////////////////////////////////////////////////
//
// CPixelsManager::SetVolumePixels
//
// Here we have a surface which:
// 1 - is D3DFMT_R5G6B5 or D3DFMT_X8R8G8B8/D3DFMT_A8R8G8B8
// 2 - can be locked
//
// Requires PLAIN pixels
//
////////////////////////////////////////////////////////////////
bool CPixelsManager::SetVolumePixels ( IDirect3DVolume9* pD3DSurface, const CPixels& pixels, const RECT* pRect, uint uiSlice )
{
if ( !pD3DSurface )
return false;
// Calc surface rect
D3DVOLUME_DESC SurfDesc;
pD3DSurface->GetDesc ( &SurfDesc );
POINT SurfSize = { SurfDesc.Width, SurfDesc.Height };
RECT SurfRect = { 0, 0, SurfDesc.Width, SurfDesc.Height };
if ( pRect )
SurfRect = *pRect;
// Calc pixels rect
uint uiPixelsWidth, uiPixelsHeight;
if ( !GetPlainDimensions ( pixels, uiPixelsWidth, uiPixelsHeight ) )
return false;
POINT PixelsSize = { uiPixelsWidth, uiPixelsHeight };
RECT PixelsRect = { 0, 0, uiPixelsWidth, uiPixelsHeight };
// Validate rects
if ( !ClipRects ( PixelsSize, PixelsRect, SurfSize, SurfRect ) )
return false;
// Check if pRect can be NULL
pRect = &SurfRect;
if ( SurfRect.left == 0 && SurfRect.top == 0 && SurfRect.right == SurfDesc.Width && SurfRect.bottom == SurfDesc.Height )
pRect = NULL;
// Get pixels from pD3DSurface
D3DLOCKED_RECT LockedRect;
if ( FAILED ( LockVolumeRect ( pD3DSurface, &LockedRect, pRect, D3DLOCK_NOSYSLOCK, uiSlice ) ) )
return false;
// Get sizes
uint SurfRectWidth = GetRectWidth ( SurfRect );
uint SurfRectHeight = GetRectHeight ( SurfRect );
uint PixelsRectWidth = GetRectWidth ( PixelsRect );
uint PixelsRectHeight = GetRectHeight ( PixelsRect );
uint CopyWidth = Min ( SurfRectWidth, PixelsRectWidth );
uint CopyHeight = Min ( SurfRectHeight, PixelsRectHeight );
// Prepare pixels
uint ulPixelsPitch = uiPixelsWidth * XRGB_BYTES_PER_PIXEL;
const char* pPixelsData = pixels.GetData ();
pPixelsData += PixelsRect.left * XRGB_BYTES_PER_PIXEL;
pPixelsData += PixelsRect.top * ulPixelsPitch;
uint ulSurfPitch = LockedRect.Pitch;
BYTE* pSurfBits = (BYTE*)LockedRect.pBits;
if ( CRenderItemManager::GetBitsPerPixel ( SurfDesc.Format ) == 32 )
{
if ( SurfDesc.Format == D3DFMT_A8R8G8B8 )
{
uint uiCopyWidthBytes = CopyWidth * XRGB_BYTES_PER_PIXEL;
// Copy lines into surface
for ( uint i = 0; i < CopyHeight; i++ )
{
memcpy ( pSurfBits + ulSurfPitch * i, pPixelsData + ulPixelsPitch * i, uiCopyWidthBytes );
}
}
else
{
// Copy lines into surface
for ( uint i = 0; i < CopyHeight; i++ )
{
const DWORD* pLinePixelsStart = (DWORD*)( pPixelsData + ulPixelsPitch * i );
DWORD* pLineSurfStart = (DWORD*)( pSurfBits + ulSurfPitch * i );
for ( uint x = 0; x < CopyWidth; x++ )
{
DWORD x8r8g8b8 = pLinePixelsStart[x];
x8r8g8b8 |= 0xff000000;
pLineSurfStart[x] = x8r8g8b8;
}
}
}
}
else
if ( CRenderItemManager::GetBitsPerPixel ( SurfDesc.Format ) == 16 )
{
// Copy lines into surface
for ( uint i = 0; i < CopyHeight; i++ )
{
const DWORD* pLinePixelsStart = (DWORD*)( pPixelsData + ulPixelsPitch * i );
WORD* pLineSurfStart = (WORD*)( pSurfBits + ulSurfPitch * i );
for ( uint x = 0; x < CopyWidth; x++ )
{
DWORD x8r8g8b8 = pLinePixelsStart[x];
WORD r = ( x8r8g8b8 & 0xF80000 ) >> 8;
WORD g = ( x8r8g8b8 & 0xFC00 ) >> 5;
WORD b = ( x8r8g8b8 & 0xF8 ) >> 3;
WORD r5g6b5 = r | g | b;
pLineSurfStart[x] = r5g6b5;
}
}
}
pD3DSurface->UnlockBox ();
return true;
}
