NLMISC::CBitmap Class Reference

#include <bitmap.h>

Inheritance diagram for NLMISC::CBitmap:

---

Detailed Description

Class Bitmap

Author:

Stephane Coutelas

Nevrax France

Date:

2000

Definition at line 87 of file bitmap.h.

[NOHEADER]
CRGBA	getDXTC1Texel (sint x, sint y, uint32 numMipMap) const
CRGBA	getDXTC3Texel (sint x, sint y, uint32 numMipMap) const
CRGBA	getDXTC5Texel (sint x, sint y, uint32 numMipMap) const
CRGBA	getDXTCColorFromBlock (const uint8 *block, sint x, sint y)
Public Types
enum	TType {   RGBA = 0, Luminance, Alpha, AlphaLuminance,   DXTC1, DXTC1Alpha, DXTC3, DXTC5,   DsDt, ModeCount, DonTKnow = 0xffffffff }
Public Member Functions
void	blend (CBitmap &Bm0, CBitmap &Bm1, uint16 factor, bool inputBitmapIsMutable=false)
bool	blit (const CBitmap *src, sint32 x, sint32 y)
void	buildMipMaps ()
	CBitmap ()
bool	convertToType (TType type)
void	flipH ()
void	flipV ()
CRGBAF	getColor (float x, float y) const
virtual uint32	getHeight (uint32 numMipMap=0) const
uint32	getMipMapCount () const
CRGBA	getPixelColor (sint x, sint y, uint32 numMipMap=0) const
TType	getPixelFormat () const
uint32	getSize (uint32 numMipMap=0) const
virtual uint32	getWidth (uint32 numMipMap=0) const
bool	isGrayscaleAsAlpha () const
uint8	load (NLMISC::IStream &f, uint mipMapSkip=0)
void	loadGrayscaleAsAlpha (bool loadAsAlpha)
void	makeDummy ()
void	releaseMipMaps ()
void	resample (sint32 nNewWidth, sint32 nNewHeight)
void	reset (TType type=RGBA)
void	resize (sint32 nNewWidth, sint32 nNewHeight, TType newType=DonTKnow, bool resetTo0=true)
void	resizeMipMap (uint32 numMipMap, sint32 nNewWidth, sint32 nNewHeight, bool resetTo0=true)
void	rot90CCW ()
void	rot90CW ()
void	rotateCCW ()
void	setMipMapCount (uint32 mmc)
bool	writeJPG (NLMISC::IStream &f, uint8 quality=80)
bool	writeTGA (NLMISC::IStream &f, uint32 d, bool upsideDown=false)
virtual	~CBitmap ()
Static Public Member Functions
void	loadSize (const std::string &path, uint32 &retWidth, uint32 &retHeight)
void	loadSize (NLMISC::IStream &f, uint32 &width, uint32 &height)
Data Fields
enum NLMISC::CBitmap::TType	PixelFormat
Static Public Attributes
const uint32	bitPerPixels [ModeCount]
const uint32	DXTC1HEADER = NL_MAKEFOURCC('D','X', 'T', '1')
const uint32	DXTC3HEADER = NL_MAKEFOURCC('D','X', 'T', '3')
const uint32	DXTC5HEADER = NL_MAKEFOURCC('D','X', 'T', '5')
Protected Attributes
CObjectVector< uint8 >	_Data [MAX_MIPMAP]
uint32	_Height
bool	_LoadGrayscaleAsAlpha
uint8	_MipMapCount
uint32	_Width
Private Member Functions
uint32	blend (uint32 &n0, uint32 &n1, uint32 coef0)
bool	decompressDXT1 (bool alpha)
bool	decompressDXT3 ()
bool	decompressDXT5 ()
float	getColorInterp (float x, float y, float xy00, float xy01, float xy10, float xy11) const
CRGBA	getRGBAPixel (sint x, sint y, uint32 numMipMap) const
uint8	readDDS (NLMISC::IStream &f, uint mipMapSkip)
uint8	readTGA (NLMISC::IStream &f)
void	resamplePicture32 (const NLMISC::CRGBA *pSrc, NLMISC::CRGBA *pDest, sint32 nSrcWidth, sint32 nSrcHeight, sint32 nDestWidth, sint32 nDestHeight)
bool	alphaLuminanceToAlpha ()
bool	alphaLuminanceToLuminance ()
bool	alphaLuminanceToRGBA ()
bool	alphaToAlphaLuminance ()
bool	alphaToLuminance ()
bool	alphaToRGBA ()
bool	convertToAlpha ()
bool	convertToAlphaLuminance ()
bool	convertToDXTC5 ()
bool	convertToLuminance ()
bool	convertToRGBA ()
bool	luminanceToAlpha ()
bool	luminanceToAlphaLuminance ()
bool	luminanceToRGBA ()
bool	rgbaToAlpha ()
bool	rgbaToAlphaLuminance ()
bool	rgbaToLuminance ()
Static Private Member Functions
void	uncompress (uint16 color, NLMISC::CRGBA &)

---

Member Enumeration Documentation

enum NLMISC::CBitmap::TType

Enumeration values: RGBA  Luminance  Alpha  AlphaLuminance  DXTC1  DXTC1Alpha  DXTC3  DXTC5  DsDt  ModeCount  DonTKnow  Definition at line 234 of file bitmap.h. { RGBA=0, Luminance, Alpha, AlphaLuminance, DXTC1, DXTC1Alpha, DXTC3, DXTC5, DsDt, ModeCount, DonTKnow=0xffffffff } PixelFormat;

---

Constructor & Destructor Documentation

NLMISC::CBitmap::CBitmap (   )  [inline]

Definition at line 254 of file bitmap.h. References _LoadGrayscaleAsAlpha, _MipMapCount, PixelFormat, and RGBA. { _MipMapCount = 1; _Width = 0; _Height = 0; PixelFormat = RGBA; _LoadGrayscaleAsAlpha = true; }

virtual NLMISC::CBitmap::~CBitmap (   )  [inline, virtual]

Definition at line 263 of file bitmap.h. { }

---

Member Function Documentation

bool NLMISC::CBitmap::alphaLuminanceToAlpha (   )  [private]

Definition at line 762 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToAlpha(). { 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; }

bool NLMISC::CBitmap::alphaLuminanceToLuminance (   )  [private]

Definition at line 677 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToLuminance(). { 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++]= 0; dataTmp[dstId++]= 0; dataTmp[dstId++]= 0; dataTmp[dstId++]= _Data[m][i]; } NLMISC::contReset(_Data[m]); _Data[m].resize(0); _Data[m] = dataTmp; } PixelFormat = Luminance; return true; }

bool NLMISC::CBitmap::alphaLuminanceToRGBA (   )  [private]

Definition at line 519 of file bitmap.cpp. References _MipMapCount, PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToRGBA(). { 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; }

bool NLMISC::CBitmap::alphaToAlphaLuminance (   )  [private]

Definition at line 607 of file bitmap.cpp. References _MipMapCount, PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToAlphaLuminance(). { 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; }

bool NLMISC::CBitmap::alphaToLuminance (   )  [private]

Definition at line 664 of file bitmap.cpp. References PixelFormat. Referenced by convertToLuminance(). { if(_Width*_Height == 0) return false; PixelFormat = Luminance; return true; }

bool NLMISC::CBitmap::alphaToRGBA (   )  [private]

Definition at line 490 of file bitmap.cpp. References _MipMapCount, PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToRGBA(). { 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; }

void NLMISC::CBitmap::blend (  CBitmap &  Bm0, CBitmap &  Bm1, uint16  factor, bool  inputBitmapIsMutable = false )

Set this bitmap as the result of the blend bewteen 2 bitmap REQUIRE : - Bm0 and Bm1 should have the same size. Both bitmap should be convertible to RGBA pixel format. The result is a RGBA bitmap. NB: this just works with the first mipmaps Parameters: factor  The blend factor. 0 means the result is equal to Bm0, 256 means the result is equal to Bm1 inputBitmapIsMutable  when true, bitmap can be converted in place when needed (no copy done) Definition at line 2817 of file bitmap.cpp. References _Data, _Height, _Width, convertToRGBA(), nlassert, PixelFormat, resize(), RGBA, uint, uint16, uint64, and uint8. { 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; } 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]); #ifdef NL_OS_WINDOWS 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] = factor; bf1[0] = bf1[1] = bf1[2] = bf1[3] = 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 punpcklbw mm5, mm3 // mm4 contains src1 color 1 in high bytes psll mm6, 1 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] psll mm4, 1 // 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 { *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); } }

uint32 NLMISC::CBitmap::blend (  uint32 &  n0, uint32 &  n1, uint32  coef0 )  [private]

blend 2 integers between 0 and 255 . Parameters: n0  first integer n1  second integer coef  coefficient for the first integer (must be in [0,256]) Definition at line 1338 of file bitmap.cpp. References uint32. Referenced by decompressDXT5(), and NL3D::CTextureBlend::doGenerate(). { int a0 = coef0; int a1 = 256-a0; return ((n0*a0 + n1*a1) >>8); }

bool NLMISC::CBitmap::blit (  const CBitmap *  src, sint32  x, sint32  y )

Perform a simple blit from the source to this bitmap at the (x, y) pos The dimension of the original bitmap are preserved For now, this texture and the source must have the same format With DXTC format, the dest coordinates must be a multiple of 4 mipmap are not rebuild when present Returns: true if the params were corrects and if the blit occures. In debug build there's an assertion Definition at line 2332 of file bitmap.cpp. References bitPerPixels, DonTKnow, height, nlassert, PixelFormat, sint, sint32, src, uint, uint8, width, x, and y. Referenced by NL3D::CTextureGrouped::doGenerate(), and NL3D::CCoarseMeshBuild::expand(). { 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; }

void NLMISC::CBitmap::buildMipMaps (   )

Build the mipmaps of the bitmap if they don't exist. Work only in RGBA mode... See also: releaseMipMaps(). Definition at line 1422 of file bitmap.cpp. References _MipMapCount, NLMISC::CRGBA::A, NLMISC::CRGBA::B, NLMISC::CRGBA::G, NLMISC::isPowerOf2(), PixelFormat, NLMISC::CRGBA::R, NLMISC::CObjectVector< uint8 >::resize(), RGBA, sint, uint32, and w. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CTextureMem::doGenerate(), flipH(), flipV(), resample(), rot90CCW(), rot90CW(), and NL3D::CDriverGL::setupTextureEx(). { 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(mulh==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++; } }

bool NLMISC::CBitmap::convertToAlpha (   )  [private]

Definition at line 821 of file bitmap.cpp. References alphaLuminanceToAlpha(), luminanceToAlpha(), PixelFormat, RGBA, and rgbaToAlpha(). Referenced by convertToType(). { 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; }

bool NLMISC::CBitmap::convertToAlphaLuminance (   )  [private]

Definition at line 852 of file bitmap.cpp. References alphaToAlphaLuminance(), luminanceToAlphaLuminance(), PixelFormat, RGBA, and rgbaToAlphaLuminance(). Referenced by convertToType(). { 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; }

bool NLMISC::CBitmap::convertToDXTC5 (   )  [private]

Change bitmap format about DXTC1 to DXTC5 : Does nothing if the format is not DXTC1 about alpha encoding : alpha0 == alpha1 code(x,y) == 7 for every (x,y) about luminance to alpha and alpha to luminance : the buffer keeps unchanged Definition at line 415 of file bitmap.cpp. Referenced by convertToType(). { /* 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; */ }

bool NLMISC::CBitmap::convertToLuminance (   )  [private]

Definition at line 790 of file bitmap.cpp. References alphaLuminanceToLuminance(), alphaToLuminance(), PixelFormat, RGBA, and rgbaToLuminance(). Referenced by convertToType(). { 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; }

bool NLMISC::CBitmap::convertToRGBA (   )  [private]

Definition at line 882 of file bitmap.cpp. References alphaLuminanceToRGBA(), alphaToRGBA(), decompressDXT1(), decompressDXT3(), decompressDXT5(), luminanceToRGBA(), PixelFormat, and RGBA. Referenced by blend(), and convertToType(). { 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; }

bool NLMISC::CBitmap::convertToType (  TType  type  )

Convert bitmap to another type conversion to rgba always work. No-op if already rgba. Parameters: type  new type for the bitmap Returns: true if conversion succeeded, false else Definition at line 926 of file bitmap.cpp. References convertToAlpha(), convertToAlphaLuminance(), convertToDXTC5(), convertToLuminance(), convertToRGBA(), PixelFormat, RGBA, and type. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CLodCharacterTmpBitmap::build(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CTextureFile::buildBitmapFromFile(), NL3D::CHeightMap::buildFromBitmap(), NL3D::CAsyncTextureManager::CTextureEntry::createCoarseBitmap(), NL3D::CZoneLighter::getTexture(), NL3D::CTileBank::getTileNoiseMap(), and NL3D::CDriverGL::setupTextureEx(). { 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; }

bool NLMISC::CBitmap::decompressDXT1 (  bool  alpha  )  [private]

Decompress bitmap compressed with S3TC DXT1 algorithm. Parameters: alpha  if alpha is true there's alpha. Definition at line 965 of file bitmap.cpp. References _MipMapCount, NLMISC::CRGBA::A, alpha, NLMISC::CRGBA::blendFromui(), height, NLMISC::MAX_MIPMAP, PixelFormat, NLMISC::CRGBA::R, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, NLMISC::CRGBA::set(), NLMISC::CObjectVector< uint8 >::size(), NLMISC::CObjectVector< T, EnableObjectBehavior >::size(), src, uint, uint16, uint32, uint8, uncompress(), width, x, and y. Referenced by convertToRGBA(). { 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; }

bool NLMISC::CBitmap::decompressDXT3 (   )  [private]

Decompress bitmap compressed with S3TC DXT3 algorithm. Exceptions: EAllocationFailure  : can't allocate memory. Definition at line 1090 of file bitmap.cpp. References _MipMapCount, alpha, NLMISC::CRGBA::blendFromui(), height, NLMISC::MAX_MIPMAP, PixelFormat, NLMISC::CRGBA::R, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, NLMISC::CObjectVector< uint8 >::size(), NLMISC::CObjectVector< T, EnableObjectBehavior >::size(), src, uint, uint16, uint32, uint64, uint8, uncompress(), width, x, and y. Referenced by convertToRGBA(). { 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; }

bool NLMISC::CBitmap::decompressDXT5 (   )  [private]

Decompress bitmap compressed with S3TC DXT3 algorithm. Exceptions: EAllocationFailure  : can't allocate memory. Definition at line 1200 of file bitmap.cpp. References _MipMapCount, alpha, blend(), NLMISC::CRGBA::blendFromui(), height, NLMISC::MAX_MIPMAP, PixelFormat, NLMISC::CRGBA::R, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, NLMISC::CObjectVector< uint8 >::size(), NLMISC::CObjectVector< T, EnableObjectBehavior >::size(), src, uint, uint16, uint32, uint64, uint8, uncompress(), width, x, and y. Referenced by convertToRGBA(). { 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; }

void NLMISC::CBitmap::flipH (   )

Horizontal flip (all the columns are flipped) Definition at line 2682 of file bitmap.cpp. References _MipMapCount, buildMipMaps(), getHeight(), getWidth(), PixelFormat, releaseMipMaps(), RGBA, and sint32. { if (PixelFormat != RGBA) 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 NLMISC::CBitmap::flipV (   )

Vertical flip (all the rows are flipped) Definition at line 2714 of file bitmap.cpp. References _MipMapCount, buildMipMaps(), getHeight(), getWidth(), PixelFormat, releaseMipMaps(), RGBA, and sint32. { if (PixelFormat != RGBA) 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(); } }

CRGBAF NLMISC::CBitmap::getColor (  float  x, float  y )  const

Get the color in the bitmap given a pixel size The mipmaps must be built. If not just return the bilinear at the given point. The input x and y must be clamped between 0 and 1 Definition at line 2470 of file bitmap.cpp. References NLMISC::CRGBAF::A, NLMISC::CRGBAF::B, NLMISC::CRGBAF::G, getColorInterp(), getHeight(), getPixelColor(), getPixels(), getWidth(), nlassert, PixelFormat, NLMISC::CRGBAF::R, RGBA, sint32, uint32, x, and y. { 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); }

float NLMISC::CBitmap::getColorInterp (  float  x, float  y, float  xy00, float  xy01, float  xy10, float  xy11 )  const [private]

Quadratic interpolator Returns: the interpolation in (x,y) of the values (xy**) Definition at line 2459 of file bitmap.cpp. References NLMISC::clamp(), res, x, and y. Referenced by getColor(). { 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; }

CRGBA NLMISC::CBitmap::getDXTC1Texel (  sint  x, sint  y, uint32  numMipMap )  const [private]

Definition at line 3048 of file bitmap.cpp. References getDXTCColorFromBlock(), getHeight(), getPixels(), getWidth(), sint, uint, uint32, uint8, w, x, and y. Referenced by getPixelColor(). { 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 NLMISC::CBitmap::getDXTC3Texel (  sint  x, sint  y, uint32  numMipMap )  const [private]

Definition at line 3061 of file bitmap.cpp. References NLMISC::CRGBA::A, getDXTCColorFromBlock(), getHeight(), getPixels(), getWidth(), sint, uint, uint32, uint8, w, x, and y. Referenced by getPixelColor(). { 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 << 4); return result; }

CRGBA NLMISC::CBitmap::getDXTC5Texel (  sint  x, sint  y, uint32  numMipMap )  const [private]

Definition at line 3077 of file bitmap.cpp. References NLMISC::CRGBA::A, getDXTCColorFromBlock(), getHeight(), getPixels(), getWidth(), sint, uint, uint32, uint8, w, x, and y. Referenced by getPixelColor(). { 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 NLMISC::CBitmap::getDXTCColorFromBlock (  const uint8 *  block, sint  x, sint  y )  [static, private]

Definition at line 2990 of file bitmap.cpp. References NLMISC::CRGBA::A, NLMISC::CRGBA::blendFromui(), NLMISC::CRGBA::set(), sint, uint, uint16, uint8, uncompress(), x, and y. Referenced by getDXTC1Texel(), getDXTC3Texel(), and getDXTC5Texel(). { 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; } 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; }

uint32 NLMISC::CBitmap::getHeight (  uint32  numMipMap = 0  )  const [virtual]

Return the image height, or a mipmap height. Parameters: mipMap  mipmap level Returns: image height (0 if mipmap not found) Definition at line 1388 of file bitmap.cpp. References uint32, and w. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CLodCharacterTmpBitmap::build(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CTextureFile::buildBitmapFromFile(), NL3D::CFontManager::computeString(), NL3D::CFastHLSModifier::convertDDSBitmap(), draw2dLine(), NL3D::CCoarseMeshBuild::expand(), NL3D::CDriverGL::fillBuffer(), flipH(), flipV(), NL3D::CPatchDLMContext::generate(), getColor(), getDXTC1Texel(), getDXTC3Texel(), getDXTC5Texel(), getRGBAPixel(), getSize(), NL3D::GetTextureSize(), NL3D::CTileBank::getTileNoiseMap(), NL3D::CZoneLighter::lightWater(), NL3D::CShapeBank::processWSUploadTexture(), RenderTriangle(), rot90CCW(), rot90CW(), NL3D::CHLSColorTexture::setBitmap(), NL3D::CDriverGL::setupTextureEx(), NL3D::CDriverGL::uploadTexture(), and NL3D::CAsyncTextureManager::uploadTexturePart(). { 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; }

uint32 NLMISC::CBitmap::getMipMapCount (   )  const [inline]

Return the number of mipmaps. Level0 is a mipmap... Returns: number of mipmaps. 0 if no image at all. 1 if no mipmaping (for the base level). Definition at line 369 of file bitmap.h. References _MipMapCount, and uint32. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CHLSColorTexture::setBitmap(), NL3D::CDriverGL::setupTextureEx(), NL3D::CDriverGL::uploadTexture(), NL3D::CAsyncTextureManager::uploadTexturePart(), and NL3D::CAsyncTextureManager::validDXTCMipMap(). { return _MipMapCount; }

CRGBA NLMISC::CBitmap::getPixelColor (  sint  x, sint  y, uint32  numMipMap = 0 )  const

Get the pixel at the given coorrdinate. Works in RGBA and DXTC modes. Outside of the bitmap it returns Black (or if mipmap is not found) Definition at line 3134 of file bitmap.cpp. References getDXTC1Texel(), getDXTC3Texel(), getDXTC5Texel(), getRGBAPixel(), nlstop, PixelFormat, RGBA, sint, uint32, x, and y. Referenced by getColor(). { 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; }

TType NLMISC::CBitmap::getPixelFormat (   )  const [inline]

Return the format of pixels stored at the present time in the object buffer. Returns: Pixel format (rgba luminance alpha alphaLuminance dxtc1 dxtc1Alpha dxtc3 dxtc5) Definition at line 335 of file bitmap.h. References PixelFormat. Referenced by NL3D::CFastHLSModifier::convertDDSBitmap(), NL3D::CFastHLSModifier::convertRGBABitmap(), NL3D::CTextureGrouped::doGenerate(), NL3D::CDriverGL::fillBuffer(), NL3D::getGlSrcTextureFormat(), NL3D::CDriverGL::getGlTextureFormat(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CTextureFar::rebuildPatch(), NL3D::CHLSColorTexture::setBitmap(), NL3D::CDriverGL::setupTextureEx(), NL3D::CAsyncTextureManager::update(), NL3D::CDriverGL::uploadTexture(), NL3D::CAsyncTextureManager::uploadTexturePart(), and NL3D::CAsyncTextureManager::validDXTCMipMap(). { return PixelFormat; }

const CObjectVector<uint8>& NLMISC::CBitmap::getPixels (  uint32  numMipMap = 0  )  const [inline]

Definition at line 313 of file bitmap.h. References uint32. { //nlassert (numMipMap<=_MipMapCount); return _Data[numMipMap]; }

CObjectVector<uint8>& NLMISC::CBitmap::getPixels (  uint32  numMipMap = 0  )  [inline]

Return the pixels buffer of the image, or of one of its mipmap. Return a reference of an array in pixel format get with getPixelFormat(). Returns: CObjectVector<uint8>& RGBA pixels Definition at line 308 of file bitmap.h. References uint32. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CLodCharacterTmpBitmap::build(), NL3D::CTextureFile::buildBitmapFromFile(), NL3D::CHLSColorTexture::buildColorVersion(), NL3D::CFastHLSModifier::convertDDSBitmapDXTC1Or1A(), NL3D::CFastHLSModifier::convertDDSBitmapDXTC3Or5(), NL3D::CFastHLSModifier::convertRGBABitmap(), NL3D::CTextureDLM::copyRect(), NL3D::CTextureFont::CTextureFont(), NL3D::CTextureMem::doGenerate(), NL3D::CTextureEmboss::doGenerate(), NL3D::CTextureBump::doGenerate(), draw2dLine(), NL3D::CTextureFont::dumpTextureFont(), NL3D::CCoarseMeshBuild::expand(), NL3D::CDriverGL::fillBuffer(), NL3D::CTextureDLM::fillRect(), NL3D::CDriverGL::getBufferPart(), getColor(), getDXTC1Texel(), getDXTC3Texel(), getDXTC5Texel(), getRGBAPixel(), NL3D::CTileBank::getTileNoiseMap(), NL3D::CZoneLighter::lightWater(), NL3D::CTextureDLM::modulateAndfillRect565(), NL3D::CTextureDLM::modulateAndfillRect8888(), NL3D::CTextureDLM::modulateConstantAndfillRect(), NL3D::CTextureFar::rebuildPatch(), RenderTriangle(), NL3D::CHLSColorTexture::setBitmap(), NL3D::CDriverGL::setupTextureEx(), and NL3D::CDriverGL::uploadTexture(). { //nlassert (numMipMap<=_MipMapCount); return _Data[numMipMap]; }

CRGBA NLMISC::CBitmap::getRGBAPixel (  sint  x, sint  y, uint32  numMipMap )  const [private]

Definition at line 2980 of file bitmap.cpp. References getHeight(), getPixels(), getWidth(), sint, uint, uint32, uint8, w, x, and y. Referenced by getPixelColor(). { 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]); }

uint32 NLMISC::CBitmap::getSize (  uint32  numMipMap = 0  )  const

Return the size (in pixels) of the image: <=> getHeight()*getWidth(). Parameters: mipMap  mipmap level Returns: image size (0 if mipmap not found) Definition at line 1412 of file bitmap.cpp. References getHeight(), getWidth(), and uint32. Referenced by NL3D::CShapeBank::processWSUploadTexture(), NL3D::CDriverGL::setupTextureEx(), NL3D::CAsyncTextureManager::update(), and NL3D::CAsyncTextureManager::uploadTexturePart(). { return getHeight(numMipMap)*getWidth(numMipMap); }

uint32 NLMISC::CBitmap::getWidth (  uint32  numMipMap = 0  )  const [virtual]

Return the image width, or a mipmap width. Parameters: mipMap  mipmap level Returns: image width (0 if mipmap not found) Definition at line 1363 of file bitmap.cpp. References uint32, and w. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CShadowMapManager::allocateTexture(), NL3D::CLodCharacterTmpBitmap::build(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CTextureFile::buildBitmapFromFile(), NL3D::CFontManager::computeString(), NL3D::CFastHLSModifier::convertDDSBitmap(), NL3D::CTextureDLM::copyRect(), draw2dLine(), NL3D::CCoarseMeshBuild::expand(), NL3D::CDriverGL::fillBuffer(), NL3D::CTextureDLM::fillRect(), flipH(), flipV(), NL3D::CPatchDLMContext::generate(), getColor(), getDXTC1Texel(), getDXTC3Texel(), getDXTC5Texel(), getRGBAPixel(), getSize(), NL3D::GetTextureSize(), NL3D::CTileBank::getTileNoiseMap(), NL3D::CZoneLighter::lightWater(), NL3D::CTextureDLM::modulateAndfillRect565(), NL3D::CTextureDLM::modulateAndfillRect8888(), NL3D::CTextureDLM::modulateConstantAndfillRect(), NL3D::CShapeBank::processWSUploadTexture(), RenderTriangle(), rot90CCW(), rot90CW(), NL3D::CHLSColorTexture::setBitmap(), NL3D::CDriverGL::setupTextureEx(), NL3D::CDriverGL::uploadTexture(), and NL3D::CAsyncTextureManager::uploadTexturePart(). { 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; }

bool NLMISC::CBitmap::isGrayscaleAsAlpha (   )  const [inline]

Tell if the bitmap loads grayscale bitmap as alpha or luminance format. Returns: true if the bitmap loads grayscale bitmaps as alpha, false if it loads grayscale bitmaps as luminance. Definition at line 483 of file bitmap.h. References _LoadGrayscaleAsAlpha. { return _LoadGrayscaleAsAlpha; }

uint8 NLMISC::CBitmap::load (  NLMISC::IStream &  f, uint  mipMapSkip = 0 )

Read a bitmap(TGA or DDS) from an IStream. Bitmap supported are DDS (DXTC1, DXTC1 with Alpha, DXTC3, DXTC5, and uncompressed TGA (24 and 32 bits). Parameters: IStream  The stream must be in reading mode. mipMapSkip  if the file is a DDS with mipMap. N=mipMapSkip mipmaps are skipped. Returns: image depth (24 or 32), or 0 if load failed Exceptions: ESeekFailed  : seek has failed Definition at line 109 of file bitmap.cpp. References NLMISC::IStream::begin, NLMISC::DDS, depth, height, NLMISC::IStream::isReading(), nlassert, readDDS(), readTGA(), NLMISC::IStream::seek(), NLMISC::IStream::serial(), uint, uint16, uint32, uint8, and width. Referenced by NL3D::CTextureFile::buildBitmapFromFile(), and NL3D::CTextureMem::doGenerate(). { nlassert(f.isReading()); // testing if DDS uint32 fileType = 0;; f.serial(fileType); if(fileType == DDS) { #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 } // assuming it's TGA else { 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 } }

void NLMISC::CBitmap::loadGrayscaleAsAlpha (  bool  loadAsAlpha  )  [inline]

Tell the bitmap to load grayscale bitmap as alpha or luminance format. Parameters: loadAsAlpha  is true to load grayscale bitmaps as alpha. false to load grayscale bitmaps as luminance. default value is true. Definition at line 472 of file bitmap.h. References _LoadGrayscaleAsAlpha. Referenced by NL3D::CTextureFile::buildBitmapFromFile(), and NL3D::CTileBank::getTileNoiseMap(). { _LoadGrayscaleAsAlpha=loadAsAlpha; }

void NLMISC::CBitmap::loadSize (  const std::string &  path, uint32 &  retWidth, uint32 &  retHeight )  [static]

same than other loadSize(), but with a pathName. See also: loadSize() Definition at line 2671 of file bitmap.cpp. References loadSize(), NLMISC::CIFile::open(), and uint32. { retWidth= 0; retHeight= 0; CIFile f(path); if(f.open(path)) loadSize(f, retWidth, retHeight); }

void NLMISC::CBitmap::loadSize (  NLMISC::IStream &  f, uint32 &  width, uint32 &  height )  [static]

Determinate the bitmap size from a bitmap(TGA or DDS) from an IStream. load just header of the file. Bitmap supported are DDS (DXTC1, DXTC1 with Alpha, DXTC3, DXTC5, and uncompressed TGA (24 and 32 bits). NB: at the end, f is seeked to begin. Parameters: IStream  The stream must be in reading mode. width  the width of the image. 0 if fails. height  the height of the image. 0 if fails. Exceptions: ESeekFailed  : seek has failed Definition at line 2582 of file bitmap.cpp. References NLMISC::DDS, DDSD_LINEARSIZE, depth, height, NLMISC::IStream::isReading(), nlassert, NLMISC::IStream::seek(), NLMISC::IStream::serial(), size, uint, uint16, uint32, uint8, and width. Referenced by loadSize(). { retWidth= 0; retHeight= 0; nlassert(f.isReading()); // testing if DDS uint32 fileType = 0; f.serial(fileType); if(fileType == DDS) { // read entire DDS header. uint32 size = 0; f.serial(size); // size in Bytes of header(without "DDS") uint32 * _DDSSurfaceDesc = new uint32[size]; std::auto_ptr<uint32> _DDSSurfaceDescAuto(_DDSSurfaceDesc); _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)) { throw EDDSBadHeader(); } //-------------- extracting and testing useful info retHeight = _DDSSurfaceDesc[2]; retWidth = _DDSSurfaceDesc[3]; } // 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) 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!=24 && imageDepth!=32) 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(); } }

bool NLMISC::CBitmap::luminanceToAlpha (   )  [private]

Definition at line 736 of file bitmap.cpp. References _MipMapCount, PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToAlpha(). { 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; }

bool NLMISC::CBitmap::luminanceToAlphaLuminance (   )  [private]

Definition at line 579 of file bitmap.cpp. References _MipMapCount, PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToAlphaLuminance(). { 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; }

bool NLMISC::CBitmap::luminanceToRGBA (   )  [private]

Definition at line 462 of file bitmap.cpp. References _MipMapCount, PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToRGBA(). { 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; }

void NLMISC::CBitmap::makeDummy (   )

Make a dummy "?" texture. Usefull for file not found. Mode is rgba. Definition at line 184 of file bitmap.cpp. References _MipMapCount, NLMISC::CObjectVector< uint8 >::getPtr(), PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), RGBA, NLMISC::CRGBA::set(), sint, and uint8. Referenced by NL3D::CTextureFile::buildBitmapFromFile(), NL3D::CreateDummyMesh(), NL3D::CTextureMultiFile::doGenerate(), NL3D::CTextureMem::doGenerate(), NL3D::CTextureGrouped::doGenerate(), NL3D::CTextureEmboss::doGenerate(), NL3D::CTextureBump::doGenerate(), and NL3D::CTextureBlend::doGenerate(). { 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, }; PixelFormat = RGBA; _MipMapCount = 1; _Width= 32; _Height= 32; _Data[0].resize(_Width*_Height*sizeof(NLMISC::CRGBA)); 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); } }

uint8 NLMISC::CBitmap::readDDS (  NLMISC::IStream &  f, uint  mipMapSkip )  [private]

Read a DDS from an IStream. The bitmap is readen as a set of bytes and stocked compressed. Width and Height are multiple of 4. Parameters: IStream  The stream must be in reading mode. Returns: image depth Exceptions: EDDSBadHeader  : surface is header is not valid. Definition at line 244 of file bitmap.cpp. References _MipMapCount, DDSD_LINEARSIZE, DXTC1HEADER, DXTC3HEADER, DXTC5HEADER, NLMISC::getPowerOf2(), min, PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), NLMISC::IStream::seek(), NLMISC::IStream::serial(), NLMISC::IStream::serialBuffer(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, uint8, and w. Referenced by load(). { //------------------ Reading Header ------------------------ //-------------- reading entire header uint32 size = 0; f.serial(size); // size in Bytes of header(without "DDS") uint32 * _DDSSurfaceDesc = new uint32[size]; std::auto_ptr<uint32> _DDSSurfaceDescAuto(_DDSSurfaceDesc); _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)) { 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 if(PixelFormat==DXTC1 && _DDSSurfaceDesc[21]>0) //AlphaBitDepth { PixelFormat = DXTC1Alpha; } if(PixelFormat!= DXTC1 && PixelFormat!= DXTC1Alpha && PixelFormat!= DXTC3 && PixelFormat!= DXTC5) { 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 leat 4. mipMapSkip= min(mipMapSkip, minSizeLevel-2); // skip any mipmap uint seekSize= 0; while(mipMapSkip>0) { uint32 mipMapSz; if(PixelFormat==DXTC1 || PixelFormat==DXTC1Alpha) mipMapSz = _Width*_Height/2; else mipMapSz = _Width*_Height; // 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)) { 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++) { uint32 wtmp, htmp; if(w<4) wtmp = 4; else wtmp = w; if(h < 4) htmp = 4; else htmp = h; 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 switch(PixelFormat) { case DXTC1 : return 24; case DXTC1Alpha : return 32; case DXTC3 : return 32; case DXTC5 : return 32; default : break; } return 0; }

uint8 NLMISC::CBitmap::readTGA (  NLMISC::IStream &  f  )  [private]

Read a TGA from an IStream. TGA pictures can be in 24 or 32 bits, RLE or uncompressed Parameters: f  IStream (must be a reading stream) Returns: image depth if succeed, 0 else Definition at line 1800 of file bitmap.cpp. References _LoadGrayscaleAsAlpha, _MipMapCount, NLMISC::IStream::begin, depth, NLMISC::IStream::end, NLMISC::IStream::getPos(), height, imageSize, NLMISC::IStream::isReading(), nlinfo, PixelFormat, r, NLMISC::CObjectVector< uint8 >::resize(), RGBA, NLMISC::IStream::seek(), NLMISC::IStream::serial(), NLMISC::IStream::serialBuffer(), sint32, size, uint, uint16, uint32, uint8, width, x, and y. Referenced by load(). { if(!f.isReading()) return 0; uint32 size; 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; // Image/Color map data uint8 *imageID; // Determining whether file is in Original or New TGA format bool newTgaFormat; uint32 extAreaOffset; uint32 devDirectoryOffset; char signature[16]; f.seek (0, f.end); newTgaFormat = false; 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]); } if(strncmp(signature,"TRUEVISION-XFILE",16)==0) newTgaFormat = true; } // 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) { imageID = new uint8[lengthID]; for(i=0; i<lengthID; i++) f.serial(imageID[i]); } // Reading TGA image data _Width = width; _Height = height; size = _Width * _Height * (imageDepth/8); 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] = (_r<<3) | (_r>>2); _Data[0][(height-y-1)*width*4 + 4*i + 1] = (_g<<3) | (_g>>2); _Data[0][(height-y-1)*width*4 + 4*i + 2] = (_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] = (_r<<3) | (_r>>2); _Data[0][y*width*4 + 4*i + 1] = (_g<<3) | (_g>>2); _Data[0][y*width*4 + 4*i + 2] = (_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]; uint32 imageSize = width*height; uint32 readSize = 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++) { for(j=0; j<imageDepth/8; j++) { _Data[0][dstId++]= pixel[j]; } if(imageDepth==24) { _Data[0][dstId++]= 0; } } } else // packet Raw { for(i=0; i<((packet & 0x7F) + 1); i++) { for(j=0; j<imageDepth/8; j++) { f.serial(pixel[j]); } if(imageDepth==32) { _Data[0][dstId++]= pixel[2]; _Data[0][dstId++]= pixel[1]; _Data[0][dstId++]= pixel[0]; _Data[0][dstId++]= pixel[3]; } if(imageDepth==24) { _Data[0][dstId++]= pixel[2]; _Data[0][dstId++]= pixel[1]; _Data[0][dstId++]= pixel[0]; _Data[0][dstId++]= 0; } } } readSize += (packet & 0x7F) + 1; } PixelFormat = RGBA; }; 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); }

void NLMISC::CBitmap::releaseMipMaps (   )

Release the mipmaps of the bitmap if they exist. Work for any mode. See also: buildMipMaps(). Definition at line 1493 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), NLMISC::MAX_MIPMAP, and sint. Referenced by NL3D::CAsyncTextureManager::CTextureEntry::createCoarseBitmap(), NL3D::CTextureEmboss::doGenerate(), NL3D::CTextureBump::doGenerate(), flipH(), flipV(), resample(), resize(), rot90CCW(), rot90CW(), and NL3D::CDriverGL::setupTextureEx(). { if(_MipMapCount<=1) return; _MipMapCount=1; for(sint i=1;i<MAX_MIPMAP;i++) { NLMISC::contReset(_Data[i]); } }

void NLMISC::CBitmap::resample (  sint32  nNewWidth, sint32  nNewHeight )

Resample the bitmap. If mipmaps exist they are deleted, then rebuilt after resampling. Parameters: nNewWidth  width after resample nNewHeight  height after resample Definition at line 1508 of file bitmap.cpp. References _MipMapCount, buildMipMaps(), NLMISC::contReset(), nlassert, PixelFormat, releaseMipMaps(), resamplePicture32(), NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, and sint32. Referenced by NL3D::CCoarseMeshBuild::buildBitmap(), and NL3D::CDriverGL::setupTextureEx(). { nlassert(PixelFormat == RGBA); bool needRebuild = false; // Deleting mipmaps if(_MipMapCount>1) needRebuild = true; releaseMipMaps(); if(nNewWidth==0 || nNewHeight==0) { _Width = _Height = 0; return; } CObjectVector<uint8> pDestui; pDestui.resize(nNewWidth*nNewHeight*4); NLMISC::CRGBA *pDestRgba = (NLMISC::CRGBA*)&pDestui[0]; resamplePicture32 ((NLMISC::CRGBA*)&_Data[0][0], pDestRgba, _Width, _Height, nNewWidth, nNewHeight); NLMISC::contReset(_Data[0]); // free memory _Data[0] = pDestui; _Width= nNewWidth; _Height= nNewHeight; // Rebuilding mipmaps if(needRebuild) { buildMipMaps(); } }

void NLMISC::CBitmap::resamplePicture32 (  const NLMISC::CRGBA *  pSrc, NLMISC::CRGBA *  pDest, sint32  nSrcWidth, sint32  nSrcHeight, sint32  nDestWidth, sint32  nDestHeight )  [private]

The resample function Parameters: pSrc  CRGBA array pDest  CRGBA array for storing resampled texture nSrcWidth  original width nSrcHeight  original height nDestWidth  width after resample nDestHeight  height after resample Definition at line 1618 of file bitmap.cpp. References nlassert, and sint32. Referenced by resample(). { if ((nSrcWidth<=0)||(nSrcHeight<=0)||(nDestHeight<=0)||(nDestHeight<=0)) 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) { double fNext=(double)floor (fX)+1.f; if (fNext>fFinal) fNext=fFinal; vColor+=((float)(fNext-fX))*NLMISC::CRGBAF (pSrcLine[(sint32)floor(fX)]); fX=fNext; } nlassert (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; } } } }

void NLMISC::CBitmap::reset (  TType  type = RGBA  )

Reset the buffer. Mipmaps are deleted and bitmap is not valid anymore. Parameters: type  is the new type used for this texture Definition at line 1599 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), type, and uint. Referenced by NL3D::CHLSColorTexture::buildColorVersion(), NL3D::CDriverGL::getBufferPart(), and NL3D::ITexture::release(). { 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; }

void NLMISC::CBitmap::resize (  sint32  nNewWidth, sint32  nNewHeight, TType  newType = DonTKnow, bool  resetTo0 = true )

Resize the bitmap. If mipmaps exist they are deleted and not rebuilt. This is not a crop. Pixels are lost after resize. Parameters: nNewWidth  width after resize nNewHeight  height after resize newType  is the new type of the bitmap. If don_t_know, keep the same pixel format that before. resetTo0  by default the vector are filled by 0. set false to gain performances. Definition at line 1545 of file bitmap.cpp. References DonTKnow, PixelFormat, releaseMipMaps(), resizeMipMap(), and sint32. Referenced by blend(), NL3D::CHLSColorTexture::buildColorVersion(), NL3D::CTextureFont::CTextureFont(), NL3D::CTextureMem::doGenerate(), NL3D::CTextureGrouped::doGenerate(), NL3D::CTextureCross::doGenerate(), NL3D::CTextureFont::dumpTextureFont(), NL3D::CCoarseMeshBuild::expand(), and NL3D::CDriverGL::getBufferPart(). { // 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); }

void NLMISC::CBitmap::resizeMipMap (  uint32  numMipMap, sint32  nNewWidth, sint32  nNewHeight, bool  resetTo0 = true )

ADVANCED USE Resize a single mipmap level. resize() should have been called before. This is not a crop. Pixels are lost after resize. No validity check is made. It is the user responsabitility fo setup correct mipmap size. Parameters: numMipMap  id of the mipmap nNewWidth  width after resize nNewHeight  height after resize resetTo0  by default the vector are filled by 0. set false to gain performances. Definition at line 1565 of file bitmap.cpp. References bitPerPixels, NLMISC::contReset(), NLMISC::CObjectVector< uint8 >::fill(), NLMISC::MAX_MIPMAP, nlassert, PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), sint32, and uint32. Referenced by NL3D::CHLSColorTexture::buildColorVersion(), and resize(). { 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); }

bool NLMISC::CBitmap::rgbaToAlpha (   )  [private]

Definition at line 708 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToAlpha(). { 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; }

bool NLMISC::CBitmap::rgbaToAlphaLuminance (   )  [private]

Definition at line 550 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToAlphaLuminance(). { 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; }

bool NLMISC::CBitmap::rgbaToLuminance (   )  [private]

Definition at line 635 of file bitmap.cpp. References _MipMapCount, NLMISC::contReset(), PixelFormat, NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CObjectVector< uint8 >::size(), size, uint, uint32, and uint8. Referenced by convertToLuminance(). { 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; }

void NLMISC::CBitmap::rot90CCW (   )

Rotation of the bitmap of 90 degree in counter clockwise Definition at line 2781 of file bitmap.cpp. References _MipMapCount, buildMipMaps(), NLMISC::contReset(), getHeight(), getWidth(), PixelFormat, releaseMipMaps(), NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, sint32, and uint32. { 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 NLMISC::CBitmap::rot90CW (   )

Rotation of the bitmap of 90 degree in clockwise Definition at line 2746 of file bitmap.cpp. References _MipMapCount, buildMipMaps(), NLMISC::contReset(), getHeight(), getWidth(), PixelFormat, releaseMipMaps(), NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), RGBA, sint32, and uint32. { 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 NLMISC::CBitmap::rotateCCW (   )

Rotate a bitmap in CCW mode. See also: releaseMipMaps(). Definition at line 2306 of file bitmap.cpp. References PixelFormat, RGBA, NLMISC::rotateCCW(), uint16, and uint32. { // 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 NLMISC::CBitmap::setMipMapCount (  uint32  mmc  )

ADVANCED USE To use in conjunction with resizeMipMap. Setup the correct total number of mipmap No validity check is made. It is the user responsabitility fo setup correct mipmap count. Definition at line 1590 of file bitmap.cpp. References _MipMapCount, uint32, and uint8. Referenced by NL3D::CHLSColorTexture::buildColorVersion(). { _MipMapCount= uint8(mmc); }

void NLMISC::CBitmap::uncompress (  uint16  color, NLMISC::CRGBA &  )  [inline, static, private]

Extracting RGBA infos from a 16bits word. (used by S3TC decompression) Parameters: color  a 16bits integer r  a CRGBA Definition at line 1350 of file bitmap.cpp. References r, and uint16. Referenced by decompressDXT1(), decompressDXT3(), decompressDXT5(), and getDXTCColorFromBlock(). { 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; }

bool NLMISC::CBitmap::writeJPG (  NLMISC::IStream &  f, uint8  quality = 80 )  [inline]

Write a JPG from the object pixels buffer. If the current pixel format is not rgba then the method does nothing If the pixel format is Alpha then we save in 8 bpp Parameters: f  IStream (must be a reading stream) quality  0=very bad quality 100=best quality Returns: true if succeed, false else Definition at line 620 of file bitmap.h. References nlwarning, and uint8. { nlwarning ("You must put #define USE_JPEG before all include in the file where you call writeJPG() if you want jpeg support"); return false; }

bool NLMISC::CBitmap::writeTGA (  NLMISC::IStream &  f, uint32  d, bool  upsideDown = false )

Write a TGA (24 or 32 bits) from the object pixels buffer. If the current pixel format is not rgba then the method does nothing If the pixel format is Alpha then we save in 8 bpp Parameters: f  IStream (must be a reading stream) d  depth : 8 or 16 or 24 or 32 upsideDown  if true, the bitmap will be saved with the upside down Returns: true if succeed, false else Definition at line 2139 of file bitmap.cpp. References depth, height, NLMISC::IStream::isReading(), PixelFormat, r, RGBA, NLMISC::IStream::serial(), sint32, uint16, uint32, uint8, width, x, and y. Referenced by NL3D::CTextureFont::dumpTextureFont(), NL3D::CZoneLighter::lightWater(), and NL3D::CNELU::screenshot(). { if(f.isReading()) return false; 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 = (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; }

---

Field Documentation

CObjectVector<uint8> NLMISC::CBitmap::_Data[MAX_MIPMAP] [protected]

Reimplemented in NL3D::CTextureMem. Definition at line 90 of file bitmap.h. Referenced by blend().

uint32 NLMISC::CBitmap::_Height [protected]

Definition at line 96 of file bitmap.h. Referenced by blend().

bool NLMISC::CBitmap::_LoadGrayscaleAsAlpha [protected]

Definition at line 94 of file bitmap.h. Referenced by CBitmap(), isGrayscaleAsAlpha(), loadGrayscaleAsAlpha(), and readTGA().

uint8 NLMISC::CBitmap::_MipMapCount [protected]

Definition at line 93 of file bitmap.h. Referenced by alphaLuminanceToAlpha(), alphaLuminanceToLuminance(), alphaLuminanceToRGBA(), alphaToAlphaLuminance(), alphaToRGBA(), buildMipMaps(), CBitmap(), decompressDXT1(), decompressDXT3(), decompressDXT5(), flipH(), flipV(), getMipMapCount(), luminanceToAlpha(), luminanceToAlphaLuminance(), luminanceToRGBA(), makeDummy(), readDDS(), readTGA(), releaseMipMaps(), resample(), reset(), rgbaToAlpha(), rgbaToAlphaLuminance(), rgbaToLuminance(), rot90CCW(), rot90CW(), and setMipMapCount().

uint32 NLMISC::CBitmap::_Width [protected]

Definition at line 95 of file bitmap.h. Referenced by blend().

const uint32 NLMISC::CBitmap::bitPerPixels [static]

Initial value: { 32, 8, 8, 16, 4, 4, 8, 8, 16 } Definition at line 70 of file bitmap.cpp. Referenced by blit(), and resizeMipMap().

const uint32 NLMISC::CBitmap::DXTC1HEADER = NL_MAKEFOURCC('D','X', 'T', '1') [static]

Definition at line 83 of file bitmap.cpp. Referenced by readDDS().

const uint32 NLMISC::CBitmap::DXTC3HEADER = NL_MAKEFOURCC('D','X', 'T', '3') [static]

Definition at line 84 of file bitmap.cpp. Referenced by readDDS().

const uint32 NLMISC::CBitmap::DXTC5HEADER = NL_MAKEFOURCC('D','X', 'T', '5') [static]

Definition at line 85 of file bitmap.cpp. Referenced by readDDS().

enum NLMISC::CBitmap::TType NLMISC::CBitmap::PixelFormat

Referenced by alphaLuminanceToAlpha(), alphaLuminanceToLuminance(), alphaLuminanceToRGBA(), alphaToAlphaLuminance(), alphaToLuminance(), alphaToRGBA(), blend(), blit(), NL3D::CTextureFile::buildBitmapFromFile(), buildMipMaps(), CBitmap(), convertToAlpha(), convertToAlphaLuminance(), convertToLuminance(), convertToRGBA(), convertToType(), decompressDXT1(), decompressDXT3(), decompressDXT5(), flipH(), flipV(), getColor(), getPixelColor(), getPixelFormat(), luminanceToAlpha(), luminanceToAlphaLuminance(), luminanceToRGBA(), makeDummy(), readDDS(), readTGA(), resample(), reset(), resize(), resizeMipMap(), rgbaToAlpha(), rgbaToAlphaLuminance(), rgbaToLuminance(), rot90CCW(), rot90CW(), rotateCCW(), NL3D::sameDXTCFormat(), and writeTGA().

---

The documentation for this class was generated from the following files:

• bitmap.h
• bitmap.cpp

---