Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/src/misc/bitmap.cpp
kervala 9370e93dd6 Removed useless comments/commented code 
--HG--
branch : develop
2016-02-20 18:09:24 +01:00

4511 lines
103 KiB
C++
Raw Blame History

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdmisc.h"
#include "nel/misc/bitmap.h"
#include "nel/misc/stream.h"
#include "nel/misc/file.h"
#include "nel/misc/system_info.h"
// Define this to force all bitmap white (debug)
// #define NEL_ALL_BITMAP_WHITE
using namespace std;
#ifdef DEBUG_NEW
#define new DEBUG_NEW
#endif
namespace NLMISC
{
struct EDDSBadHeader : public NLMISC::EStream
{
EDDSBadHeader() : EStream( "Bad or unrecognized DDS file header" ) {}
};
struct ESeekFailed : public NLMISC::EStream
{
ESeekFailed() : EStream( "Seek failed" ) {}
};
struct EAllocationFailure : public Exception
{
EAllocationFailure() : Exception( "Can't allocate memory" ) {}
};
void blendFromui(NLMISC::CRGBA &c0, NLMISC::CRGBA &c1, uint coef);
uint32 blend(uint32 &n0, uint32 &n1, uint32 coef0);
const uint32 CBitmap::bitPerPixels[ModeCount]=
{
32, // RGBA
8, // Luminance
8, // Alpha
16, // AlphaLuminance
4, // DXTC1
4, // DXTC1Alpha
8, // DXTC3
8, // DXTC5
16 // DsDt
};
const uint32 CBitmap::DXTC1HEADER = NL_MAKEFOURCC('D', 'X', 'T', '1');
const uint32 CBitmap::DXTC3HEADER = NL_MAKEFOURCC('D', 'X', 'T', '3');
const uint32 CBitmap::DXTC5HEADER = NL_MAKEFOURCC('D', 'X', 'T', '5');
#ifdef NEL_ALL_BITMAP_WHITE
// Make all the textures white
void MakeWhite(CBitmap &bitmaps)
{
for (uint i=0; i<bitmaps.getMipMapCount (); i++)
{
uint size = bitmaps.getPixels (i).size ();
bitmaps.getPixels (i).resize (0);
bitmaps.getPixels (i).resize (size);
bitmaps.getPixels (i).fill (0xff);
}
}
#endif // NEL_ALL_BITMAP_WHITE
CBitmap::CBitmap()
{
_MipMapCount = 1;
_Width = 0;
_Height = 0;
PixelFormat = RGBA;
_LoadGrayscaleAsAlpha = true;
}
CBitmap::~CBitmap()
{
}
/*-------------------------------------------------------------------*\
load
\*-------------------------------------------------------------------*/
uint8 CBitmap::load(NLMISC::IStream &f, uint mipMapSkip)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
nlassert(f.isReading());
// testing if DDS
uint32 fileType = 0;;
f.serial(fileType);
if(fileType == DDS_HEADER)
{
#ifdef NEL_ALL_BITMAP_WHITE
uint8 result = readDDS(f, mipMapSkip);
MakeWhite (*this);
return result;
#else // NEL_ALL_BITMAP_WHITE
return readDDS(f, mipMapSkip);
#endif // NEL_ALL_BITMAP_WHITE
}
if (fileType == PNG_HEADER)
{
#ifdef NEL_ALL_BITMAP_WHITE
uint8 result = readPNG(f);
MakeWhite (*this);
return result;
#else // NEL_ALL_BITMAP_WHITE
return readPNG(f);
#endif // NEL_ALL_BITMAP_WHITE
}
#ifdef USE_JPEG
if (fileType == JPG_HEADER)
{
#ifdef NEL_ALL_BITMAP_WHITE
uint8 result = readJPG(f);
MakeWhite (*this);
return result;
#else // NEL_ALL_BITMAP_WHITE
return readJPG(f);
#endif // NEL_ALL_BITMAP_WHITE
}
#endif // USE_JPEG
#ifdef USE_GIF
if (fileType == GIF_HEADER)
{
#ifdef NEL_ALL_BITMAP_WHITE
uint8 result = readGIF(f);
MakeWhite (*this);
return result;
#else // NEL_ALL_BITMAP_WHITE
return readGIF(f);
#endif // NEL_ALL_BITMAP_WHITE
}
#endif // USE_GIF
// assuming it's TGA
NLMISC::IStream::TSeekOrigin origin= f.begin;
if(!f.seek (0, origin))
{
throw ESeekFailed();
}
// Reading header,
// To make sure that the bitmap is TGA, we check imageType and imageDepth.
uint8 lengthID;
uint8 cMapType;
uint8 imageType;
uint16 tgaOrigin;
uint16 length;
uint8 depth;
uint16 xOrg;
uint16 yOrg;
uint16 width;
uint16 height;
uint8 imageDepth;
uint8 desc;
f.serial(lengthID);
f.serial(cMapType);
f.serial(imageType);
if(imageType!=2 && imageType!=3 && imageType!=10 && imageType!=11) return 0;
f.serial(tgaOrigin);
f.serial(length);
f.serial(depth);
f.serial(xOrg);
f.serial(yOrg);
f.serial(width);
f.serial(height);
f.serial(imageDepth);
if(imageDepth!=8 && imageDepth!=16 && imageDepth!=24 && imageDepth!=32) return 0;
f.serial(desc);
if(!f.seek (0, origin))
{
throw ESeekFailed();
}
#ifdef NEL_ALL_BITMAP_WHITE
uint8 result = readTGA(f);
MakeWhite (*this);
return result;
#else // NEL_ALL_BITMAP_WHITE
return readTGA(f);
#endif // NEL_ALL_BITMAP_WHITE
}
/*-------------------------------------------------------------------*\
makeDummy
\*-------------------------------------------------------------------*/
void CBitmap::makeDummy()
{
static const uint8 bitmap[1024]= {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,
0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,
0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
makeDummyFromBitField(bitmap);
}
/*-------------------------------------------------------------------*\
makeDummy
\*-------------------------------------------------------------------*/
void CBitmap::makeNonPowerOf2Dummy()
{
static const uint8 bitmap[1024]= {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,
0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,
0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,
0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,
0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
};
makeDummyFromBitField(bitmap);
}
/*-------------------------------------------------------------------*\
makeDummyFromBitField
\*-------------------------------------------------------------------*/
void CBitmap::makeDummyFromBitField(const uint8 bitmap[1024])
{
PixelFormat = RGBA;
_MipMapCount = 1;
_Width= 32;
_Height= 32;
_Data[0].resize(_Width*_Height*sizeof(NLMISC::CRGBA));
for(sint m=1;m<MAX_MIPMAP;m++)
_Data[m].clear();
NLMISC::CRGBA *pix= (NLMISC::CRGBA*)(_Data[0].getPtr());
for(sint i=0;i<(sint)(_Width*_Height);i++)
{
if(bitmap[i])
pix[i].set(255,255,255,255);
else
pix[i].set(0x80,0x80,0x80,0x40);
}
}
/*-------------------------------------------------------------------*\
makeOpaque
\*-------------------------------------------------------------------*/
void CBitmap::makeOpaque()
{
if (_Width*_Height == 0) return;
uint pixelSize;
switch(PixelFormat)
{
case RGBA: pixelSize = 4; break;
case AlphaLuminance: pixelSize = 2; break;
case Alpha: pixelSize = 1; break;
default: return;
}
for(uint8 m = 0; m < _MipMapCount; ++m)
{
// get a pointer on original data
uint8 *data = _Data[m].getPtr();
// special case for only alpha values
if (pixelSize == 1)
{
memset(data, 255, _Data[m].size());
}
else
{
// end of data
uint8 *endData = data + _Data[m].size();
// first alpha
data += pixelSize - 1;
// replace all alpha values by 255
while(data < endData)
{
*data = 255;
data += pixelSize;
}
}
}
}
/*-------------------------------------------------------------------*\
isAlphaUniform
\*-------------------------------------------------------------------*/
bool CBitmap::isAlphaUniform(uint8 *alpha) const
{
uint32 size = _Data[0].size();
if (size == 0) return false;
uint pixelSize;
switch(PixelFormat)
{
// formats with alpha channel
case RGBA:
pixelSize = 4;
break;
case AlphaLuminance:
pixelSize = 2;
break;
case Alpha:
pixelSize = 1;
break;
// formats without alpha channel
case Luminance:
if (alpha) *alpha = 255;
return true;
default:
return false;
}
// get a pointer on original data
uint8 *data = (uint8*)_Data[0].getPtr();
uint8 *endData = data + size;
// first alpha
data += pixelSize - 1;
// first alpha value
uint8 value = *data;
// check if all alphas have the same value
while(data < endData && *data == value) data += pixelSize;
// texture can be converted if all alphas are 0 or 255
if (data >= endData)
{
// return the uniform value
if (alpha) *alpha = value;
return true;
}
return false;
}
/*-------------------------------------------------------------------*\
isGrayscale
\*-------------------------------------------------------------------*/
bool CBitmap::isGrayscale() const
{
// all grayscale formats or, al least, without color information
switch(PixelFormat)
{
case Luminance:
case AlphaLuminance:
case Alpha:
return true;
case RGBA:
break;
default:
// DXTC formats won't be managed at the moment
return false;
}
uint32 size = _Data[0].size();
if (size == 0) return false;
// get a pointer on original data
uint32 *data = (uint32*)_Data[0].getPtr();
uint32 *endData = (uint32*)((uint8*)data + size);
NLMISC::CRGBA *color = NULL;
// check if all alphas have the same value
while(data < endData)
{
color = (NLMISC::CRGBA*)data;
if (!color->isGray()) return false;
++data;
}
return true;
}
/*-------------------------------------------------------------------*\
readDDS
\*-------------------------------------------------------------------*/
uint8 CBitmap::readDDS(NLMISC::IStream &f, uint mipMapSkip)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
//------------------ Reading Header ------------------------
//-------------- reading entire header
uint32 size = 0;
f.serial(size); // size in Bytes of header(without "DDS")
uint32 * _DDSSurfaceDesc = new uint32[size];
_DDSSurfaceDesc[0]= size;
#ifdef NL_LITTLE_ENDIAN
f.serialBuffer((uint8*)(_DDSSurfaceDesc+1), size-4);
#else
for(uint i= 0; i<size/4 - 1; i++)
{
f.serial(_DDSSurfaceDesc[i+1]);
}
#endif
// flags determines which members of the header structure contain valid data
uint32 flags = _DDSSurfaceDesc[1];
//verify if file have linearsize set
if(!(flags & DDSD_LINEARSIZE))
{
nlwarning("A DDS doesn't have the flag DDSD_LINEARSIZE");
//delete [] _DDSSurfaceDesc;
//throw EDDSBadHeader();
}
//-------------- extracting and testing useful info
_Height = _DDSSurfaceDesc[2];
_Width = _DDSSurfaceDesc[3];
_MipMapCount= (uint8) _DDSSurfaceDesc[6];
// If no mipmap.
if(_MipMapCount==0)
_MipMapCount=1;
switch (_DDSSurfaceDesc[20])
{
case DXTC1HEADER:
PixelFormat=DXTC1;
break;
case DXTC3HEADER:
PixelFormat=DXTC3;
break;
case DXTC5HEADER:
PixelFormat=DXTC5;
break;
}
flags = _DDSSurfaceDesc[19]; //PixelFormat flags
/* ace: I changed this code because it's not a way to detect if DXTC1 has a alpha channel or not
There's no easy way to detect if the DXTC1 has an alpha channel or not, so, for now, we'll suppose
that all DXTC1 has alpha channel per default.
"There is no flag unfortunately, you need to read each block of DXT1 data, check if one of the colors
contains alpha, and check if that color is used in the data.
It's not that hard to write, but it IS a pain that it's the only way that I've found to check for alpha."
http://www.gamedev.net/community/forums/topic.asp?topic_id=177475
UPDATE: worst... on linux/opengl, it generates random alpha values
if we use alpha dxtc1 by default. So I only to that for windows
and leave the old test on linux
kervala: some used textures don't have an alpha channel and they are
(very) bad rendered with this fix so we have to deactivate it the for moment
*/
if(PixelFormat==DXTC1 && _DDSSurfaceDesc[21]>0) //AlphaBitDepth
{
PixelFormat = DXTC1Alpha;
}
if(PixelFormat!= DXTC1 && PixelFormat!= DXTC1Alpha && PixelFormat!= DXTC3 && PixelFormat!= DXTC5)
{
delete [] _DDSSurfaceDesc;
throw EDDSBadHeader();
}
// compute the min power of 2 between width and height
uint minSizeLevel= min(_Width, _Height);
minSizeLevel= getPowerOf2(minSizeLevel);
//------------- manage mipMapSkip
if(_MipMapCount>1 && mipMapSkip>0 && minSizeLevel>2)
{
// Keep at least the level where width and height are at least 4.
mipMapSkip= min(mipMapSkip, minSizeLevel-2);
// skip any mipmap
uint seekSize= 0;
while(mipMapSkip>0 && _MipMapCount>1)
{
// raise to next multiple of 4
uint32 wtmp= (_Width+3)&(~3);
uint32 htmp= (_Height+3)&(~3);
wtmp= max(wtmp, uint32(4));
htmp= max(htmp, uint32(4));
uint32 mipMapSz;
if(PixelFormat==DXTC1 || PixelFormat==DXTC1Alpha)
mipMapSz = wtmp*htmp/2;
else
mipMapSz = wtmp*htmp;
// add to how many to skip
seekSize+= mipMapSz;
// Size of final bitmap is reduced.
_Width>>=1;
_Height>>=1;
_MipMapCount--;
mipMapSkip--;
}
// skip data in file
if(seekSize>0)
{
if(!f.seek(seekSize, IStream::current))
{
delete [] _DDSSurfaceDesc;
throw ESeekFailed();
}
}
}
//------------- preload all the mipmaps (one serialBuffer() is faster)
uint32 w = _Width;
uint32 h = _Height;
uint32 totalSize= 0;
uint8 m;
for(m= 0; m<_MipMapCount; m++)
{
// raise to next multiple of 4
uint32 wtmp= (w+3)&(~3);
uint32 htmp= (h+3)&(~3);
wtmp= max(wtmp, uint32(4));
htmp= max(htmp, uint32(4));
uint32 mipMapSz;
if(PixelFormat==DXTC1 || PixelFormat==DXTC1Alpha)
mipMapSz = wtmp*htmp/2;
else
mipMapSz = wtmp*htmp;
_Data[m].resize(mipMapSz);
totalSize+= mipMapSz;
w = (w+1)/2;
h = (h+1)/2;
}
// Read all the data in one block.
vector<uint8> pixData;
pixData.resize(totalSize);
f.serialBuffer(&(*pixData.begin()), totalSize);
//------------- reading mipmap levels from pixData
uint32 pixIndex= 0;
for(m= 0; m<_MipMapCount; m++)
{
uint32 mipMapSz= _Data[m].size();
memcpy(_Data[m].getPtr(), &(pixData[pixIndex]), mipMapSz);
pixIndex+= mipMapSz;
}
//------------- End
delete [] _DDSSurfaceDesc;
switch(PixelFormat)
{
case DXTC1 : return 24;
case DXTC1Alpha : return 32;
case DXTC3 : return 32;
case DXTC5 : return 32;
default : break;
}
return 0;
}
/*-------------------------------------------------------------------*\
convertToDXTC5
\*-------------------------------------------------------------------*/
bool CBitmap::convertToDXTC5()
{
/* Yoyo: RGB encoding for DXTC1 and DXTC5/3 are actually different!!
DXTC3/5 don't rely on sign of color0>color1 to setup special encoding (ie use a special compression for Black)
Since this can arise if the src is DXTC1 , we can't simply compress it into DXTC5 without doing a
heavy compression...
(the inverse is false: DXTC5 to DXTC1 is possible, with maybe swap color0/color1 and bits).
*/
return false;
/* uint32 i,j;
if(PixelFormat!=DXTC1) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(2*_Data[m].size());
uint dstId= 0;
for(i=0; i<_Data[m].size(); i+=8)
{
//64 bits alpha
for(j=0; j<8; j++)
{
dataTmp[dstId++]= 255;
}
//64 bits RGB
for(j=0; j<8; j++)
{
dataTmp[dstId++]= _Data[m][i+j];
}
}
_Data[m] = dataTmp;
}
PixelFormat = DXTC5;
return true;
*/
}
/*-------------------------------------------------------------------*\
luminanceToRGBA()
\*-------------------------------------------------------------------*/
bool CBitmap::luminanceToRGBA()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()*4);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i++)
{
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= 255;
}
_Data[m] = dataTmp;
}
PixelFormat = RGBA;
return true;
}
/*-------------------------------------------------------------------*\
alphaToRGBA()
\*-------------------------------------------------------------------*/
bool CBitmap::alphaToRGBA()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()*4);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i++)
{
dataTmp[dstId++]= 255;
dataTmp[dstId++]= 255;
dataTmp[dstId++]= 255;
dataTmp[dstId++]= _Data[m][i];
}
_Data[m] = dataTmp;
}
PixelFormat = RGBA;
return true;
}
/*-------------------------------------------------------------------*\
alphaLuminanceToRGBA()
\*-------------------------------------------------------------------*/
bool CBitmap::alphaLuminanceToRGBA()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()*2);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i+=2)
{
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= _Data[m][i+1];
}
_Data[m] = dataTmp;
}
PixelFormat = RGBA;
return true;
}
/*-------------------------------------------------------------------*\
rgbaToAlphaLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::rgbaToAlphaLuminance()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()/2);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i+=4)
{
dataTmp[dstId++]= (_Data[m][i]*77 + _Data[m][i+1]*150 + _Data[m][i+2]*28)/255;
dataTmp[dstId++]= _Data[m][i+3];
}
NLMISC::contReset(_Data[m]);
_Data[m].resize(0);
_Data[m] = dataTmp;
}
PixelFormat = AlphaLuminance;
return true;
}
/*-------------------------------------------------------------------*\
luminanceToAlphaLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::luminanceToAlphaLuminance()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()*2);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i++)
{
dataTmp[dstId++]= _Data[m][i];
dataTmp[dstId++]= 255;
}
_Data[m] = dataTmp;
}
PixelFormat = AlphaLuminance;
return true;
}
/*-------------------------------------------------------------------*\
alphaToAlphaLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::alphaToAlphaLuminance()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()*2);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i++)
{
dataTmp[dstId++]= 0;
dataTmp[dstId++]= _Data[m][i];
}
_Data[m] = dataTmp;
}
PixelFormat = AlphaLuminance;
return true;
}
/*-------------------------------------------------------------------*\
rgbaToLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::rgbaToLuminance()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()/4);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i+=4)
{
dataTmp[dstId++]= (_Data[m][i]*77 + _Data[m][i+1]*150 + _Data[m][i+2]*28)/255;
}
NLMISC::contReset(_Data[m]);
_Data[m].resize(0);
_Data[m] = dataTmp;
}
PixelFormat = Luminance;
return true;
}
/*-------------------------------------------------------------------*\
alphaToLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::alphaToLuminance()
{
if(_Width*_Height == 0) return false;
PixelFormat = Luminance;
return true;
}
/*-------------------------------------------------------------------*\
alphaLuminanceToLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::alphaLuminanceToLuminance()
{
if (_Width*_Height == 0) return false;
for(uint8 m = 0; m<_MipMapCount; ++m)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()/2);
uint dstId= 0;
for(uint32 i=0; i<_Data[m].size(); i+=2)
{
dataTmp[dstId++]= _Data[m][i];
}
NLMISC::contReset(_Data[m]);
_Data[m].resize(0);
_Data[m] = dataTmp;
}
PixelFormat = Luminance;
return true;
}
/*-------------------------------------------------------------------*\
rgbaToAlpha
\*-------------------------------------------------------------------*/
bool CBitmap::rgbaToAlpha()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()/4);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i+=4)
{
dataTmp[dstId++]= _Data[m][i+3];
}
NLMISC::contReset(_Data[m]);
_Data[m].resize(0);
_Data[m] = dataTmp;
}
PixelFormat = Alpha;
return true;
}
/*-------------------------------------------------------------------*\
luminanceToAlpha
\*-------------------------------------------------------------------*/
bool CBitmap::luminanceToAlpha()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size());
uint dstId= 0;
for(i=0; i<_Data[m].size(); i++)
{
dataTmp[dstId++]= _Data[m][i];
}
_Data[m] = dataTmp;
}
PixelFormat = Alpha;
return true;
}
/*-------------------------------------------------------------------*\
alphaLuminanceToAlpha
\*-------------------------------------------------------------------*/
bool CBitmap::alphaLuminanceToAlpha()
{
uint32 i;
if(_Width*_Height == 0) return false;
for(uint8 m= 0; m<_MipMapCount; m++)
{
CObjectVector<uint8> dataTmp;
dataTmp.resize(_Data[m].size()/2);
uint dstId= 0;
for(i=0; i<_Data[m].size(); i+=2)
{
dataTmp[dstId++]= _Data[m][i+1];
}
NLMISC::contReset(_Data[m]);
_Data[m].resize(0);
_Data[m] = dataTmp;
}
PixelFormat = Alpha;
return true;
}
/*-------------------------------------------------------------------*\
convertToLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::convertToLuminance()
{
switch(PixelFormat)
{
case RGBA :
return rgbaToLuminance();
break;
case Luminance :
return true;
break;
case Alpha :
return alphaToLuminance();
break;
case AlphaLuminance :
return alphaLuminanceToLuminance();
break;
default:
break;
}
return false;
}
/*-------------------------------------------------------------------*\
convertToAlpha
\*-------------------------------------------------------------------*/
bool CBitmap::convertToAlpha()
{
switch(PixelFormat)
{
case RGBA :
return rgbaToAlpha();
break;
case Luminance :
return luminanceToAlpha();
break;
case Alpha :
return true;
break;
case AlphaLuminance :
return alphaLuminanceToAlpha();
break;
default:
break;
}
return false;
}
/*-------------------------------------------------------------------*\
convertToAlphaLuminance
\*-------------------------------------------------------------------*/
bool CBitmap::convertToAlphaLuminance()
{
switch(PixelFormat)
{
case RGBA :
return rgbaToAlphaLuminance();
break;
case Luminance :
return luminanceToAlphaLuminance();
break;
case Alpha :
return alphaToAlphaLuminance();
break;
case AlphaLuminance :
return true;
break;
default:
break;
}
return false;
}
/*-------------------------------------------------------------------*\
convertToRGBA
\*-------------------------------------------------------------------*/
bool CBitmap::convertToRGBA()
{
switch(PixelFormat)
{
case DXTC1 :
return decompressDXT1(false);
break;
case DXTC1Alpha :
return decompressDXT1(true);
break;
case DXTC3 :
return decompressDXT3();
break;
case DXTC5 :
return decompressDXT5();
break;
case Luminance :
return luminanceToRGBA();
break;
case Alpha :
return alphaToRGBA();
break;
case AlphaLuminance :
return alphaLuminanceToRGBA();
break;
case RGBA:
return true;
break;
default:
break;
}
return false;
}
/*-------------------------------------------------------------------*\
convertToType
\*-------------------------------------------------------------------*/
bool CBitmap::convertToType(CBitmap::TType type)
{
if(PixelFormat==type) return true;
switch(type)
{
case RGBA :
return convertToRGBA();
break;
case DXTC5 :
return convertToDXTC5();
break;
case Luminance :
return convertToLuminance();
break;
case Alpha :
return convertToAlpha();
break;
case AlphaLuminance :
return convertToAlphaLuminance();
break;
default:
break;
}
return false;
}
/*-------------------------------------------------------------------*\
decompressDXT1
\*-------------------------------------------------------------------*/
bool CBitmap::decompressDXT1(bool alpha)
{
uint32 i,j,k;
NLMISC::CRGBA c[4];
CObjectVector<uint8> dataTmp[MAX_MIPMAP];
uint32 width= _Width;
uint32 height= _Height;
for(uint8 m= 0; m<_MipMapCount; m++)
{
uint32 wtmp, htmp;
if(width<4)
wtmp = 4;
else
wtmp = width;
if(height < 4)
htmp = 4;
else
htmp = height;
uint32 mipMapSz = wtmp*htmp*4;
dataTmp[m].resize(mipMapSz);
if(dataTmp[m].size()<mipMapSz)
{
throw EAllocationFailure();
}
uint32 wBlockCount= wtmp/4;
for(i=0; i < _Data[m].size(); i+=8)
{
uint16 color0;
uint16 color1;
uint32 bits;
memcpy(&color0,&_Data[m][i],2);
memcpy(&color1,&_Data[m][i+2],2);
memcpy(&bits,&_Data[m][i+4],4);
uncompress(color0,c[0]);
uncompress(color1,c[1]);
if (alpha)
{
c[0].A= 0;
c[1].A= 0;
c[2].A= 0;
c[3].A= 0;
}
else
{
c[0].A= 255;
c[1].A= 255;
c[2].A= 255;
c[3].A= 255;
}
if(color0>color1)
{
c[2].blendFromui(c[0],c[1],85);
if(alpha) c[2].A= 255;
c[3].blendFromui(c[0],c[1],171);
if(alpha) c[3].A= 255;
}
else
{
c[2].blendFromui(c[0],c[1],128);
if(alpha) c[2].A= 255;
c[3].set(0,0,0,0);
}
// computing the 16 RGBA of the block
uint32 blockNum= i/8; //(64 bits)
// <previous blocks in above lines> * 4 (rows) * _Width (columns) + 4pix*4rgba*<same line previous blocks>
uint32 pixelsCount= 4*(blockNum/wBlockCount)*wtmp*4 + 4*4*(blockNum%wBlockCount);
for(j=0; j<4; j++)
{
for(k=0; k<4; k++)
{
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k]= c[bits&3].R;
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k+1]= c[bits&3].G;
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k+2]= c[bits&3].B;
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k+3]= c[bits&3].A;
bits>>=2;
}
}
}
// Copy result into the mipmap level.
if(wtmp==width && htmp==height)
{
// For mipmaps level >4 pixels.
_Data[m]= dataTmp[m];
}
else
{
// For last mipmaps, level <4 pixels.
_Data[m].resize(width*height*4);
CRGBA *src= (CRGBA*)&dataTmp[m][0];
CRGBA *dst= (CRGBA*)&_Data[m][0];
uint x,y;
for(y=0;y<height;y++)
{
for(x=0;x<width;x++)
dst[y*width+x]= src[y*wtmp+x];
}
}
// Next mipmap size.
width = (width+1)/2;
height = (height+1)/2;
}
PixelFormat = RGBA;
return true;
}
/*-------------------------------------------------------------------*\
decompressDXT3
\*-------------------------------------------------------------------*/
bool CBitmap::decompressDXT3()
{
uint32 i,j,k;
NLMISC::CRGBA c[4];
CObjectVector<uint8> dataTmp[MAX_MIPMAP];
uint32 width= _Width;
uint32 height= _Height;
for(uint8 m= 0; m<_MipMapCount; m++)
{
uint32 wtmp, htmp;
if(width<4)
wtmp = 4;
else
wtmp = width;
if(height < 4)
htmp = 4;
else
htmp = height;
uint32 mipMapSz = wtmp*htmp*4;
dataTmp[m].resize(mipMapSz);
if(dataTmp[m].size()<mipMapSz)
{
throw EAllocationFailure();
}
uint32 wBlockCount= wtmp/4;
for(i=0; i < _Data[m].size(); i+=16)
{
uint8 alpha[16];
uint64 alphatmp;
memcpy(&alphatmp,&_Data[m][i],8);
for(j=0; j<16; j++)
{
uint8 a= (uint8)(alphatmp&15);
// expand to 0-255.
alpha[j]= a+(a<<4);
alphatmp>>=4;
}
uint16 color0;
uint16 color1;
uint32 bits;
memcpy(&color0,&_Data[m][i+8],2);
memcpy(&color1,&_Data[m][i+10],2);
memcpy(&bits,&_Data[m][i+12],4);
uncompress(color0,c[0]);
uncompress(color1,c[1]);
// ignore color0>color1 for DXT3 and DXT5.
c[2].blendFromui(c[0],c[1],85);
c[3].blendFromui(c[0],c[1],171);
// computing the 16 RGBA of the block
uint32 blockNum= i/16; //(128 bits)
// <previous blocks in above lines> * 4 (rows) * wtmp (columns) + 4pix*4rgba*<same line previous blocks>
uint32 pixelsCount= 4*(blockNum/wBlockCount)*wtmp*4 + 4*4*(blockNum%wBlockCount);
for(j=0; j<4; j++)
{
for(k=0; k<4; k++)
{
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k]= c[bits&3].R;
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k+1]= c[bits&3].G;
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k+2]= c[bits&3].B;
dataTmp[m][pixelsCount + j*wtmp*4 + 4*k+3]= alpha[4*j+k];
bits>>=2;
}
}
}
// Copy result into the mipmap level.
if(wtmp==width && htmp==height)
{
// For mipmaps level >4 pixels.
_Data[m]= dataTmp[m];
}
else
{
// For last mipmaps, level <4 pixels.
_Data[m].resize(width*height*4);
CRGBA *src= (CRGBA*)&dataTmp[m][0];
CRGBA *dst= (CRGBA*)&_Data[m][0];
uint x,y;
for(y=0;y<height;y++)
{
for(x=0;x<width;x++)
dst[y*width+x]= src[y*wtmp+x];
}
}
// Next mipmap size.
width = (width+1)/2;
height = (height+1)/2;
}
PixelFormat = RGBA;
return true;
}
/*-------------------------------------------------------------------*\
decompressDXT5
\*-------------------------------------------------------------------*/
bool CBitmap::decompressDXT5()
{
uint32 i,j,k;
NLMISC::CRGBA c[4];
CObjectVector<uint8> dataTmp[MAX_MIPMAP];
uint32 width= _Width;
uint32 height= _Height;
for(uint8 m= 0; m<_MipMapCount; m++)
{
uint32 wtmp, htmp;
if(width<4)
wtmp = 4;
else
wtmp = width;
if(height < 4)
htmp = 4;
else
htmp = height;
uint32 mipMapSz = wtmp*htmp*4;
dataTmp[m].resize(mipMapSz);
if(dataTmp[m].size()<mipMapSz)
{
throw EAllocationFailure();
}
uint32 wBlockCount= wtmp/4;
for(i=0; i < _Data[m].size(); i+=16)
{
uint64 bitsAlpha;
memcpy(&bitsAlpha,&_Data[m][i],8);
bitsAlpha>>= 16;
uint32 alpha[8];
alpha[0]= _Data[m][i+0];
alpha[1]= _Data[m][i+1];
if(alpha[0]>alpha[1])
{
alpha[2]= blend(alpha[0], alpha[1], 219);
alpha[3]= blend(alpha[0], alpha[1], 183);
alpha[4]= blend(alpha[0], alpha[1], 146);
alpha[5]= blend(alpha[0], alpha[1], 110);
alpha[6]= blend(alpha[0], alpha[1], 73);
alpha[7]= blend(alpha[0], alpha[1], 37);
}
else
{
alpha[2]= blend(alpha[0], alpha[1], 204);
alpha[3]= blend(alpha[0], alpha[1], 154);
alpha[4]= blend(alpha[0], alpha[1], 102);
alpha[5]= blend(alpha[0], alpha[1], 51);
alpha[6]= 0;
alpha[7]= 255;
}
uint8 codeAlpha[16];
for(j=0; j<16; j++)
{
codeAlpha[j] = (uint8)(bitsAlpha & 7);
bitsAlpha>>=3;
}
uint16 color0;
uint16 color1;
uint32 bits;
memcpy(&color0,&_Data[m][i+8],2);
memcpy(&color1,&_Data[m][i+10],2);
memcpy(&bits,&_Data[m][i+12],4);
uncompress(color0,c[0]);
uncompress(color1,c[1]);
// ignore color0>color1 for DXT3 and DXT5.
c[2].blendFromui(c[0],c[1],85);
c[3].blendFromui(c[0],c[1],171);
// computing the 16 RGBA of the block
uint32 blockNum= i/16; //(128 bits)
// <previous blocks in above lines> * 4 (rows) * wtmp (columns) + 4pix*<same line previous blocks>
uint32 pixelsCount= (blockNum/wBlockCount)*wtmp*4 + 4*(blockNum%wBlockCount);
// *sizeof(RGBA)
pixelsCount*=4;
for(j=0; j<4; j++)
{
for(k=0; k<4; k++)
{
dataTmp[m][pixelsCount + (j*wtmp+k)*4 +0]= c[bits&3].R;
dataTmp[m][pixelsCount + (j*wtmp+k)*4 +1]= c[bits&3].G;
dataTmp[m][pixelsCount + (j*wtmp+k)*4 +2]= c[bits&3].B;
dataTmp[m][pixelsCount + (j*wtmp+k)*4 +3]= (uint8) alpha[codeAlpha[4*j+k]];
bits>>=2;
}
}
}
// Copy result into the mipmap level.
if(wtmp==width && htmp==height)
{
// For mipmaps level >4 pixels.
_Data[m]= dataTmp[m];
}
else
{
// For last mipmaps, level <4 pixels.
_Data[m].resize(width*height*4);
CRGBA *src= (CRGBA*)&dataTmp[m][0];
CRGBA *dst= (CRGBA*)&_Data[m][0];
uint x,y;
for(y=0;y<height;y++)
{
for(x=0;x<width;x++)
dst[y*width+x]= src[y*wtmp+x];
}
}
// Next mipmap size.
width = (width+1)/2;
height = (height+1)/2;
}
PixelFormat = RGBA;
return true;
}
/*-------------------------------------------------------------------*\
blend
\*-------------------------------------------------------------------*/
uint32 CBitmap::blend(uint32 &n0, uint32 &n1, uint32 coef0)
{
int a0 = coef0;
int a1 = 256-a0;
return ((n0*a0 + n1*a1) >>8);
}
/*-------------------------------------------------------------------*\
uncompress
\*-------------------------------------------------------------------*/
inline void CBitmap::uncompress(uint16 color, NLMISC::CRGBA &r)
{
r.A= 0;
r.R= ((color>>11)&31) << 3; r.R+= r.R>>5;
r.G= ((color>>5)&63) << 2; r.G+= r.G>>6;
r.B= ((color)&31) << 3; r.B+= r.B>>5;
}
/*-------------------------------------------------------------------*\
getWidth
\*-------------------------------------------------------------------*/
uint32 CBitmap::getWidth(uint32 mipMap) const
{
if(mipMap==0) return _Width;
uint32 w = _Width;
uint32 h = _Height;
uint32 m = 0;
do
{
m++;
w = (w+1)/2;
h = (h+1)/2;
if(m==mipMap) return w;
}
while(w!=1 || h!=1);
return 0;
}
/*-------------------------------------------------------------------*\
getHeight
\*-------------------------------------------------------------------*/
uint32 CBitmap::getHeight(uint32 mipMap) const
{
if(mipMap==0) return _Height;
uint32 w = _Width;
uint32 h = _Height;
uint32 m = 0;
do
{
m++;
w = (w+1)/2;
h = (h+1)/2;
if(m==mipMap) return h;
}
while(w!=1 || h!=1);
return 0;
}
/*-------------------------------------------------------------------*\
getSize
\*-------------------------------------------------------------------*/
uint32 CBitmap::getSize(uint32 numMipMap) const
{
return getHeight(numMipMap)*getWidth(numMipMap);
}
/*-------------------------------------------------------------------*\
buildMipMaps
\*-------------------------------------------------------------------*/
void CBitmap::buildMipMaps()
{
uint32 i,j;
if(PixelFormat!=RGBA) return;
if(_MipMapCount!=1) return;
if(!NLMISC::isPowerOf2(_Width)) return;
if(!NLMISC::isPowerOf2(_Height)) return;
uint32 w = _Width;
uint32 h = _Height;
while(w>1 || h>1)
{
uint32 precw = w;
uint32 prech = h;
w = (w+1)/2;
h = (h+1)/2;
uint32 mulw= precw/w;
uint32 mulh= prech/h;
_Data[_MipMapCount].resize(w*h*4);
NLMISC::CRGBA *pRgba = (NLMISC::CRGBA*)&_Data[_MipMapCount][0];
NLMISC::CRGBA *pRgbaPrev = (NLMISC::CRGBA*)&_Data[_MipMapCount-1][0];
for(i=0; i<h; i++)
{
sint i0= mulh*i;
sint i1= mulh*i+1;
if(mulh==1)
i1=i0;
i0*=precw;
i1*=precw;
for(j=0; j<w; j++)
{
sint j0= mulw*j;
sint j1= mulw*j+1;
if(mulw==1)
j1=j0;
CRGBA &c0= pRgbaPrev[i0+j0];
CRGBA &c1= pRgbaPrev[i0+j1];
CRGBA &c2= pRgbaPrev[i1+j0];
CRGBA &c3= pRgbaPrev[i1+j1];
pRgba[i*w + j].R = (c0.R +
c1.R +
c2.R +
c3.R + 2 ) /4;
pRgba[i*w + j].G = (c0.G +
c1.G +
c2.G +
c3.G + 2 ) /4;
pRgba[i*w + j].B = (c0.B +
c1.B +
c2.B +
c3.B + 2 ) /4;
pRgba[i*w + j].A = (c0.A +
c1.A +
c2.A +
c3.A + 2 ) /4;
}
}
_MipMapCount++;
}
}
/*-------------------------------------------------------------------*\
computeNeededMipMapCount
\*-------------------------------------------------------------------*/
uint32 CBitmap::computeNeededMipMapCount() const
{
if(_MipMapCount == 0) return 0;
if(!NLMISC::isPowerOf2(_Width)) return 1;
if(!NLMISC::isPowerOf2(_Height)) return 1;
uint32 mipMapCount = 1;
uint32 w = _Width;
uint32 h = _Height;
while(w>1 || h>1)
{
w = (w+1)/2;
h = (h+1)/2;
++mipMapCount;
}
return mipMapCount;
}
/*-------------------------------------------------------------------*\
releaseMipMaps
\*-------------------------------------------------------------------*/
void CBitmap::releaseMipMaps()
{
if(_MipMapCount<=1) return;
_MipMapCount=1;
for(sint i=1;i<MAX_MIPMAP;i++)
{
NLMISC::contReset(_Data[i]);
}
}
/*-------------------------------------------------------------------*\
resample
\*-------------------------------------------------------------------*/
void CBitmap::resample(sint32 nNewWidth, sint32 nNewHeight)
{
nlassert(PixelFormat == RGBA || PixelFormat == Luminance);
bool needRebuild = false;
// Deleting mipmaps
//logResample("Resample: 10");
if(_MipMapCount>1)
needRebuild = true;
releaseMipMaps();
//logResample("Resample: 20");
if(nNewWidth==0 || nNewHeight==0)
{
_Width = _Height = 0;
//logResample("Resample: 25");
return;
}
//logResample("Resample: 30");
CObjectVector<uint8> pDestui;
if (PixelFormat == RGBA)
{
pDestui.resize(nNewWidth*nNewHeight*4);
//logResample("Resample: 40");
NLMISC::CRGBA *pDestRgba = (NLMISC::CRGBA*)&pDestui[0];
//logResample("Resample: 50");
resamplePicture32 ((NLMISC::CRGBA*)&_Data[0][0], pDestRgba, _Width, _Height, nNewWidth, nNewHeight);
//logResample("Resample: 60");
}
else if (PixelFormat == Luminance)
{
pDestui.resize(nNewWidth*nNewHeight);
//logResample("Resample: 40");
uint8 *pDestGray = &pDestui[0];
//logResample("Resample: 50");
resamplePicture8 (&_Data[0][0], pDestGray, _Width, _Height, nNewWidth, nNewHeight);
//logResample("Resample: 60");
}
NLMISC::contReset(_Data[0]); // free memory
//logResample("Resample: 70");
_Data[0] = pDestui;
//logResample("Resample: 80");
_Width= nNewWidth;
_Height= nNewHeight;
// Rebuilding mipmaps
//logResample("Resample: 90");
if(needRebuild)
{
buildMipMaps();
//logResample("Resample: 95");
}
//logResample("Resample: 100");
}
/*-------------------------------------------------------------------*\
resize
\*-------------------------------------------------------------------*/
void CBitmap::resize (sint32 nNewWidth, sint32 nNewHeight, TType newType, bool resetTo0)
{
// Deleting mipmaps
releaseMipMaps();
// Change type of bitmap ?
if (newType!=DonTKnow)
PixelFormat=newType;
_Width = nNewWidth;
_Height = nNewHeight;
// resize the level 0 only.
resizeMipMap(0, nNewWidth, nNewHeight, resetTo0);
}
/*-------------------------------------------------------------------*\
resizeMipMap
\*-------------------------------------------------------------------*/
void CBitmap::resizeMipMap (uint32 numMipMap, sint32 nNewWidth, sint32 nNewHeight, bool resetTo0)
{
nlassert(numMipMap<MAX_MIPMAP);
// free memory
NLMISC::contReset(_Data[numMipMap]);
// DXTC compressed??
//bool isDXTC= PixelFormat==DXTC1 || PixelFormat==DXTC1Alpha || PixelFormat==DXTC3 || PixelFormat==DXTC5;
// if yes, must round up width and height to 4, for allocation
nNewWidth= 4*((nNewWidth+3)/4);
nNewHeight= 4*((nNewHeight+3)/4);
// resize the buffer
_Data[numMipMap].resize (((uint32)(nNewWidth*nNewHeight)*bitPerPixels[PixelFormat])/8);
// Fill 0?
if( resetTo0 )
_Data[numMipMap].fill(0);
}
/*-------------------------------------------------------------------*\
reset
\*-------------------------------------------------------------------*/
void CBitmap::setMipMapCount(uint32 mmc)
{
_MipMapCount= uint8(mmc);
}
/*-------------------------------------------------------------------*\
reset
\*-------------------------------------------------------------------*/
void CBitmap::reset(TType type)
{
for(uint i=0; i<_MipMapCount; i++)
{
NLMISC::contReset(_Data[i]);
_Data[i].resize(0);
}
_Width = _Height = 0;
_MipMapCount= 1;
// Change pixel format
PixelFormat=type;
}
/*-------------------------------------------------------------------*\
resamplePicture32
\*-------------------------------------------------------------------*/
void CBitmap::resamplePicture32 (const NLMISC::CRGBA *pSrc, NLMISC::CRGBA *pDest,
sint32 nSrcWidth, sint32 nSrcHeight,
sint32 nDestWidth, sint32 nDestHeight)
{
//logResample("RP32: 0 pSrc=%p pDest=%p, Src=%d x %d Dest=%d x %d", pSrc, pDest, nSrcWidth, nSrcHeight, nDestWidth, nDestHeight);
if ((nSrcWidth<=0)||(nSrcHeight<=0)||(nDestHeight<=0)||(nDestHeight<=0))
return;
// If we're reducing it by 2, call the fast resample
if (((nSrcHeight / 2) == nDestHeight) && ((nSrcHeight % 2) == 0) &&
((nSrcWidth / 2) == nDestWidth) && ((nSrcWidth % 2) == 0))
{
resamplePicture32Fast(pSrc, pDest, nSrcWidth, nSrcHeight, nDestWidth, nDestHeight);
return;
}
bool bXMag=(nDestWidth>=nSrcWidth);
bool bYMag=(nDestHeight>=nSrcHeight);
bool bXEq=(nDestWidth==nSrcWidth);
bool bYEq=(nDestHeight==nSrcHeight);
std::vector<NLMISC::CRGBAF> pIterm (nDestWidth*nSrcHeight);
if (bXMag)
{
float fXdelta=(float)(nSrcWidth)/(float)(nDestWidth);
NLMISC::CRGBAF *pItermPtr=&*pIterm.begin();
sint32 nY;
for (nY=0; nY<nSrcHeight; nY++)
{
const NLMISC::CRGBA *pSrcLine=pSrc;
float fX=0.f;
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
float fVirgule=fX-(float)floor(fX);
nlassert (fVirgule>=0.f);
NLMISC::CRGBAF vColor;
if (fVirgule>=0.5f)
{
if (fX<(float)(nSrcWidth-1))
{
NLMISC::CRGBAF vColor1 (pSrcLine[(sint32)floor(fX)]);
NLMISC::CRGBAF vColor2 (pSrcLine[(sint32)floor(fX)+1]);
vColor=vColor1*(1.5f-fVirgule)+vColor2*(fVirgule-0.5f);
}
else
vColor=NLMISC::CRGBAF (pSrcLine[(sint32)floor(fX)]);
}
else
{
if (fX>=1.f)
{
NLMISC::CRGBAF vColor1 (pSrcLine[(sint32)floor(fX)]);
NLMISC::CRGBAF vColor2 (pSrcLine[(sint32)floor(fX)-1]);
vColor=vColor1*(0.5f+fVirgule)+vColor2*(0.5f-fVirgule);
}
else
vColor=NLMISC::CRGBAF (pSrcLine[(sint32)floor(fX)]);
}
*(pItermPtr++)=vColor;
fX+=fXdelta;
}
pSrc+=nSrcWidth;
}
}
else if (bXEq)
{
NLMISC::CRGBAF *pItermPtr=&*pIterm.begin();
for (sint32 nY=0; nY<nSrcHeight; nY++)
{
const NLMISC::CRGBA *pSrcLine=pSrc;
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
*(pItermPtr++)=NLMISC::CRGBAF (pSrcLine[nX]);
pSrc+=nSrcWidth;
}
}
else
{
double fXdelta=(double)(nSrcWidth)/(double)(nDestWidth);
nlassert (fXdelta>1.f);
NLMISC::CRGBAF *pItermPtr=&*pIterm.begin();
sint32 nY;
for (nY=0; nY<nSrcHeight; nY++)
{
const NLMISC::CRGBA *pSrcLine=pSrc;
double fX=0.f;
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
NLMISC::CRGBAF vColor (0.f, 0.f, 0.f, 0.f);
double fFinal=fX+fXdelta;
while ((fX<fFinal)&&((sint32)fX!=nSrcWidth))
{
double fNext=(double)floor (fX)+1.f;
if (fNext>fFinal)
fNext=fFinal;
vColor+=((float)(fNext-fX))*NLMISC::CRGBAF (pSrcLine[(sint32)floor(fX)]);
fX=fNext;
}
fX = fFinal; // ensure fX == fFinal
vColor/=(float)fXdelta;
*(pItermPtr++)=vColor;
}
pSrc+=nSrcWidth;
}
}
if (bYMag)
{
double fYdelta=(double)(nSrcHeight)/(double)(nDestHeight);
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
double fY=0.f;
sint32 nY;
for (nY=0; nY<nDestHeight; nY++)
{
double fVirgule=fY-(double)floor(fY);
nlassert (fVirgule>=0.f);
NLMISC::CRGBAF vColor;
if (fVirgule>=0.5f)
{
if (fY<(double)(nSrcHeight-1))
{
NLMISC::CRGBAF vColor1=pIterm[((sint32)floor(fY))*nDestWidth+nX];
NLMISC::CRGBAF vColor2=pIterm[(((sint32)floor(fY))+1)*nDestWidth+nX];
vColor=vColor1*(1.5f-(float)fVirgule)+vColor2*((float)fVirgule-0.5f);
}
else
vColor=pIterm[((sint32)floor(fY))*nDestWidth+nX];
}
else
{
if (fY>=1.f)
{
NLMISC::CRGBAF vColor1=pIterm[((sint32)floor(fY))*nDestWidth+nX];
NLMISC::CRGBAF vColor2=pIterm[(((sint32)floor(fY))-1)*nDestWidth+nX];
vColor=vColor1*(0.5f+(float)fVirgule)+vColor2*(0.5f-(float)fVirgule);
}
else
vColor=pIterm[((sint32)floor(fY))*nDestWidth+nX];
}
pDest[nX+nY*nDestWidth]=vColor;
fY+=fYdelta;
}
}
}
else if (bYEq)
{
for (sint32 nX=0; nX<nDestWidth; nX++)
{
sint32 nY;
for (nY=0; nY<nDestHeight; nY++)
{
pDest[nX+nY*nDestWidth]=pIterm[nY*nDestWidth+nX];
}
}
}
else
{
double fYdelta=(double)(nSrcHeight)/(double)(nDestHeight);
nlassert (fYdelta>1.f);
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
double fY=0.f;
sint32 nY;
for (nY=0; nY<nDestHeight; nY++)
{
NLMISC::CRGBAF vColor (0.f, 0.f, 0.f, 0.f);
double fFinal=fY+fYdelta;
while ((fY<fFinal)&&((sint32)fY!=nSrcHeight))
{
double fNext=(double)floor (fY)+1.f;
if (fNext>fFinal)
fNext=fFinal;
vColor+=((float)(fNext-fY))*pIterm[((sint32)floor(fY))*nDestWidth+nX];
fY=fNext;
}
vColor/=(float)fYdelta;
pDest[nX+nY*nDestWidth]=vColor;
}
}
}
}
/*-------------------------------------------------------------------*\
resamplePicture32Fast
\*-------------------------------------------------------------------*/
void CBitmap::resamplePicture32Fast (const NLMISC::CRGBA *pSrc, NLMISC::CRGBA *pDest,
sint32 nSrcWidth, sint32 nSrcHeight,
sint32 nDestWidth, sint32 nDestHeight)
{
// the image is divided by two : 1 pixel in dest = 4 pixels in src
// the resulting pixel in dest is an average of the four pixels in src
nlassert(nSrcWidth % 2 == 0);
nlassert(nSrcHeight % 2 == 0);
nlassert(nSrcWidth / 2 == nDestWidth);
nlassert(nSrcHeight / 2 == nDestHeight);
sint32 x, y, twoX, twoSrcWidthByY;
for (y=0 ; y<nDestHeight ; y++)
{
twoSrcWidthByY = 2*nSrcWidth*y;
for (x=0 ; x<nDestWidth ; x++)
{
twoX = 2*x;
pDest[x+y*nDestWidth].avg4( pSrc[twoX + twoSrcWidthByY ],
pSrc[twoX + twoSrcWidthByY + nSrcWidth ],
pSrc[twoX+1 + twoSrcWidthByY ],
pSrc[twoX+1 + twoSrcWidthByY + nSrcWidth ]);
}
}
}
/*-------------------------------------------------------------------*\
resamplePicture32
\*-------------------------------------------------------------------*/
void CBitmap::resamplePicture8 (const uint8 *pSrc, uint8 *pDest,
sint32 nSrcWidth, sint32 nSrcHeight,
sint32 nDestWidth, sint32 nDestHeight)
{
//logResample("RP8: 0 pSrc=%p pDest=%p, Src=%d x %d Dest=%d x %d", pSrc, pDest, nSrcWidth, nSrcHeight, nDestWidth, nDestHeight);
if ((nSrcWidth<=0)||(nSrcHeight<=0)||(nDestHeight<=0)||(nDestHeight<=0))
return;
// If we're reducing it by 2, call the fast resample
if (((nSrcHeight / 2) == nDestHeight) && ((nSrcHeight % 2) == 0) &&
((nSrcWidth / 2) == nDestWidth) && ((nSrcWidth % 2) == 0))
{
resamplePicture8Fast(pSrc, pDest, nSrcWidth, nSrcHeight, nDestWidth, nDestHeight);
return;
}
bool bXMag=(nDestWidth>=nSrcWidth);
bool bYMag=(nDestHeight>=nSrcHeight);
bool bXEq=(nDestWidth==nSrcWidth);
bool bYEq=(nDestHeight==nSrcHeight);
std::vector<float> pIterm (nDestWidth*nSrcHeight);
if (bXMag)
{
float fXdelta=(float)(nSrcWidth)/(float)(nDestWidth);
float *pItermPtr=&*pIterm.begin();
sint32 nY;
for (nY=0; nY<nSrcHeight; nY++)
{
const uint8 *pSrcLine=pSrc;
float fX=0.f;
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
float fVirgule=fX-(float)floor(fX);
nlassert (fVirgule>=0.f);
float vColor;
if (fVirgule>=0.5f)
{
if (fX<(float)(nSrcWidth-1))
{
float vColor1 (pSrcLine[(sint32)floor(fX)]);
float vColor2 (pSrcLine[(sint32)floor(fX)+1]);
vColor=vColor1*(1.5f-fVirgule)+vColor2*(fVirgule-0.5f);
}
else
vColor = float(pSrcLine[(sint32)floor(fX)]);
}
else
{
if (fX>=1.f)
{
float vColor1 (pSrcLine[(sint32)floor(fX)]);
float vColor2 (pSrcLine[(sint32)floor(fX)-1]);
vColor = vColor1*(0.5f+fVirgule)+vColor2*(0.5f-fVirgule);
}
else
vColor = float (pSrcLine[(sint32)floor(fX)]);
}
*(pItermPtr++)=vColor;
fX+=fXdelta;
}
pSrc+=nSrcWidth;
}
}
else if (bXEq)
{
float *pItermPtr=&*pIterm.begin();
for (sint32 nY=0; nY<nSrcHeight; nY++)
{
const uint8 *pSrcLine=pSrc;
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
*(pItermPtr++) = float (pSrcLine[nX]);
pSrc+=nSrcWidth;
}
}
else
{
double fXdelta=(double)(nSrcWidth)/(double)(nDestWidth);
nlassert (fXdelta>1.f);
float *pItermPtr=&*pIterm.begin();
sint32 nY;
for (nY=0; nY<nSrcHeight; nY++)
{
const uint8 *pSrcLine=pSrc;
double fX=0.f;
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
float vColor = 0.f;
double fFinal=fX+fXdelta;
while ((fX<fFinal)&&((sint32)fX!=nSrcWidth))
{
double fNext=(double)floor (fX)+1.f;
if (fNext>fFinal)
fNext=fFinal;
vColor+=((float)(fNext-fX))* float (pSrcLine[(sint32)floor(fX)]);
fX=fNext;
}
fX = fFinal; // ensure fX == fFinal
vColor/=(float)fXdelta;
*(pItermPtr++)=vColor;
}
pSrc+=nSrcWidth;
}
}
if (bYMag)
{
double fYdelta=(double)(nSrcHeight)/(double)(nDestHeight);
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
double fY=0.f;
sint32 nY;
for (nY=0; nY<nDestHeight; nY++)
{
double fVirgule=fY-(double)floor(fY);
nlassert (fVirgule>=0.f);
float vColor;
if (fVirgule>=0.5f)
{
if (fY<(double)(nSrcHeight-1))
{
float vColor1=pIterm[((sint32)floor(fY))*nDestWidth+nX];
float vColor2=pIterm[(((sint32)floor(fY))+1)*nDestWidth+nX];
vColor=vColor1*(1.5f-(float)fVirgule)+vColor2*((float)fVirgule-0.5f);
}
else
vColor=pIterm[((sint32)floor(fY))*nDestWidth+nX];
}
else
{
if (fY>=1.f)
{
float vColor1=pIterm[((sint32)floor(fY))*nDestWidth+nX];
float vColor2=pIterm[(((sint32)floor(fY))-1)*nDestWidth+nX];
vColor=vColor1*(0.5f+(float)fVirgule)+vColor2*(0.5f-(float)fVirgule);
}
else
vColor=pIterm[((sint32)floor(fY))*nDestWidth+nX];
}
pDest[nX+nY*nDestWidth]=vColor;
fY+=fYdelta;
}
}
}
else if (bYEq)
{
for (sint32 nX=0; nX<nDestWidth; nX++)
{
sint32 nY;
for (nY=0; nY<nDestHeight; nY++)
{
pDest[nX+nY*nDestWidth]=pIterm[nY*nDestWidth+nX];
}
}
}
else
{
double fYdelta=(double)(nSrcHeight)/(double)(nDestHeight);
nlassert (fYdelta>1.f);
sint32 nX;
for (nX=0; nX<nDestWidth; nX++)
{
double fY=0.f;
sint32 nY;
for (nY=0; nY<nDestHeight; nY++)
{
float vColor = 0.f;
double fFinal=fY+fYdelta;
while ((fY<fFinal)&&((sint32)fY!=nSrcHeight))
{
double fNext=(double)floor (fY)+1.f;
if (fNext>fFinal)
fNext=fFinal;
vColor+=((float)(fNext-fY))*pIterm[((sint32)floor(fY))*nDestWidth+nX];
fY=fNext;
}
vColor/=(float)fYdelta;
pDest[nX+nY*nDestWidth]=vColor;
}
}
}
}
/*-------------------------------------------------------------------*\
resamplePicture8Fast
\*-------------------------------------------------------------------*/
void CBitmap::resamplePicture8Fast (const uint8 *pSrc, uint8 *pDest,
sint32 nSrcWidth, sint32 nSrcHeight,
sint32 nDestWidth, sint32 nDestHeight)
{
// the image is divided by two : 1 pixel in dest = 4 pixels in src
// the resulting pixel in dest is an average of the four pixels in src
nlassert(nSrcWidth % 2 == 0);
nlassert(nSrcHeight % 2 == 0);
nlassert(nSrcWidth / 2 == nDestWidth);
nlassert(nSrcHeight / 2 == nDestHeight);
sint32 x, y, twoX, twoSrcWidthByY;
for (y=0 ; y<nDestHeight ; y++)
{
twoSrcWidthByY = 2*nSrcWidth*y;
for (x=0 ; x<nDestWidth ; x++)
{
twoX = 2*x;
pDest[x+y*nDestWidth] = (
(uint)pSrc[twoX + twoSrcWidthByY ]+
(uint)pSrc[twoX + twoSrcWidthByY + nSrcWidth ]+
(uint)pSrc[twoX+1 + twoSrcWidthByY ]+
(uint)pSrc[twoX+1 + twoSrcWidthByY + nSrcWidth ]+1)>>2;
}
}
}
/*-------------------------------------------------------------------*\
readTGA
\*-------------------------------------------------------------------*/
uint8 CBitmap::readTGA( NLMISC::IStream &f)
{
/* ***********************************************
* WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
* It can be loaded/called through CAsyncFileManager for instance
* ***********************************************/
if(!f.isReading()) return 0;
uint32 x,y;
sint32 slsize;
uint8 *scanline;
uint8 r,g,b;
sint32 i,j,k;
// TGA file header fields
uint8 lengthID;
uint8 cMapType;
uint8 imageType;
uint16 origin;
uint16 length;
uint8 depth;
uint16 xOrg;
uint16 yOrg;
uint16 width;
uint16 height;
uint8 imageDepth;
uint8 desc;
// Determining whether file is in Original or New TGA format
uint32 extAreaOffset;
uint32 devDirectoryOffset;
char signature[16];
f.seek (0, f.end);
if (f.getPos() >= 26)
{
f.seek (-26, f.end);
f.serial(extAreaOffset);
f.serial(devDirectoryOffset);
for(i=0; i<16; i++)
{
f.serial(signature[i]);
}
}
// Reading TGA file header
f.seek (0, f.begin);
f.serial(lengthID);
f.serial(cMapType);
f.serial(imageType);
f.serial(origin);
f.serial(length);
f.serial(depth);
f.serial(xOrg);
f.serial(yOrg);
f.serial(width);
f.serial(height);
f.serial(imageDepth);
f.serial(desc);
if(cMapType!=0)
{
nlinfo("readTga : color-map not supported");
}
if(lengthID>0)
{
uint8 dummy;
for(i=0; i<lengthID; i++)
f.serial(dummy);
}
// Reading TGA image data
_Width = width;
_Height = height;
switch(imageType)
{
// Uncompressed RGB or RGBA
case 2:
{
_Data[0].resize(_Width*_Height*4);
uint8 upSideDown = ((desc & (1 << 5))==0);
slsize = _Width * imageDepth / 8;
scanline = new uint8[slsize];
if(!scanline)
{
throw EAllocationFailure();
}
for(y=0; y<_Height;y++)
{
// Serial buffer: more efficient way to load.
f.serialBuffer (scanline, slsize);
if(imageDepth==24 || imageDepth==32)
{
sint32 mult = 3;
if(imageDepth==16)
{
mult = 2;
}
if(imageDepth==32)
{
mult = 4;
}
if(imageDepth!=16)
{
for(x=0; x<_Width; x++)
{
// RGB(A)
r = scanline[x*mult+0];
g = scanline[x*mult+1];
b = scanline[x*mult+2];
// Switching to BGR(A)
scanline[x*mult+0] = b;
scanline[x*mult+1] = g;
scanline[x*mult+2] = r;
}
}
}
k=0;
for(i=0; i<width; i++)
{
if(upSideDown)
{
if(imageDepth==16)
{
uint16 toto = (uint16)scanline[k++];
toto |= scanline[k++]<<8;
uint _r = toto>>10;
uint _g = (toto>>5)&0x1f;
uint _b = toto&0x1f;
_Data[0][(height-y-1)*width*4 + 4*i] = uint8((_r<<3) | (_r>>2));
_Data[0][(height-y-1)*width*4 + 4*i + 1] = uint8((_g<<3) | (_g>>2));
_Data[0][(height-y-1)*width*4 + 4*i + 2] = uint8((_b<<3) | (_b>>2));
_Data[0][(height-y-1)*width*4 + 4*i + 3] = 255;
}
else
{
_Data[0][(height-y-1)*width*4 + 4*i] = scanline[k++];
_Data[0][(height-y-1)*width*4 + 4*i + 1] = scanline[k++];
_Data[0][(height-y-1)*width*4 + 4*i + 2] = scanline[k++];
if(imageDepth==32)
_Data[0][(height-y-1)*width*4 + 4*i + 3] = scanline[k++];
else
_Data[0][(height-y-1)*width*4 + 4*i + 3] = 255;
}
}
else
{
if(imageDepth==16)
{
uint16 toto = (uint16)scanline[k++];
toto |= scanline[k++]<<8;
int _r = toto>>10;
int _g = toto&(0x3e0)>>5;
int _b = toto&0x1f;
_Data[0][y*width*4 + 4*i] = uint8((_r<<3) | (_r>>2));
_Data[0][y*width*4 + 4*i + 1] = uint8((_g<<3) | (_g>>2));
_Data[0][y*width*4 + 4*i + 2] = uint8((_b<<3) | (_b>>2));
_Data[0][y*width*4 + 4*i + 3] = 255;
}
else
{
_Data[0][y*width*4 + 4*i] = scanline[k++];
_Data[0][y*width*4 + 4*i + 1] = scanline[k++];
_Data[0][y*width*4 + 4*i + 2] = scanline[k++];
if(imageDepth==32)
_Data[0][y*width*4 + 4*i + 3] = scanline[k++];
else
_Data[0][y*width*4 + 4*i + 3] = 255;
}
}
}
}
PixelFormat = RGBA;
delete []scanline;
};
break;
// Uncompressed Grayscale bitmap
case 3:
{
_Data[0].resize(_Width*_Height);
uint8 upSideDown = ((desc & (1 << 5))==0);
slsize = _Width;
scanline = new uint8[slsize];
if(!scanline)
{
throw EAllocationFailure();
}
for(y=0; y<_Height;y++)
{
// Serial buffer: more efficient way to load.
f.serialBuffer (scanline, slsize);
k=0;
for(i=0; i<width; i++)
{
if(upSideDown)
_Data[0][(height-y-1)*width + i] = scanline[k++];
else
_Data[0][y*width + i] = scanline[k++];
}
}
PixelFormat = _LoadGrayscaleAsAlpha?Alpha:Luminance;
delete []scanline;
};
break;
// Compressed RGB or RGBA
case 10:
{
uint8 packet;
uint8 pixel[4] = {0};
uint32 imageSize = width*height;
uint32 readSize = 0;
uint8 upSideDown = ((desc & (1 << 5))==0);
_Data[0].resize(_Width*_Height*4);
uint dstId= 0;
while(readSize < imageSize)
{
f.serial(packet);
if((packet & 0x80) > 0) // packet RLE
{
for(i=0; i<imageDepth/8; i++)
{
f.serial(pixel[i]);
}
for (i=0; i < (packet & 0x7F) + 1; i++)
{
_Data[0][dstId++]= pixel[2];
_Data[0][dstId++]= pixel[1];
_Data[0][dstId++]= pixel[0];
_Data[0][dstId++]= pixel[3];
}
}
else // packet Raw
{
for(i=0; i<((packet & 0x7F) + 1); i++)
{
for(j=0; j<imageDepth/8; j++)
{
f.serial(pixel[j]);
}
_Data[0][dstId++]= pixel[2];
_Data[0][dstId++]= pixel[1];
_Data[0][dstId++]= pixel[0];
_Data[0][dstId++]= pixel[3];
}
}
readSize += (packet & 0x7F) + 1;
}
PixelFormat = RGBA;
if (upSideDown) flipV();
};
break;
// Compressed Grayscale bitmap (not tested)
case 11:
{
uint8 packet;
uint8 pixel[4];
uint32 imageSize = width*height;
uint32 readSize = 0;
_Data[0].resize(_Width*_Height);
uint dstId= 0;
while(readSize < imageSize)
{
f.serial(packet);
if((packet & 0x80) > 0) // packet RLE
{
f.serial(pixel[0]);
for (i=0; i < (packet & 0x7F) + 1; i++)
{
_Data[0][dstId++]= pixel[0];
}
}
else // packet Raw
{
for(i=0; i<((packet & 0x7F) + 1); i++)
{
f.serial(pixel[0]);
_Data[0][dstId++]= pixel[0];
}
}
readSize += (packet & 0x7F) + 1;
}
PixelFormat = _LoadGrayscaleAsAlpha?Alpha:Luminance;
};
break;
default:
return 0;
}
_MipMapCount = 1;
return(imageDepth);
}
/*-------------------------------------------------------------------*\
writeTGA
\*-------------------------------------------------------------------*/
bool CBitmap::writeTGA( NLMISC::IStream &f, uint32 d, bool upsideDown)
{
if(f.isReading()) return false;
if (d==0)
{
switch (PixelFormat)
{
case RGBA:
d = 32;
break;
case Luminance:
d = 8;
break;
case Alpha:
d = 8;
break;
default:
;
}
}
if(d!=24 && d!=32 && d!=16 && d!=8) return false;
if ((PixelFormat != RGBA)&&(PixelFormat != Alpha)&&(PixelFormat != Luminance)) return false;
if ((PixelFormat == Alpha) && (d != 8)) return false;
if ((PixelFormat == Luminance) && (d != 8)) return false;
sint32 i,j,x,y;
uint8 * scanline;
uint8 r,g,b,a;
uint8 lengthID = 0;
uint8 cMapType = 0;
uint8 imageType = 2;
uint16 origin = 0;
uint16 length = 0;
uint8 depth = 0;
uint16 xOrg = 0;
uint16 yOrg = 0;
uint16 width = (uint16)_Width;
uint16 height = (uint16)_Height;
uint8 imageDepth = (uint8)d;
uint8 desc = 0;
if (upsideDown)
desc |= 1<<5;
if ((PixelFormat == Alpha) || (PixelFormat == Luminance))
imageType = 3; // Uncompressed grayscale
f.serial(lengthID);
f.serial(cMapType);
f.serial(imageType);
f.serial(origin);
f.serial(length);
f.serial(depth);
f.serial(xOrg);
f.serial(yOrg);
f.serial(width);
f.serial(height);
f.serial(imageDepth);
f.serial(desc);
if ((PixelFormat == Alpha)||(PixelFormat == Luminance))
scanline = new uint8[width];
else
scanline = new uint8[width*4];
if(!scanline)
{
throw EAllocationFailure();
}
for(y=0; y<(sint32)height; y++)
{
uint32 k=0;
if (PixelFormat == Alpha)
{
for(i=0; i<width; ++i) // Alpha
{
scanline[k++] = _Data[0][(height-y-1)*width + i];
}
}
else if (PixelFormat == Luminance)
{
for(i=0; i<width; ++i) // Luminance
{
scanline[k++] = _Data[0][(height-y-1)*width + i];
}
}
else
{
for(i=0; i<width*4; i+=4) // 4:RGBA
{
if(d==16)
{
for(j=0; j<(sint32)4; j++)
{
scanline[k++] = _Data[0][(height-y-1)*width*4 + i + j];
}
}
else
{
for(j=0; j<(sint32)d/8; j++)
{
scanline[k++] = _Data[0][(height-y-1)*width*4 + i + j];
}
}
}
}
if(d==16)
{
for(x=0; x<(sint32)width; x++)
{
r = scanline[x*4+0];
g = scanline[x*4+1];
b = scanline[x*4+2];
int rr = r >>3;
int gg = g >>3;
int bb = b >>3;
uint16 c16 = uint16((rr<<10) | (gg<<5) | bb);
scanline[x*2+0] = c16&0xff;
scanline[x*2+1] = c16>>8;
}
}
if(d==24)
{
for(x=0; x<(sint32)width; x++)
{
r = scanline[x*3+0];
g = scanline[x*3+1];
b = scanline[x*3+2];
scanline[x*3+0] = b;
scanline[x*3+1] = g;
scanline[x*3+2] = r;
}
}
if(d==32)
{
for(x=0; x<(sint32)width; x++)
{
r = scanline[x*4+0];
g = scanline[x*4+1];
b = scanline[x*4+2];
a= scanline[x*4+3];
scanline[x*4+0] = b;
scanline[x*4+1] = g;
scanline[x*4+2] = r;
scanline[x*4+3] = a;
}
}
int finaleSize=width*d/8;
for(i=0; i<finaleSize; i++)
{
f.serial(scanline[i]);
}
}
delete []scanline;
return true;
}
template<class T>
void rotateCCW (const T* src, T* dst, uint srcWidth, uint srcHeight)
{
for (uint y=0; y<srcHeight; y++)
for (uint x=0; x<srcWidth; x++)
{
uint dstX=y;
uint dstY=srcWidth-x-1;
dst[dstX+dstY*srcHeight]=src[x+y*srcWidth];
}
}
/*template<class T>
void rotateCCW (const vector<T>& src, vector<T>& dst, uint srcWidth, uint srcHeight)
{
for (uint y=0; y<srcHeight; y++)
for (uint x=0; x<srcWidth; x++)
{
uint dstX=y;
uint dstY=srcWidth-x;
dst[dstX+dstY*srcHeight]=src[x+y*srcWidth];
}
}
*/
void CBitmap::rotateCCW()
{
// Copy the array
CObjectVector<uint8> copy=_Data[0];
switch (PixelFormat)
{
case RGBA:
NLMISC::rotateCCW ((uint32*)&(_Data[0][0]), (uint32*)&(copy[0]), _Width, _Height);
break;
case Luminance:
case Alpha:
NLMISC::rotateCCW (&_Data[0][0], &copy[0], _Width, _Height);
break;
case AlphaLuminance:
NLMISC::rotateCCW ((uint16*)&(_Data[0][0]), (uint16*)&(copy[0]), _Width, _Height);;
break;
default: break;
}
uint32 tmp=_Width;
_Width=_Height;
_Height=tmp;
_Data[0]=copy;
}
void CBitmap::blit(const CBitmap &src, sint srcX, sint srcY, sint srcWidth, sint srcHeight, sint destX, sint destY)
{
nlassert(PixelFormat == RGBA);
nlassert(src.PixelFormat == RGBA);
// clip x
if (srcX < 0)
{
srcWidth += srcX;
if (srcWidth <= 0) return;
destX -= srcX;
srcX = 0;
}
if (srcX + srcWidth > (sint) src.getWidth())
{
srcWidth = src.getWidth() - srcX;
if (srcWidth <= 0) return;
}
if (destX < 0)
{
srcWidth += destX;
if (srcWidth <= 0) return;
srcX -= destX;
destX = 0;
}
if (destX + srcWidth > (sint) getWidth())
{
srcWidth = getWidth() - destX;
if (srcWidth <= 0) return;
}
// clip y
if (srcY < 0)
{
srcHeight += srcY;
if (srcHeight <= 0) return;
destY -= srcY;
srcY = 0;
}
if (srcY + srcHeight > (sint) src.getHeight())
{
srcHeight = src.getHeight() - srcY;
if (srcHeight <= 0) return;
}
if (destY < 0)
{
srcHeight += destY;
if (srcHeight <= 0) return;
srcY -= destY;
destY = 0;
}
if (destY + srcHeight > (sint) getHeight())
{
srcHeight = getHeight() - destY;
if (srcHeight <= 0) return;
}
uint32 *srcPixels = (uint32 *) &src.getPixels()[0];
uint32 *srcPtr = &(srcPixels[srcX + srcY * src.getWidth()]);
uint32 *srcEndPtr = srcPtr + srcHeight * src.getWidth();
uint32 *destPixels = (uint32 *) &getPixels()[0];
uint32 *destPtr = &(destPixels[destX + destY * getWidth()]);
while (srcPtr != srcEndPtr)
{
memcpy(destPtr, srcPtr, sizeof(uint32) * srcWidth);
srcPtr += src.getWidth();
destPtr += getWidth();
}
}
bool CBitmap::blit(const CBitmap *src, sint32 x, sint32 y)
{
nlassert(this->PixelFormat == src->PixelFormat);
if (this->PixelFormat != src->PixelFormat)
{
return false;
}
// check for dxtc use
const bool useDXTC = PixelFormat == DXTC1 || PixelFormat == DXTC1Alpha || PixelFormat == DXTC3 || PixelFormat == DXTC5;
// number of bits for a 4x4 pix block
const uint dxtcNumBits = PixelFormat == DXTC1 || PixelFormat == DXTC1Alpha ? 64 : 128;
if (useDXTC)
{
// blit pos must be multiple of 4
nlassert(! (x & 3 || y & 3) );
if (x & 3 || y & 3) return false;
}
nlassert(PixelFormat != DonTKnow);
// the width to copy
sint width = src->_Width;
// the height to copy
sint height = src->_Height;
uint destStartX, destStartY;
uint srcStartX, srcStartY;
// clip against left
if (x < 0)
{
width += x;
if (width <= 0) return true;
destStartX = 0;
srcStartX = -x;
}
else
{
destStartX = x;
srcStartX = 0;
}
// clip against top
if (y < 0)
{
height += y;
if (height <= 0) return true;
srcStartY = -y;
destStartY = 0;
}
else
{
destStartY = y;
srcStartY = 0;
}
// clip against right
if ((destStartX + width - 1) >= _Width)
{
width = _Width - destStartX;
if (width <= 0) return true;
}
// clip against bottom
if ((destStartY + height - 1) >= _Height)
{
height = _Height - destStartY;
if (width <= 0) return true;
}
// divide all distance by 4 when using DXTC
if (useDXTC)
{
destStartX >>= 2;
destStartY >>= 2;
srcStartX >>= 2;
srcStartY >>= 2;
width >>= 2;
height >>= 2;
}
// bytes per pixs is for either one pixel or 16 (a 4x4 block in DXTC)
const uint bytePerPixs = ( useDXTC ? dxtcNumBits : bitPerPixels[PixelFormat] ) >> 3 /* divide by 8 to get the number of bytes */;
const uint destRealWidth = useDXTC ? (_Width >> 2) : _Width;
const uint srcRealWidth = useDXTC ? (src->_Width >> 2) : src->_Width;
// size to go to the next line in the destination
const uint destStride = destRealWidth * bytePerPixs;
// size to go to the next line in the source
const uint srcStride = srcRealWidth * bytePerPixs;
// length in bytes of a line to copy
const uint lineLength = width * bytePerPixs;
uint8 *destPos = &(_Data[0][0]) + destStride * destStartY + bytePerPixs * destStartX;
const uint8 *srcPos = &(src->_Data[0][0]) + srcStride * srcStartY + bytePerPixs * srcStartX;
// copy each hline
for (sint k = 0; k < height; ++k)
{
::memcpy(destPos, srcPos, lineLength);
destPos += destStride;
srcPos += srcStride;
}
return true;
}
// Private :
float CBitmap::getColorInterp (float x, float y, float colorInXY00, float colorInXY10, float colorInXY01, float colorInXY11) const
{
float res = colorInXY00*(1.0f-x)*(1.0f-y) +
colorInXY10*( x)*(1.0f-y) +
colorInXY01*(1.0f-x)*( y) +
colorInXY11*( x)*( y);
clamp (res, 0.0f, 255.0f);
return res;
}
// Public:
CRGBAF CBitmap::getColor (float x, float y) const
{
if (x < 0.0f) x = 0.0f;
if (x > 1.0f) x = 1.0f;
if (y < 0.0f) y = 0.0f;
if (y > 1.0f) y = 1.0f;
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
if (nWidth == 0 || nHeight == 0) return CRGBAF(0, 0, 0, 0);
const CObjectVector<uint8> &rBitmap = getPixels(0);
sint32 nX[4], nY[4];
x *= nWidth-1;
y *= nHeight-1;
// Integer part of (x,y)
//nX[0] = ((sint32)floor(x-0.5f));
//nY[0] = ((sint32)floor(y-0.5f));
nX[0] = ((sint32)floor(x));
nY[0] = ((sint32)floor(y));
nX[1] = (nX[0] < (nWidth-1) ? nX[0]+1 : nX[0]);
nY[1] = nY[0];
nX[2] = nX[0];
nY[2] = (nY[0] < (nHeight-1) ? nY[0]+1 : nY[0]);
nX[3] = nX[1];
nY[3] = nY[2];
uint32 i;
for (i = 0; i < 4; ++i)
{
nlassert (nX[i] >= 0);
nlassert (nY[i] >= 0 );
nlassert (nX[i] < nWidth);
nlassert (nY[i] < nHeight);
}
// Decimal part of (x,y)
x = x - (float)nX[0];
y = y - (float)nY[0];
switch (this->PixelFormat)
{
case RGBA:
case DXTC1:
case DXTC1Alpha:
case DXTC3:
case DXTC5:
{
CRGBAF finalVal;
CRGBA val[4];
if (this->PixelFormat == RGBA)
{
for (i = 0; i < 4; ++i)
{
val[i] = CRGBA (rBitmap[(nX[i]+nY[i]*nWidth)*4+0],
rBitmap[(nX[i]+nY[i]*nWidth)*4+1],
rBitmap[(nX[i]+nY[i]*nWidth)*4+2],
rBitmap[(nX[i]+nY[i]*nWidth)*4+3]);
}
}
else
{
// slower version : get from DXT
for (i = 0; i < 4; ++i)
{
val[i] = getPixelColor(nX[i], nY[i]);
}
}
finalVal.R = getColorInterp (x, y, val[0].R, val[1].R, val[2].R, val[3].R);
finalVal.G = getColorInterp (x, y, val[0].G, val[1].G, val[2].G, val[3].G);
finalVal.B = getColorInterp (x, y, val[0].B, val[1].B, val[2].B, val[3].B);
finalVal.A = getColorInterp (x, y, val[0].A, val[1].A, val[2].A, val[3].A);
finalVal /= 255.f;
return finalVal;
}
break;
case Alpha:
case Luminance:
{
float finalVal;
float val[4];
for (i = 0; i < 4; ++i)
val[i] = rBitmap[(nX[i]+nY[i]*nWidth)];
finalVal = getColorInterp (x, y, val[0], val[1], val[2], val[3]);
finalVal /= 255.f;
if (this->PixelFormat == Alpha)
return CRGBAF (1.f, 1.f, 1.f, finalVal);
else // Luminance
return CRGBAF (finalVal, finalVal, finalVal, 1.f);
}
break;
default: break;
}
return CRGBAF (0.0f, 0.0f, 0.0f, 0.0f);
}
// wrap a value inside the given range (for positive value it is like a modulo)
static inline uint32 wrap(sint32 value, uint32 range)
{
return value >= 0 ? (value % range) : range - 1 - (- value - 1) % range;
}
CRGBAF CBitmap::getColor(float x, float y, bool tileU, bool tileV) const
{
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
if (nWidth == 0 || nHeight == 0) return CRGBAF(0, 0, 0, 0);
sint32 nX[4], nY[4];
if (!tileU)
{
if (x < 0.0f) x = 0.0f;
if (x > 1.0f) x = 1.0f;
x *= nWidth-1;
nX[0] = ((sint32)floor(x));
nX[1] = (nX[0] < (nWidth-1) ? nX[0]+1 : nX[0]);
nX[2] = nX[0];
nX[3] = nX[1];
uint32 i;
for (i = 0; i < 4; ++i)
{
nlassert (nX[i] >= 0);
nlassert (nX[i] < nWidth);
}
}
else
{
x *= nWidth;
nX[0] = wrap((sint32)floorf(x), nWidth);
nX[1] = wrap(nX[0] + 1, nWidth);
nX[2] = nX[0];
nX[3] = nX[1];
}
//
if (!tileV)
{
if (y < 0.0f) y = 0.0f;
if (y > 1.0f) y = 1.0f;
y *= nHeight-1;
nY[0] = ((sint32)floor(y));
nY[1] = nY[0];
nY[2] = (nY[0] < (nHeight-1) ? nY[0]+1 : nY[0]);
nY[3] = nY[2];
uint32 i;
for (i = 0; i < 4; ++i)
{
nlassert (nY[i] >= 0 );
nlassert (nY[i] < nHeight);
}
}
else
{
y *= nHeight;
nY[0] = wrap((sint32)floorf(y), nHeight);
nY[1] = nY[0];
nY[2] = wrap(nY[0] + 1, nHeight);
nY[3] = nY[2];
}
// Decimal part of (x,y)
x = x - (float)nX[0];
y = y - (float)nY[0];
const CObjectVector<uint8> &rBitmap = getPixels(0);
switch (this->PixelFormat)
{
case RGBA:
case DXTC1:
case DXTC1Alpha:
case DXTC3:
case DXTC5:
{
CRGBAF finalVal;
CRGBA val[4];
if (this->PixelFormat == RGBA)
{
for (uint32 i = 0; i < 4; ++i)
{
val[i] = CRGBA (rBitmap[(nX[i]+nY[i]*nWidth)*4+0],
rBitmap[(nX[i]+nY[i]*nWidth)*4+1],
rBitmap[(nX[i]+nY[i]*nWidth)*4+2],
rBitmap[(nX[i]+nY[i]*nWidth)*4+3]);
}
}
else
{
// slower version : get from DXT
for (uint32 i = 0; i < 4; ++i)
{
val[i] = getPixelColor(nX[i], nY[i]);
}
}
finalVal.R = getColorInterp (x, y, val[0].R, val[1].R, val[2].R, val[3].R);
finalVal.G = getColorInterp (x, y, val[0].G, val[1].G, val[2].G, val[3].G);
finalVal.B = getColorInterp (x, y, val[0].B, val[1].B, val[2].B, val[3].B);
finalVal.A = getColorInterp (x, y, val[0].A, val[1].A, val[2].A, val[3].A);
finalVal /= 255.f;
return finalVal;
}
break;
case Alpha:
case Luminance:
{
float finalVal;
float val[4];
for (uint32 i = 0; i < 4; ++i)
val[i] = rBitmap[(nX[i]+nY[i]*nWidth)];
finalVal = getColorInterp (x, y, val[0], val[1], val[2], val[3]);
finalVal /= 255.f;
if (this->PixelFormat == Alpha)
return CRGBAF (1.f, 1.f, 1.f, finalVal);
else // Luminance
return CRGBAF (finalVal, finalVal, finalVal, 1.f);
}
break;
default: break;
}
return CRGBAF (0.0f, 0.0f, 0.0f, 0.0f);
}
void CBitmap::loadSize(NLMISC::IStream &f, uint32 &retWidth, uint32 &retHeight)
{
retWidth= 0;
retHeight= 0;
nlassert(f.isReading());
// testing if DDS
uint32 fileType = 0;
f.serial(fileType);
if(fileType == DDS_HEADER)
{
// read entire DDS header.
uint32 size = 0;
f.serial(size); // size in Bytes of header(without "DDS")
uint32 * _DDSSurfaceDesc = new uint32[size];
_DDSSurfaceDesc[0]= size;
for(uint i= 0; i<size/4 - 1; i++)
{
f.serial(_DDSSurfaceDesc[i+1]);
}
// flags determines which members of the header structure contain valid data
uint32 flags = _DDSSurfaceDesc[1];
//verify if file have linearsize set
if(!(flags & DDSD_LINEARSIZE))
{
nlwarning("A DDS doesn't have the flag DDSD_LINEARSIZE");
//delete [] _DDSSurfaceDesc;
//throw EDDSBadHeader();
}
//-------------- extracting and testing useful info
retHeight = _DDSSurfaceDesc[2];
retWidth = _DDSSurfaceDesc[3];
delete [] _DDSSurfaceDesc;
}
else if(fileType == PNG_HEADER)
{
// check second part of header
f.serialCheck(0x0a1a0a0d);
uint32 chunkLength = 0;
uint32 chunkName = 0;
bool eof = false;
do
{
try
{
// length of chunk data
f.serial(chunkLength);
NLMISC_BSWAP32(chunkLength);
// name of chunk
f.serial(chunkName);
// size of image is a part of IHDR chunk
if (chunkName == NL_MAKEFOURCC('I', 'H', 'D', 'R'))
{
uint32 val;
f.serial(val);
NLMISC_BSWAP32(val);
retWidth = val;
f.serial(val);
NLMISC_BSWAP32(val);
retHeight = val;
break;
}
// end of file chunk
else if (chunkName == NL_MAKEFOURCC('I', 'E', 'N', 'D'))
{
break;
}
// skip data of this chunk and CRC32
f.seek(chunkLength+4, IStream::current);
}
catch(...)
{
eof = true;
}
}
while(!eof);
}
else if(fileType == JPG_HEADER)
{
uint8 blockMarker1 = 0;
uint8 blockMarker2 = 0;
uint16 blockSize = 0;
bool eof = false;
do
{
try
{
// marker of a block
f.serial(blockMarker1);
if (blockMarker1 == 0xff)
{
// marker of a block
f.serial(blockMarker2);
// 0xff00 is only found in image data
if (blockMarker2 == 0x00)
{
// image data 0xff
}
// 0xffda is image data
else if (blockMarker2 == 0xda)
{
// next data is image data which must end with 0xffd9
}
// 0xffd9 is the end of an image
else if (blockMarker2 == 0xd9)
{
// real end of file
break;
}
else if (blockMarker2 == 0xdd || blockMarker2 == 0xdc)
{
f.seek(4, IStream::current);
}
else if (blockMarker2 == 0xdf)
{
f.seek(3, IStream::current);
}
else if (blockMarker2 >= 0xd0 && blockMarker2 <= 0xd8)
{
// no content
}
else
{
// size of a block
f.serial(blockSize);
NLMISC_BSWAP16(blockSize);
// frame marker (which contains image width and height)
if (blockMarker2 >= 0xc0 && blockMarker2 <= 0xc3)
{
uint8 imagePrecision = 0; // sample precision
uint32 imageSize = 0; // width and height
f.serial(imagePrecision);
f.serial(imageSize);
NLMISC_BSWAP32(imageSize);
retWidth = imageSize & 0xffff;
retHeight = (imageSize & 0xffff0000) >> 16;
break;
}
// skip the block
f.seek(blockSize - 2, IStream::current);
}
}
}
catch(...)
{
eof = true;
}
}
while(!eof);
}
else if(fileType == GIF_HEADER)
{
// check second part of header ("7a" or "9a" in 'GIF89a')
uint16 s;
f.serial(s);
if (s != 0x6137 && s != 0x6139)
{
nlwarning("Invalid GIF header, expected GIF87a or GIF89a");
return;
}
uint16 lsWidth;
uint16 lsHeight;
f.serial(lsWidth);
f.serial(lsHeight);
retWidth = lsWidth;
retHeight = lsHeight;
}
// assuming it's TGA
else
{
if(!f.seek (0, NLMISC::IStream::begin))
{
throw ESeekFailed();
}
// Reading header,
// To make sure that the bitmap is TGA, we check imageType and imageDepth.
uint8 lengthID;
uint8 cMapType;
uint8 imageType;
uint16 tgaOrigin;
uint16 length;
uint8 depth;
uint16 xOrg;
uint16 yOrg;
uint16 width;
uint16 height;
uint8 imageDepth;
uint8 desc;
f.serial(lengthID);
f.serial(cMapType);
f.serial(imageType);
if(imageType!=2 && imageType!=3 && imageType!=10 && imageType!=11)
{
nlwarning("Invalid TGA format, type %u in not supported (must be 2, 3, 10 or 11)", imageType);
return;
}
f.serial(tgaOrigin);
f.serial(length);
f.serial(depth);
f.serial(xOrg);
f.serial(yOrg);
f.serial(width);
f.serial(height);
f.serial(imageDepth);
if(imageDepth!=8 && imageDepth!=16 && imageDepth!=24 && imageDepth!=32)
{
nlwarning("Invalid TGA format, bit depth %u in not supported (must be 8,16,24 or 32)", imageDepth);
return;
}
f.serial(desc);
// Ok, we have width and height.
retWidth= width;
retHeight= height;
}
// reset stream.
if(!f.seek (0, NLMISC::IStream::begin))
{
throw ESeekFailed();
}
}
void CBitmap::loadSize(const std::string &path, uint32 &retWidth, uint32 &retHeight)
{
retWidth= 0;
retHeight= 0;
CIFile f(path);
if(f.open(path))
loadSize(f, retWidth, retHeight);
}
// ***************************************************************************
void CBitmap::flipHDXTCBlockColor(uint8 *bitColor, uint32 w)
{
// pack each line in a u32 (NB: the following works either in Little and Big Endian)
uint32 bits= *(uint32*)bitColor;
// swap in X for each line
uint32 res;
if(w!=2)
{
res = (bits & 0xC0C0C0C0) >> 6;
res+= (bits & 0x30303030) >> 2;
res+= (bits & 0x0C0C0C0C) << 2;
res+= (bits & 0x03030303) << 6;
}
// special case where w==2
else
{
res = (bits & 0x0C0C0C0C) >> 2;
res+= (bits & 0x03030303) << 2;
}
// copy
*((uint32*)bitColor)= res;
}
// ***************************************************************************
void CBitmap::flipVDXTCBlockColor(uint8 *bitColor, uint32 h)
{
// swap just bytes (work either in Little and Big Endian)
if(h!=2)
{
std::swap(bitColor[0], bitColor[3]);
std::swap(bitColor[1], bitColor[2]);
}
// special case where h==2)
else
{
// whatever Little or Big endian, the first byte is the first line, and the second byte is the second line
std::swap(bitColor[0], bitColor[1]);
}
}
// ***************************************************************************
void CBitmap::flipHDXTCBlockAlpha3(uint8 *blockAlpha, uint32 w)
{
#ifdef NL_LITTLE_ENDIAN
uint64 bits= *(uint64*)blockAlpha;
#else
uint64 bits= (uint64)blockAlpha[0] + ((uint64)blockAlpha[1]<<8) +
((uint64)blockAlpha[2]<<16) + ((uint64)blockAlpha[3]<<24) +
((uint64)blockAlpha[4]<<32) + ((uint64)blockAlpha[5]<<40) +
((uint64)blockAlpha[6]<<48) + ((uint64)blockAlpha[7]<<56);
#endif
// swap in X for each line
uint64 res;
if(w!=2)
{
res = (bits & INT64_CONSTANT(0xF000F000F000F000)) >> 12;
res+= (bits & INT64_CONSTANT(0x0F000F000F000F00)) >> 4;
res+= (bits & INT64_CONSTANT(0x00F000F000F000F0)) << 4;
res+= (bits & INT64_CONSTANT(0x000F000F000F000F)) << 12;
}
// special case where w==2
else
{
res = (bits & INT64_CONSTANT(0x00F000F000F000F0)) >> 4;
res+= (bits & INT64_CONSTANT(0x000F000F000F000F)) << 4;
}
// copy
#ifdef NL_LITTLE_ENDIAN
*((uint64*)blockAlpha)= res;
#else
blockAlpha[0]= res & 255;
blockAlpha[1]= (res>>8) & 255;
blockAlpha[2]= (res>>16) & 255;
blockAlpha[3]= (res>>24) & 255;
blockAlpha[4]= (res>>32) & 255;
blockAlpha[5]= (res>>40) & 255;
blockAlpha[6]= (res>>48) & 255;
blockAlpha[7]= (res>>56) & 255;
#endif
}
// ***************************************************************************
void CBitmap::flipVDXTCBlockAlpha3(uint8 *blockAlpha, uint32 h)
{
uint16 *wAlpha= (uint16*)blockAlpha;
// swap just words (work either in Little and Big Endian)
if(h!=2)
{
std::swap(wAlpha[0], wAlpha[3]);
std::swap(wAlpha[1], wAlpha[2]);
}
// special case where h==2)
else
{
// whatever Little or Big endian, the first byte is the first line, and the second byte is the second line
std::swap(wAlpha[0], wAlpha[1]);
}
}
// ***************************************************************************
void CBitmap::flipHDXTCBlockAlpha5(uint8 *bitAlpha, uint32 w)
{
// pack into bits. Little Indian in all cases
uint64 bits= (uint64)bitAlpha[0] + ((uint64)bitAlpha[1]<<8) +
((uint64)bitAlpha[2]<<16) + ((uint64)bitAlpha[3]<<24) +
((uint64)bitAlpha[4]<<32) + ((uint64)bitAlpha[5]<<40);
// swap in X for each line
uint64 res;
if(w!=2)
{
res = (bits & INT64_CONSTANT(0xE00E00E00E00)) >> 9;
res+= (bits & INT64_CONSTANT(0x1C01C01C01C0)) >> 3;
res+= (bits & INT64_CONSTANT(0x038038038038)) << 3;
res+= (bits & INT64_CONSTANT(0x007007007007)) << 9;
}
// special case where w==2
else
{
res = (bits & INT64_CONSTANT(0x038038038038)) >> 3;
res+= (bits & INT64_CONSTANT(0x007007007007)) << 3;
}
// copy. Little Indian in all cases
bitAlpha[0]= uint8(res & 255);
bitAlpha[1]= uint8((res>>8) & 255);
bitAlpha[2]= uint8((res>>16) & 255);
bitAlpha[3]= uint8((res>>24) & 255);
bitAlpha[4]= uint8((res>>32) & 255);
bitAlpha[5]= uint8((res>>40) & 255);
}
// ***************************************************************************
void CBitmap::flipVDXTCBlockAlpha5(uint8 *bitAlpha, uint32 h)
{
// pack into bits. Little Indian in all cases
uint64 bits= (uint64)bitAlpha[0] + ((uint64)bitAlpha[1]<<8) +
((uint64)bitAlpha[2]<<16) + ((uint64)bitAlpha[3]<<24) +
((uint64)bitAlpha[4]<<32) + ((uint64)bitAlpha[5]<<40);
// swap in Y
uint64 res;
if(h!=2)
{
res = (bits & INT64_CONSTANT(0xFFF000000000)) >> 36;
res+= (bits & INT64_CONSTANT(0x000FFF000000)) >> 12;
res+= (bits & INT64_CONSTANT(0x000000FFF000)) << 12;
res+= (bits & INT64_CONSTANT(0x000000000FFF)) << 36;
}
// special case where h==2
else
{
res = (bits & INT64_CONSTANT(0x000000FFF000)) >> 12;
res+= (bits & INT64_CONSTANT(0x000000000FFF)) << 12;
}
// copy. Little Indian in all cases
bitAlpha[0]= uint8(res & 255);
bitAlpha[1]= uint8((res>>8) & 255);
bitAlpha[2]= uint8((res>>16) & 255);
bitAlpha[3]= uint8((res>>24) & 255);
bitAlpha[4]= uint8((res>>32) & 255);
bitAlpha[5]= uint8((res>>40) & 255);
}
// ***************************************************************************
void CBitmap::flipDXTCMipMap(bool vertical, uint mm, uint type)
{
nlassert(mm<MAX_MIPMAP);
// size of a DXTC block. 64 bits (2 U32) for DXTC1, else 128 bits (4*U32)
uint blockSizeU32= type==1? 2 : 4;
// get size in block
sint32 width = getWidth(mm);
sint32 height = getHeight(mm);
if(width==0 || height==0)
return;
uint32 wBlock= (width+3)/4;
uint32 hBlock= (height+3)/4;
// get data ptr and check size.
uint32 *data= (uint32*)(&_Data[mm][0]);
nlassert(_Data[mm].size()==wBlock*hBlock*blockSizeU32*4);
// get the offset (in bytes) to the start of color pixels bits
uint32 offsetColorBits= type==1? 4 : 12;
// abort if swap is nonsense
if(vertical && height==1)
return;
if(!vertical && width==1)
return;
// *** First reverse Blocks
if(vertical)
{
// reverse vertical
for(uint yBlock=0;yBlock<hBlock/2;yBlock++)
{
uint32 *src0= data + (yBlock*wBlock)*blockSizeU32;
uint32 *src1= data + ((hBlock-yBlock-1)*wBlock)*blockSizeU32;
for(uint xBlock=0;xBlock<wBlock;xBlock++, src0+=blockSizeU32, src1+=blockSizeU32)
{
uint32 *block0= src0;
uint32 *block1= src1;
// swap the blocks
for(uint i=0;i<blockSizeU32;i++, block0++, block1++)
{
std::swap(*block0, *block1);
}
}
}
}
else
{
// reverse horizontal
for(uint yBlock=0;yBlock<hBlock;yBlock++)
{
uint32 *src0= data + (yBlock*wBlock)*blockSizeU32;
uint32 *src1= data + (yBlock*wBlock + wBlock-1)*blockSizeU32;
for(uint xBlock=0;xBlock<wBlock/2;xBlock++, src0+=blockSizeU32, src1-=blockSizeU32)
{
uint32 *block0= src0;
uint32 *block1= src1;
// swap the blocks
for(uint i=0;i<blockSizeU32;i++, block0++, block1++)
{
std::swap(*block0, *block1);
}
}
}
}
// *** Then reverse Bits
for(uint yBlock=0;yBlock<hBlock;yBlock++)
{
uint32 *src= data + (yBlock*wBlock)*blockSizeU32;
for(uint xBlock=0;xBlock<wBlock;xBlock++, src+=blockSizeU32)
{
uint8 *block= (uint8*)src;
// flip color bits
if(vertical) flipVDXTCBlockColor(block+offsetColorBits, height);
else flipHDXTCBlockColor(block+offsetColorBits, width);
// flip alpha bits if any
if(type==3)
{
// point to the alpha part (16*4 bits)
if(vertical) flipVDXTCBlockAlpha3(block, height);
else flipHDXTCBlockAlpha3(block, width);
}
else if(type==5)
{
// point to the bit alpha part (16*3 bits)
if(vertical) flipVDXTCBlockAlpha5(block+2, height);
else flipHDXTCBlockAlpha5(block+2, width);
}
}
}
}
// ***************************************************************************
void CBitmap::flipDXTC(bool vertical)
{
// get type
uint type;
if(PixelFormat == DXTC1 || PixelFormat == DXTC1Alpha )
type=1;
else if(PixelFormat == DXTC3)
type=3;
else if(PixelFormat == DXTC5)
type=5;
else
return;
// correct width/height?
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
if(!isPowerOf2(nWidth) || !isPowerOf2(nHeight))
return;
// flip all mipmaps
for(uint mm=0;mm<_MipMapCount;mm++)
{
flipDXTCMipMap(vertical, mm, type);
}
}
// ***************************************************************************
void CBitmap::flipH()
{
if (PixelFormat != RGBA)
{
// try for DXTC
flipDXTC(false);
// then quit (whether it worked or not)
return;
}
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
sint32 i, j;
NLMISC::CRGBA *pBitmap = (NLMISC::CRGBA*)&_Data[0][0];
bool needRebuild = false;
CRGBA temp;
if(_MipMapCount>1)
needRebuild = true;
releaseMipMaps();
for( i = 0; i < nHeight; ++i )
for( j = 0; j < nWidth/2; ++j )
{
temp = pBitmap[i*nWidth+j];
pBitmap[i*nWidth+j] = pBitmap[i*nWidth+nWidth-j-1];
pBitmap[i*nWidth+nWidth-j-1] = temp;
}
// Rebuilding mipmaps
if(needRebuild)
{
buildMipMaps();
}
}
// ***************************************************************************
void CBitmap::flipV()
{
if (PixelFormat != RGBA)
{
// try for DXTC
flipDXTC(true);
// then quit (whether it worked or not)
return;
}
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
sint32 i, j;
NLMISC::CRGBA *pBitmap = (NLMISC::CRGBA*)&_Data[0][0];
bool needRebuild = false;
CRGBA temp;
if(_MipMapCount>1)
needRebuild = true;
releaseMipMaps();
for( j = 0; j < nHeight/2; ++j )
for( i = 0; i < nWidth; ++i )
{
temp = pBitmap[j*nWidth+i];
pBitmap[j*nWidth+i] = pBitmap[(nHeight-j-1)*nWidth+i];
pBitmap[(nHeight-j-1)*nWidth+i] = temp;
}
// Rebuilding mipmaps
if(needRebuild)
{
buildMipMaps();
}
}
void CBitmap::rot90CW()
{
if (PixelFormat != RGBA)
return;
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
sint32 i, j;
NLMISC::CRGBA *pSrcRgba = (NLMISC::CRGBA*)&_Data[0][0];
bool needRebuild = false;
if(_MipMapCount>1)
needRebuild = true;
releaseMipMaps();
CObjectVector<uint8> pDestui;
pDestui.resize(nWidth*nHeight*4);
NLMISC::CRGBA *pDestRgba = (NLMISC::CRGBA*)&pDestui[0];
for( j = 0; j < nHeight; ++j )
for( i = 0; i < nWidth; ++i )
pDestRgba[j+i*nHeight] = pSrcRgba[i+(nHeight-1-j)*nWidth];
uint32 nTemp = _Width;
_Width = _Height;
_Height = nTemp;
NLMISC::contReset(_Data[0]); // free memory
_Data[0] = pDestui;
// Rebuilding mipmaps
if(needRebuild)
{
buildMipMaps();
}
}
void CBitmap::rot90CCW()
{
if (PixelFormat != RGBA)
return;
sint32 nWidth = getWidth(0);
sint32 nHeight = getHeight(0);
sint32 i, j;
NLMISC::CRGBA *pSrcRgba = (NLMISC::CRGBA*)&_Data[0][0];
bool needRebuild = false;
if(_MipMapCount>1)
needRebuild = true;
releaseMipMaps();
CObjectVector<uint8> pDestui;
pDestui.resize(nWidth*nHeight*4);
NLMISC::CRGBA *pDestRgba = (NLMISC::CRGBA*)&pDestui[0];
for( j = 0; j < nHeight; ++j )
for( i = 0; i < nWidth; ++i )
pDestRgba[j+i*nHeight] = pSrcRgba[nWidth-1-i+j*nWidth];
uint32 nTemp = _Width;
_Width = _Height;
_Height = nTemp;
NLMISC::contReset(_Data[0]); // free memory
_Data[0] = pDestui;
// Rebuilding mipmaps
if(needRebuild)
{
buildMipMaps();
}
}
//===========================================================================
void CBitmap::blend(CBitmap &Bm0, CBitmap &Bm1, uint16 factor, bool inputBitmapIsMutable /*= false*/)
{
nlassert(factor <= 256);
nlassert(Bm0._Width != 0 && Bm0._Height != 0
&& Bm1._Width != 0 && Bm1._Height != 0);
nlassert(Bm0._Width == Bm1._Width); // the bitmap should have the same size
nlassert(Bm0._Height == Bm1._Height);
const CBitmap *nBm0, *nBm1; // pointer to the bitmap that is used for blending, or to a copy is a conversion wa required
CBitmap cp0, cp1; // these bitmap are copies of Bm1 and Bm0 if a conversion was needed
if (Bm0.PixelFormat != RGBA)
{
if (inputBitmapIsMutable)
{
Bm0.convertToRGBA();
nBm0 = &Bm0;
}
else
{
cp0 = Bm0;
cp0.convertToRGBA();
nBm0 = &cp0;
}
}
else
{
nBm0 = &Bm0;
}
if (Bm1.PixelFormat != RGBA)
{
if (inputBitmapIsMutable)
{
Bm1.convertToRGBA();
nBm1 = &Bm1;
}
else
{
cp1 = Bm1;
cp1.convertToRGBA();
nBm1 = &cp1;
}
}
else
{
nBm1 = &Bm1;
}
if (this != nBm0 && this != nBm1)
{
// if source is the same than the dets, don't resize because this clear the bitmap
this->resize(Bm0._Width, Bm0._Height, RGBA);
}
uint numPix = _Width * _Height; // 4 component per pixels
const uint8 *src0 = &(nBm0->_Data[0][0]);
const uint8 *src1 = &(nBm1->_Data[0][0]);
uint8 *dest = &(this->_Data[0][0]);
#if defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
if (CSystemInfo::hasMMX())
{
// On a P4 2GHz, with a 256x256 texture, I got the following results :
// without mmx : 5.2 ms
// with mmx : 1.7 ms
// I'm sure this can be further optimized..
uint numPixLeft = numPix & 1; // process 2 pixels at once, so special case for odd number
numPix = numPix & ~1;
// do fast blend with mmx
uint64 blendFactor0;
uint64 blendFactor1;
uint16 *bf0 = (uint16 *) &blendFactor0;
uint16 *bf1 = (uint16 *) &blendFactor1;
bf0[0] = bf0[1] = bf0[2] = bf0[3] = (1 << 6) * (factor);
bf1[0] = bf1[1] = bf1[2] = bf1[3] = (1 << 6) * (256 - factor);
__asm
{
mov esi, src0
mov eax, src1
mov edi, dest
mov ebx, -8
mov ecx, numPix
shr ecx, 1 // process pixels 2 by 2
movq mm1, blendFactor0
movq mm0, blendFactor1
myLoop:
pxor mm6, mm6
lea ebx, [ebx + 8] // points next location
pxor mm7, mm7
movq mm2, [esi + ebx]
movq mm3, [eax + ebx]
// do blend
punpckhbw mm7, mm2 // mm7 contains src0 color 0 in high bytes
punpckhbw mm6, mm3 // mm6 contains src1 color 0 in high bytes
psrl mm7, 1
pxor mm4, mm4 // mm4 = 0
psrl mm6, 1
pmulhw mm7, mm0 // src0 = src0 * blendFactor
pxor mm5, mm5 // mm5 = 0
pmulhw mm6, mm1 // src1 = src1 * (1 - blendfactor)
punpcklbw mm4, mm2 // mm4 contains src0 color 1 in high bytes
paddusw mm6, mm7 // mm6 = src0[0] blended with src1[0]
psrl mm4, 1
psrlw mm6, 5
punpcklbw mm5, mm3 // mm4 contains src1 color 1 in high bytes
psrl mm5, 1
pmulhw mm4, mm0 // src0 = src0 * blendFactor
pmulhw mm5, mm1 // src1 = src1 * (1 - blendfactor)
paddusw mm4, mm5 // mm6 = src0[1] blended with src1[1]
psrlw mm4, 5
// pack result
packuswb mm4, mm6
dec ecx
movq [edi + ebx], mm4 // store result
jne myLoop
emms
}
if (numPixLeft)
{
// case of odd number of pixels
src0 += 4 * numPix;
src1 += 4 * numPix;
dest += 4 * numPix;
uint blendFact = (uint) factor;
uint invblendFact = 256 - blendFact;
*dest = (uint8) (((blendFact * *src1) + (invblendFact * *src0)) >> 8);
*(dest + 1) = (uint8) (((blendFact * *(src1 + 1)) + (invblendFact * *(src0 + 1))) >> 8);
*(dest + 2) = (uint8) (((blendFact * *(src1 + 2)) + (invblendFact * *(src0 + 2))) >> 8);
*(dest + 3) = (uint8) (((blendFact * *(src1 + 3)) + (invblendFact * *(src0 + 3))) >> 8);
}
}
else
#endif //#ifdef NL_OS_WINDOWS
{
uint8 *endPix = dest + (numPix << 2);
// no mmx version
uint blendFact = (uint) factor;
uint invblendFact = 256 - blendFact;
do
{
/// blend 4 component at each pass
*dest = (uint8) (((blendFact * *src1) + (invblendFact * *src0)) >> 8);
*(dest + 1) = (uint8) (((blendFact * *(src1 + 1)) + (invblendFact * *(src0 + 1))) >> 8);
*(dest + 2) = (uint8) (((blendFact * *(src1 + 2)) + (invblendFact * *(src0 + 2))) >> 8);
*(dest + 3) = (uint8) (((blendFact * *(src1 + 3)) + (invblendFact * *(src0 + 3))) >> 8);
src0 = src0 + 4;
src1 = src1 + 4;
dest = dest + 4;
}
while (dest != endPix);
}
}
//-----------------------------------------------
CRGBA CBitmap::getRGBAPixel(sint x, sint y, uint32 numMipMap /*=0*/) const
{
uint w = getWidth(numMipMap);
uint h = getHeight(numMipMap);
if (w == 0 || (uint) x >= w || (uint) y >= h) return CRGBA::Black; // include negative cases
const uint8 *pix = &getPixels(numMipMap)[(x + y * w) << 2];
return CRGBA(pix[0], pix[1], pix[2], pix[3]);
}
//-----------------------------------------------
CRGBA CBitmap::getDXTCColorFromBlock(const uint8 *block, sint x, sint y)
{
uint16 col0;
uint16 col1;
memcpy(&col0, block, sizeof(uint16));
memcpy(&col1, block + 2, sizeof(uint16));
uint colIndex = (block[4 + (y & 3)] >> ((x & 3) << 1)) & 3;
CRGBA result, c0, c1;
if (col0 > col1)
{
switch(colIndex)
{
case 0:
uncompress(col0, result);
break;
case 1:
uncompress(col1, result);
break;
case 2:
uncompress(col0, c0);
uncompress(col1, c1);
result.blendFromui(c0, c1, 85);
break;
case 3:
uncompress(col0, c0);
uncompress(col1, c1);
result.blendFromui(c0, c1, 171);
break;
default:
;
}
result.A = 255;
}
else
{
switch(colIndex)
{
case 0:
uncompress(col0, result);
result.A = 255;
break;
case 1:
uncompress(col1, result);
result.A = 255;
break;
case 2:
uncompress(col0, c0);
uncompress(col1, c1);
result.blendFromui(c0, c1, 128);
result.A = 255;
break;
case 3:
result.set(0, 0, 0, 0);
break;
}
}
return result;
}
//-----------------------------------------------
CRGBA CBitmap::getDXTC1Texel(sint x, sint y, uint32 numMipMap) const
{
uint w = getWidth(numMipMap);
uint h = getHeight(numMipMap);
if (w == 0 || h == 0 || (uint) x >= w || (uint) y >= h) return CRGBA::Black; // include negative cases
uint numRowBlocks = std::max((w + 3) >> 2, 1u);
const uint8 *pix = &getPixels(numMipMap)[0];
const uint8 *block = pix + ((y >> 2) * (numRowBlocks << 3) + ((x >> 2) << 3));
return getDXTCColorFromBlock(block, x, y);
}
//-----------------------------------------------
CRGBA CBitmap::getDXTC3Texel(sint x, sint y, uint32 numMipMap) const
{
uint w = getWidth(numMipMap);
uint h = getHeight(numMipMap);
if (w == 0 || h == 0 || (uint) x >= w || (uint) y >= h) return CRGBA::Black; // include negative cases
uint numRowBlocks = std::max((w + 3) >> 2, 1u);
const uint8 *pix = &getPixels(numMipMap)[0];
const uint8 *block = pix + ((y >> 2) * (numRowBlocks << 4) + ((x >> 2) << 4));
CRGBA result = getDXTCColorFromBlock(block + 8, x, y);
// get alpha part
uint8 alphaByte = block[((y & 3) << 1) + ((x & 2) >> 1)];
result.A = (x & 1) ? (alphaByte & 0xf0) : ((alphaByte & 0x0f) << 4);
return result;
}
//-----------------------------------------------
CRGBA CBitmap::getDXTC5Texel(sint x, sint y, uint32 numMipMap) const
{
uint w = getWidth(numMipMap);
uint h = getHeight(numMipMap);
if (w == 0 || h == 0 || (uint) x >= w || (uint) y >= h) return CRGBA::Black; // include negative cases
uint numRowBlocks = std::max((w + 3) >> 2, 1u);
const uint8 *pix = &getPixels(numMipMap)[0];
const uint8 *block = pix + ((y >> 2) * (numRowBlocks << 4) + ((x >> 2) << 4));
CRGBA result = getDXTCColorFromBlock(block + 8, x, y);
// get alpha part
uint8 alpha0 = block[0];
uint8 alpha1 = block[1];
uint alphaIndex;
uint tripletIndex = (x & 3) + ((y & 3) << 2);
if (tripletIndex < 8)
{
alphaIndex = (((uint32 &) block[2]) >> (tripletIndex * 3)) & 7;
}
else
{
alphaIndex = (((uint32 &) block[5]) >> ((tripletIndex - 8) * 3)) & 7; // we can read a dword there because there are color datas following he alpha datas
}
if (alpha0 > alpha1)
{
switch (alphaIndex)
{
case 0: result.A = alpha0; break;
case 1: result.A = alpha1; break;
case 2: result.A = (uint8) ((6 * (uint) alpha0 + (uint) alpha1) / 7); break;
case 3: result.A = (uint8) ((5 * (uint) alpha0 + 2 * (uint) alpha1) / 7); break;
case 4: result.A = (uint8) ((4 * (uint) alpha0 + 3 * (uint) alpha1) / 7); break;
case 5: result.A = (uint8) ((3 * (uint) alpha0 + 4 * (uint) alpha1) / 7); break;
case 6: result.A = (uint8) ((2 * (uint) alpha0 + 5 * (uint) alpha1) / 7); break;
case 7: result.A = (uint8) (((uint) alpha0 + (uint) 6 * alpha1) / 7); break;
}
}
else
{
switch (alphaIndex)
{
case 0: result.A = alpha0; break;
case 1: result.A = alpha1; break;
case 2: result.A = (uint8) ((4 * (uint) alpha0 + (uint) alpha1) / 5); break;
case 3: result.A = (uint8) ((3 * (uint) alpha0 + 2 * (uint) alpha1) / 5); break;
case 4: result.A = (uint8) ((2 * (uint) alpha0 + 3 * (uint) alpha1) / 5); break;
case 5: result.A = (uint8) (((uint) alpha0 + 4 * (uint) alpha1) / 5); break;
case 6: result.A = 0; break;
case 7: result.A = 255; break;
}
}
return result;
}
//-----------------------------------------------
CRGBA CBitmap::getPixelColor(sint x, sint y, uint32 numMipMap /*=0*/) const
{
switch (PixelFormat)
{
case RGBA:
return getRGBAPixel(x, y, numMipMap);
case DXTC1:
case DXTC1Alpha:
return getDXTC1Texel(x, y, numMipMap);
case DXTC3:
return getDXTC3Texel(x, y, numMipMap);
case DXTC5:
return getDXTC5Texel(x, y, numMipMap);
default:
nlstop;
break;
}
return CRGBA::Black;
}
//-----------------------------------------------
void CBitmap::swap(CBitmap &other)
{
std::swap(PixelFormat, other.PixelFormat);
std::swap(_MipMapCount, other._MipMapCount);
std::swap(_LoadGrayscaleAsAlpha, other._LoadGrayscaleAsAlpha);
std::swap(_Width, other._Width);
std::swap(_Height, other._Height);
for(uint k = 0; k < MAX_MIPMAP; ++k)
{
_Data[k].swap(other._Data[k]);
}
}
//-----------------------------------------------
void CBitmap::unattachPixels(CObjectVector<uint8> *mipmapDestArray, uint maxMipMapCount /*=MAX_MIPMAP*/)
{
if (!mipmapDestArray) return;
uint k;
for(k = 0; k < std::min((uint) _MipMapCount, maxMipMapCount); ++k)
{
mipmapDestArray[k].swap(_Data[k]);
_Data[k].clear();
}
for(; k < _MipMapCount; ++k)
{
_Data[k].clear();
}
#ifdef NL_DEBUG
// check that remaining mipmaps are empty
for(; k < _MipMapCount; ++k)
{
nlassert(_Data[k].empty());
}
#endif
_MipMapCount = 1;
_Width = 0;
_Height = 0;
PixelFormat = RGBA;
_LoadGrayscaleAsAlpha = true;
}
void CBitmap::getData(uint8*& extractData)
{
uint32 size=0;
if(PixelFormat==RGBA)
size=_Width*_Height*4;
else if(PixelFormat==Alpha||PixelFormat==Luminance)
size=_Width*_Height;
else
{
nlstop;
}
for(uint32 pix=0;pix<size;pix++)
extractData[pix]=_Data[0][pix];
}
void CBitmap::getDibData(uint8*& extractData)
{
uint32 lineSize=0,size;
uint8** buf;
buf=new uint8*[_Height];
if(PixelFormat==RGBA)
{
lineSize=_Width*4;
}
else if(PixelFormat==Alpha||PixelFormat==Luminance)
{
lineSize=_Width;
}
else
{
nlstop;
}
for(sint32 i=_Height-1;i>=0;i--)
{
buf[_Height-1-i]=&_Data[0][i*lineSize];
}
size=lineSize*_Height;
for(uint32 line=0;line<_Height;line++)
{
for(uint32 pix=0;pix<lineSize;pix++)
extractData[line*lineSize+pix]=_Data[0][size-(line+1)*lineSize+pix];
}
delete []buf;
}
} // NLMISC
Reference in a new issue View git blame Copy permalink