NL3D::ITexture Class Reference

#include <texture.h>

Inheritance diagram for NL3D::ITexture:

---

Detailed Description

Interface for textures

Sharing System note: The deriver may implement sharing system by implement supportSharing() and getShareName(). Such a texture may return a Unique Name for sharing. If the driver already has this texture, it will reuse it. As a direct impact, you cannot invalidate part of the textures with shared texture. This is logic, since the Unique sharname of the texture must represent all of it.

Definition at line 106 of file texture.h.

Public Types
enum	TMagFilter { Nearest = 0, Linear, MagFilterCount }
enum	TMinFilter {   NearestMipMapOff = 0, NearestMipMapNearest, NearestMipMapLinear, LinearMipMapOff,   LinearMipMapNearest, LinearMipMapLinear, MinFilterCount }
enum	TType {   RGBA = 0, Luminance, Alpha, AlphaLuminance,   DXTC1, DXTC1Alpha, DXTC3, DXTC5,   DsDt, ModeCount, DonTKnow = 0xffffffff }
enum	TUploadFormat {   Auto = 0, RGBA8888, RGBA4444, RGBA5551,   RGB888, RGB565, DXTC1, DXTC1Alpha,   DXTC3, DXTC5, Luminance, Alpha,   AlphaLuminance, DsDt, UploadFormatCount }
enum	TWrapMode { Repeat = 0, Clamp, WrapModeCount }
Public Member Functions
virtual bool	allowDegradation () const
	Does this texture allow the driver to degrade.
void	blend (CBitmap &Bm0, CBitmap &Bm1, uint16 factor, bool inputBitmapIsMutable=false)
bool	blit (const CBitmap *src, sint32 x, sint32 y)
void	buildMipMaps ()
virtual ITexture *	buildNonSelectableVersion (uint index)
void	clearTouched (void)
bool	convertToType (TType type)
void	flipH ()
void	flipV ()
void	generate (bool async=false)
virtual std::string	getClassName ()=0
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
const sint &	getRefCount () const
bool	getReleasable () const
virtual std::string	getShareName () const
uint32	getSize (uint32 numMipMap=0) const
virtual uint32	getWidth (uint32 numMipMap=0) const
bool	isAllInvalidated () const
virtual bool	isBumpMap () const
bool	isGrayscaleAsAlpha () const
virtual bool	isSelectable () const
	Test wether this texture is selectable.
uint8	load (NLMISC::IStream &f, uint mipMapSkip=0)
void	loadGrayscaleAsAlpha (bool loadAsAlpha)
void	makeDummy ()
virtual void	release ()
void	releaseDriverSetup ()
	Release the Driver info for this texture (if any). Call it with care.
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 ()
virtual void	selectTexture (uint index)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
	serial ITexture basic infos (clamp ...).
void	setMipMapCount (uint32 mmc)
void	setReleasable (bool r)
bool	setupedIntoDriver () const
virtual bool	supportSharing () const
void	touch ()
bool	touched (void)
void	touchRect (const NLMISC::CRect &rect)
void	validateGenerateFlag ()
bool	writeJPG (NLMISC::IStream &f, uint8 quality=80)
bool	writeTGA (NLMISC::IStream &f, uint32 d, bool upsideDown=false)
	ITexture (const ITexture &tex)
	see operator=.
	ITexture ()
	By default, a texture is releasable.
ITexture &	operator= (const ITexture &tex)
	The operator= do not copy drv info, and set touched=true. _Releasable, WrapMode and UploadFormat are copied.
virtual	~ITexture ()
	Need a virtual dtor.
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
std::list< NLMISC::CRect >	_ListInvalidRect
sint	crefs
CPtrInfo *	pinfo
enum NLMISC::CBitmap::TType	PixelFormat
NLMISC::CRefPtr< CTextureDrvShare >	TextureDrvShare
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')
CPtrInfo	NullPtrInfo
Protected Member Functions
virtual void	doGenerate (bool async=false)=0
Protected Attributes
CObjectVector< uint8 >	_Data [MAX_MIPMAP]
uint32	_Height
bool	_LoadGrayscaleAsAlpha
uint8	_MipMapCount
bool	_Touched
uint32	_Width
Private Attributes
bool	_GoodGenerate
TMagFilter	_MagFilter
TMinFilter	_MinFilter
bool	_Releasable
TUploadFormat	_UploadFormat
TWrapMode	_WrapS
TWrapMode	_WrapT
Friends
struct	CPtrInfo

---

Member Enumeration Documentation

enum NL3D::ITexture::TMagFilter

Magnification mode. Same behavior as OpenGL. Enumeration values: Nearest  Linear  MagFilterCount  Definition at line 148 of file texture.h. Referenced by getMagFilter(). { Nearest=0, Linear, MagFilterCount };

enum NL3D::ITexture::TMinFilter

Minifying mode. Same behavior as OpenGL. If the bitmap has no mipmap, and mipmap is required, then mipmaps are computed. Enumeration values: NearestMipMapOff  NearestMipMapNearest  NearestMipMapLinear  LinearMipMapOff  LinearMipMapNearest  LinearMipMapLinear  MinFilterCount  Definition at line 159 of file texture.h. Referenced by getMinFilter(). { NearestMipMapOff=0, NearestMipMapNearest, NearestMipMapLinear, LinearMipMapOff, LinearMipMapNearest, LinearMipMapLinear, MinFilterCount };

enum NLMISC::CBitmap::TType [inherited]

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;

enum NL3D::ITexture::TUploadFormat

Enumeration values: Auto  RGBA8888  RGBA4444  RGBA5551  RGB888  RGB565  DXTC1  DXTC1Alpha  DXTC3  DXTC5  Luminance  Alpha  AlphaLuminance  DsDt  UploadFormatCount  Definition at line 125 of file texture.h. Referenced by getUploadFormat(). { Auto= 0, RGBA8888, RGBA4444, RGBA5551, RGB888, RGB565, DXTC1, DXTC1Alpha, DXTC3, DXTC5, Luminance, Alpha, AlphaLuminance, DsDt, UploadFormatCount };

enum NL3D::ITexture::TWrapMode

Enumeration values: Repeat  Clamp  WrapModeCount  Definition at line 117 of file texture.h. { Repeat= 0, Clamp, WrapModeCount };

---

Constructor & Destructor Documentation

NL3D::ITexture::ITexture (   )

By default, a texture is releasable. Definition at line 43 of file texture.cpp. References _GoodGenerate, _MagFilter, _MinFilter, _Releasable, _UploadFormat, _WrapS, _WrapT, Auto, and LinearMipMapLinear. { _Touched= false; _GoodGenerate= false; _Releasable= true; _WrapS= _WrapT= Repeat; _UploadFormat= Auto; _MagFilter= Linear; _MinFilter= LinearMipMapLinear; }

NL3D::ITexture::ITexture (  const ITexture &  tex  )  [inline]

see operator=. Definition at line 179 of file texture.h. References operator=(). {operator=(tex);}

NL3D::ITexture::~ITexture (   )  [virtual]

Need a virtual dtor. Definition at line 56 of file texture.cpp. References releaseDriverSetup(). { // Must kill the drv mirror of this texture. releaseDriverSetup(); }

---

Member Function Documentation

virtual bool NL3D::ITexture::allowDegradation (   )  const [inline, virtual]

Does this texture allow the driver to degrade. Reimplemented in NL3D::CTextureFile, and NL3D::CTextureMem. Definition at line 352 of file texture.h. Referenced by NL3D::CDriverGL::getGlTextureFormat(), NL3D::CDriverGL::setupTextureEx(), and NL3D::CDriverGL::uploadTexture(). { return false; }

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

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 NLMISC::CBitmap::_Data, NLMISC::CBitmap::_Height, NLMISC::CBitmap::_Width, NLMISC::CBitmap::convertToRGBA(), nlassert, NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::resize(), NLMISC::CBitmap::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); } }

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

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 NLMISC::CBitmap::bitPerPixels, NLMISC::CBitmap::DonTKnow, height, nlassert, NLMISC::CBitmap::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 (   )  [inherited]

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 NLMISC::CBitmap::_MipMapCount, NLMISC::CRGBA::A, NLMISC::CRGBA::B, NLMISC::CRGBA::G, NLMISC::isPowerOf2(), NLMISC::CBitmap::PixelFormat, NLMISC::CRGBA::R, NLMISC::CObjectVector< uint8 >::resize(), NLMISC::CBitmap::RGBA, sint, uint32, and w. Referenced by NL3D::CHLSColorTexture::addMask(), NL3D::CTextureMem::doGenerate(), NLMISC::CBitmap::flipH(), NLMISC::CBitmap::flipV(), NLMISC::CBitmap::resample(), NLMISC::CBitmap::rot90CCW(), NLMISC::CBitmap::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++; } }

virtual ITexture* NL3D::ITexture::buildNonSelectableVersion (  uint  index  )  [inline, virtual]

If this texture is selectable, build a non selectable version of this texture that is setupped with the given slot. NB : If this texture is selectable, you are ensured that the return pointer is not 'this' Reimplemented in NL3D::CTextureCube, and NL3D::CTextureMultiFile. Definition at line 368 of file texture.h. References index, and uint. Referenced by NL3D::CMeshBaseInstance::selectTextureSet(). { return this; }

void NL3D::ITexture::clearTouched (  void   )  [inline]

Definition at line 448 of file texture.h. References _ListInvalidRect. Referenced by NL3D::CDriverGL::setupTextureEx(). { _Touched=false; _ListInvalidRect.clear(); }

bool NLMISC::CBitmap::convertToType (  TType  type  )  [inherited]

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 NLMISC::CBitmap::convertToAlpha(), NLMISC::CBitmap::convertToAlphaLuminance(), NLMISC::CBitmap::convertToDXTC5(), NLMISC::CBitmap::convertToLuminance(), NLMISC::CBitmap::convertToRGBA(), NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::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; }

virtual void NL3D::ITexture::doGenerate (  bool  async = false  )  [protected, pure virtual]

Generate the texture pixels. If the invalidate rect list is empty, generate() must rebuild all the texture. If the invalidate rect list is not empty, generate() rebuilds only the invalidate rectangles in the list. See also: isAllInvalidated(), touch(), touched(), touchRect(), clearTouched(), _ListInvalidRect, generate() getReleasable(), setReleasable() Implemented in NL3D::CTextureCross, NL3D::CTextureBlank, NL3D::CTextureBlend, NL3D::CTextureBump, NL3D::CTextureCube, NL3D::CTextureDLM, NL3D::CTextureEmboss, NL3D::CTextureFar, NL3D::CTextureFile, NL3D::CTextureFont, NL3D::CTextureGrouped, NL3D::CTextureMem, NL3D::CTextureMultiFile, and NL3D::CTextureNear. Referenced by generate().

void NLMISC::CBitmap::flipH (   )  [inherited]

Horizontal flip (all the columns are flipped) Definition at line 2682 of file bitmap.cpp. References NLMISC::CBitmap::_MipMapCount, NLMISC::CBitmap::buildMipMaps(), NLMISC::CBitmap::getHeight(), NLMISC::CBitmap::getWidth(), NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::releaseMipMaps(), NLMISC::CBitmap::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 (   )  [inherited]

Vertical flip (all the rows are flipped) Definition at line 2714 of file bitmap.cpp. References NLMISC::CBitmap::_MipMapCount, NLMISC::CBitmap::buildMipMaps(), NLMISC::CBitmap::getHeight(), NLMISC::CBitmap::getWidth(), NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::releaseMipMaps(), NLMISC::CBitmap::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(); } }

void NL3D::ITexture::generate (  bool  async = false  )  [inline]

Generate the texture pixels. This method is called by the driver when it needs to generate pixels of the texture. If the texture is used for the first time or if it is touched, the driver will call this method. For exemple, a texture file will load the bitmap in this method. If the invalidate rect list is empty, generate() rebuild all the texture. If the invalidate rect list is not empty, generate() rebuilds only the invalidate rectangles in the list. Don't clear the touch flag or the invalid rectangle list until updating the texture in generate(). It's the generate()'s caller jobs. After generation, if the texture is releasable, the driver will release the texture by calling release(). NB: a flag is maintained to see if the generated bitmap is coherent with texture description (see touch*()). So if you do {generate(); generate();}, you only get 1 real bitmap generation... If, after the doGenerate, the bitmap format is compressed (DXTC) and no mipmaps have been generated, the mipmap are disabled beacause the user probably don't want the driver to unpacks the texture, generates the mipmaps and repacks the dxtc texture (that takes a lot of CPU time). Parameters: async  tells the texture if the call is made asynchronously or not. See also: isAllInvalidated(), touch(), touched(), touchRect(), clearTouched(), _ListInvalidRect getReleasable(), setReleasable() Definition at line 309 of file texture.h. References _GoodGenerate, and doGenerate(). Referenced by NL3D::CShadowMapManager::allocateTexture(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CTextureCube::doGenerate(), NL3D::CZoneLighter::getTexture(), NL3D::GetTextureSize(), NL3D::CTileBank::getTileNoiseMap(), NL3D::CZoneLighter::lightWater(), NL3D::CAsyncFileManager3D::CTextureLoad::run(), NL3D::CAsyncFileManager3D::CMeshLoad::run(), NL3D::CPSMultiTexturedParticle::setupMaterial(), and NL3D::CDriverGL::setupTextureEx(). { if(!_GoodGenerate) { doGenerate(async); _GoodGenerate=true; } }

virtual std::string NLMISC::IClassable::getClassName (   )  [pure virtual, inherited]

Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc. Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize().

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

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, NLMISC::CBitmap::getColorInterp(), NLMISC::CBitmap::getHeight(), NLMISC::CBitmap::getPixelColor(), NLMISC::CBitmap::getPixels(), NLMISC::CBitmap::getWidth(), nlassert, NLMISC::CBitmap::PixelFormat, NLMISC::CRGBAF::R, NLMISC::CBitmap::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); }

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

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(), NLMISC::CBitmap::flipH(), NLMISC::CBitmap::flipV(), NL3D::CPatchDLMContext::generate(), NLMISC::CBitmap::getColor(), NLMISC::CBitmap::getDXTC1Texel(), NLMISC::CBitmap::getDXTC3Texel(), NLMISC::CBitmap::getDXTC5Texel(), NLMISC::CBitmap::getRGBAPixel(), NLMISC::CBitmap::getSize(), NL3D::GetTextureSize(), NL3D::CTileBank::getTileNoiseMap(), NL3D::CZoneLighter::lightWater(), NL3D::CShapeBank::processWSUploadTexture(), RenderTriangle(), NLMISC::CBitmap::rot90CCW(), NLMISC::CBitmap::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; }

TMagFilter NL3D::ITexture::getMagFilter (   )  const [inline]

Definition at line 214 of file texture.h. References _MagFilter, and TMagFilter. Referenced by NL3D::CDriverGL::activateTexture(), and NL3D::CDriverGL::setupTextureEx(). {return _MagFilter;}

TMinFilter NL3D::ITexture::getMinFilter (   )  const [inline]

Definition at line 215 of file texture.h. References _MinFilter, and TMinFilter. Referenced by NL3D::CDriverGL::activateTexture(), and NL3D::CDriverGL::setupTextureEx(). {return _MinFilter;}

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

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 NLMISC::CBitmap::_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 [inherited]

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 NLMISC::CBitmap::getDXTC1Texel(), NLMISC::CBitmap::getDXTC3Texel(), NLMISC::CBitmap::getDXTC5Texel(), NLMISC::CBitmap::getRGBAPixel(), nlstop, NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::RGBA, sint, uint32, x, and y. Referenced by NLMISC::CBitmap::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, inherited]

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 NLMISC::CBitmap::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, inherited]

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, inherited]

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(), NLMISC::CBitmap::getColor(), NLMISC::CBitmap::getDXTC1Texel(), NLMISC::CBitmap::getDXTC3Texel(), NLMISC::CBitmap::getDXTC5Texel(), NLMISC::CBitmap::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]; }

const sint& NLMISC::CRefCount::getRefCount (   )  const [inline, inherited]

Definition at line 70 of file smart_ptr.h. References NLMISC::CRefCount::crefs, and sint. { return crefs; }

bool NL3D::ITexture::getReleasable (   )  const [inline]

Return whether texture can be released. If it returns true, the driver will release the texture after generate it and upload it into the videomemory by calling release(). If it returns false, the driver won't release the texture. Returns: true if texture can be released, false else See also: setReleasable(), generate() Definition at line 267 of file texture.h. References _Releasable. Referenced by NL3D::CTextureBump::getNormalizationFactor(), NL3D::GetTextureSize(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CDriverGL::setupTextureEx(), and NL3D::CAsyncTextureManager::uploadTexturePart(). { return _Releasable; }

virtual std::string NL3D::ITexture::getShareName (   )  const [inline, virtual]

Return the Unique ident/name of the texture, used for Driver sharing caps. Deriver should add a prefix for their texture type. eg "file::pipoland", "noise::4-4-2" etc.... Reimplemented in NL3D::CTextureBlend, NL3D::CTextureBump, NL3D::CTextureCube, NL3D::CTextureEmboss, NL3D::CTextureFile, NL3D::CTextureGrouped, NL3D::CTextureMem, and NL3D::CTextureMultiFile. Definition at line 338 of file texture.h. Referenced by NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CZoneLighter::getTexture(), NL3D::IDriver::getTextureShareName(), NL3D::CCoarseMeshBuild::remapCoordinates(), and NL3D::CAsyncFileManager3D::CMeshLoad::run(). {return std::string();}

uint32 NLMISC::CBitmap::getSize (  uint32  numMipMap = 0  )  const [inherited]

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 NLMISC::CBitmap::getHeight(), NLMISC::CBitmap::getWidth(), and uint32. Referenced by NL3D::CShapeBank::processWSUploadTexture(), NL3D::CDriverGL::setupTextureEx(), NL3D::CAsyncTextureManager::update(), and NL3D::CAsyncTextureManager::uploadTexturePart(). { return getHeight(numMipMap)*getWidth(numMipMap); }

TUploadFormat NL3D::ITexture::getUploadFormat (   )  const [inline]

Definition at line 212 of file texture.h. References _UploadFormat, and TUploadFormat. Referenced by NL3D::CTextureBump::doGenerate(), NL3D::CDriverGL::getGlTextureFormat(), and NL3D::IDriver::getTextureShareName(). {return _UploadFormat;}

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

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(), NLMISC::CBitmap::flipH(), NLMISC::CBitmap::flipV(), NL3D::CPatchDLMContext::generate(), NLMISC::CBitmap::getColor(), NLMISC::CBitmap::getDXTC1Texel(), NLMISC::CBitmap::getDXTC3Texel(), NLMISC::CBitmap::getDXTC5Texel(), NLMISC::CBitmap::getRGBAPixel(), NLMISC::CBitmap::getSize(), NL3D::GetTextureSize(), NL3D::CTileBank::getTileNoiseMap(), NL3D::CZoneLighter::lightWater(), NL3D::CTextureDLM::modulateAndfillRect565(), NL3D::CTextureDLM::modulateAndfillRect8888(), NL3D::CTextureDLM::modulateConstantAndfillRect(), NL3D::CShapeBank::processWSUploadTexture(), RenderTriangle(), NLMISC::CBitmap::rot90CCW(), NLMISC::CBitmap::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; }

TWrapMode NL3D::ITexture::getWrapS (   )  const [inline]

Definition at line 204 of file texture.h. References _WrapS. Referenced by NL3D::CDriverGL::activateTexture(), NL3D::CZoneLighter::getTexture(), and NL3D::CDriverGL::setupTextureEx(). {return _WrapS;}

TWrapMode NL3D::ITexture::getWrapT (   )  const [inline]

Definition at line 205 of file texture.h. References _WrapT. Referenced by NL3D::CDriverGL::activateTexture(), NL3D::CZoneLighter::getTexture(), and NL3D::CDriverGL::setupTextureEx(). {return _WrapT;}

bool NL3D::ITexture::isAllInvalidated (   )  const [inline]

Return true if ALL the texture is invalidate, else return false. Definition at line 428 of file texture.h. References _ListInvalidRect. Referenced by NL3D::CDriverGL::setupTextureEx(), and touchRect(). { return _Touched&&(_ListInvalidRect.begin()==_ListInvalidRect.end()); }

virtual bool NL3D::ITexture::isBumpMap (   )  const [inline, virtual]

Reimplemented in NL3D::CTextureBump. Definition at line 380 of file texture.h. Referenced by NL3D::CDriverGL::setupWaterPassARB(), NL3D::CDriverGL::setupWaterPassNV20(), and NL3D::CDriverGL::setupWaterPassR200(). { return false; }

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

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 NLMISC::CBitmap::_LoadGrayscaleAsAlpha. { return _LoadGrayscaleAsAlpha; }

virtual bool NL3D::ITexture::isSelectable (   )  const [inline, virtual]

Test wether this texture is selectable. Reimplemented in NL3D::CTextureCube, and NL3D::CTextureMultiFile. Definition at line 363 of file texture.h. Referenced by NL3D::CMeshBaseInstance::selectTextureSet(). { return false; }

virtual bool NL3D::ITexture::isTextureCube (   )  const [inline, virtual]

Does this texture is a cube texture. Reimplemented in NL3D::CTextureCube. Definition at line 376 of file texture.h. Referenced by NL3D::CDriverGL::activateTexture(), NL3D::convTexAddr(), NL3D::CDriverGL::copyFrameBufferToTexture(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CDriverGL::setTextureEnvFunction(), NL3D::CDriverGL::setupTextureEx(), NL3D::CDriverGL::uploadTexture(), and NL3D::CDriverGL::uploadTextureCube(). { return false; }

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

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, NLMISC::CBitmap::readDDS(), NLMISC::CBitmap::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, inherited]

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 NLMISC::CBitmap::_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, inherited]

same than other loadSize(), but with a pathName. See also: loadSize() Definition at line 2671 of file bitmap.cpp. References NLMISC::CBitmap::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, inherited]

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 NLMISC::CBitmap::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(); } }

void NLMISC::CBitmap::makeDummy (   )  [inherited]

Make a dummy "?" texture. Usefull for file not found. Mode is rgba. Definition at line 184 of file bitmap.cpp. References NLMISC::CBitmap::_MipMapCount, NLMISC::CObjectVector< uint8 >::getPtr(), NLMISC::CBitmap::PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), NLMISC::CBitmap::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); } }

bool NL3D::ITexture::mipMapOff (   )  const [inline]

Definition at line 216 of file texture.h. References _MinFilter, LinearMipMapOff, and NearestMipMapOff. Referenced by mipMapOn(), and setFilterMode(). {return _MinFilter==NearestMipMapOff || _MinFilter==LinearMipMapOff;}

bool NL3D::ITexture::mipMapOn (   )  const [inline]

Definition at line 217 of file texture.h. References mipMapOff(). Referenced by NL3D::IDriver::getTextureShareName(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CDriverGL::setupTextureEx(), and NL3D::CDriverGL::uploadTexture(). {return !mipMapOff();}

ITexture & NL3D::ITexture::operator= (  const ITexture &  tex  )

The operator= do not copy drv info, and set touched=true. _Releasable, WrapMode and UploadFormat are copied. Definition at line 72 of file texture.cpp. References _MagFilter, _MinFilter, _Releasable, _UploadFormat, _WrapS, _WrapT, and touch(). Referenced by ITexture(). { // The operator= do not copy drv info // set touched=true. _Releasable is copied. _UploadFormat= tex._UploadFormat; _Releasable= tex._Releasable; _WrapS= tex._WrapS; _WrapT= tex._WrapT; _MagFilter= tex._MagFilter; _MinFilter= tex._MinFilter; touch(); return *this; }

virtual void NL3D::ITexture::release (  void   )  [inline, virtual]

Release the texure (free memory) Reimplemented in NL3D::CTextureBlend, NL3D::CTextureBump, NL3D::CTextureCube, NL3D::CTextureEmboss, and NL3D::CTextureGrouped. Definition at line 327 of file texture.h. References _GoodGenerate, and NLMISC::CBitmap::reset(). Referenced by NL3D::CZoneLighter::getTexture(), NL3D::GetTextureSize(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CDriverGL::setupTextureEx(), and NL3D::CAsyncTextureManager::update(). { reset(); _GoodGenerate= false; }

void NL3D::ITexture::releaseDriverSetup (   )

Release the Driver info for this texture (if any). Call it with care. Definition at line 64 of file texture.cpp. References NLMISC::CRefPtr< CTextureDrvShare >::kill(), and TextureDrvShare. Referenced by NL3D::CMeshBaseInstance::isAsyncTextureReady(), and ~ITexture(). { // Must kill the drv mirror of this texture. TextureDrvShare.kill(); }

void NLMISC::CBitmap::releaseMipMaps (   )  [inherited]

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 NLMISC::CBitmap::_MipMapCount, NLMISC::contReset(), NLMISC::MAX_MIPMAP, and sint. Referenced by NL3D::CAsyncTextureManager::CTextureEntry::createCoarseBitmap(), NL3D::CTextureEmboss::doGenerate(), NL3D::CTextureBump::doGenerate(), NLMISC::CBitmap::flipH(), NLMISC::CBitmap::flipV(), NLMISC::CBitmap::resample(), NLMISC::CBitmap::resize(), NLMISC::CBitmap::rot90CCW(), NLMISC::CBitmap::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 )  [inherited]

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 NLMISC::CBitmap::_MipMapCount, NLMISC::CBitmap::buildMipMaps(), NLMISC::contReset(), nlassert, NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::releaseMipMaps(), NLMISC::CBitmap::resamplePicture32(), NLMISC::CObjectVector< T, EnableObjectBehavior >::resize(), NLMISC::CBitmap::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::reset (  TType  type = RGBA  )  [inherited]

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 NLMISC::CBitmap::_MipMapCount, NLMISC::contReset(), NLMISC::CBitmap::PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), type, and uint. Referenced by NL3D::CHLSColorTexture::buildColorVersion(), NL3D::CDriverGL::getBufferPart(), and 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 )  [inherited]

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 NLMISC::CBitmap::DonTKnow, NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::releaseMipMaps(), NLMISC::CBitmap::resizeMipMap(), and sint32. Referenced by NLMISC::CBitmap::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 )  [inherited]

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 NLMISC::CBitmap::bitPerPixels, NLMISC::contReset(), NLMISC::CObjectVector< uint8 >::fill(), NLMISC::MAX_MIPMAP, nlassert, NLMISC::CBitmap::PixelFormat, NLMISC::CObjectVector< uint8 >::resize(), sint32, and uint32. Referenced by NL3D::CHLSColorTexture::buildColorVersion(), and NLMISC::CBitmap::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); }

void NLMISC::CBitmap::rot90CCW (   )  [inherited]

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

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

Rotate a bitmap in CCW mode. See also: releaseMipMaps(). Definition at line 2306 of file bitmap.cpp. References NLMISC::CBitmap::PixelFormat, NLMISC::CBitmap::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; }

virtual void NL3D::ITexture::selectTexture (  uint  index  )  [inline, virtual]

Select a texture among several other (if this texture is a set of texture such as CTextureMultiFile) The default does nothing Reimplemented in NL3D::CTextureCube, and NL3D::CTextureMultiFile. Definition at line 360 of file texture.h. References index, and uint. Referenced by NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CCoarseMeshBuild::remapCoordinates(), and NL3D::CAsyncFileManager3D::CMeshLoad::run(). {}

void NL3D::ITexture::serial (  NLMISC::IStream &  f  )  throw (NLMISC::EStream) [virtual]

serial ITexture basic infos (clamp ...). Implements NLMISC::IStreamable. Reimplemented in NL3D::CTextureCross, NL3D::CTextureBlend, NL3D::CTextureBump, NL3D::CTextureCube, NL3D::CTextureDLM, NL3D::CTextureEmboss, NL3D::CTextureFar, NL3D::CTextureFile, NL3D::CTextureFont, NL3D::CTextureGrouped, NL3D::CTextureMem, NL3D::CTextureMultiFile, and NL3D::CTextureNear. Definition at line 133 of file texture.cpp. References sint. Referenced by NL3D::CPSRibbon::serial(), and NL3D::CFlareShape::serial(). { /* Version 1: - _LoadGrayscaleAsAlpha Version 0: - base version. */ sint ver= f.serialVersion(1); f.serialEnum(_UploadFormat); f.serialEnum(_WrapS); f.serialEnum(_WrapT); f.serialEnum(_MinFilter); f.serialEnum(_MagFilter); if(ver>=1) f.serial(_LoadGrayscaleAsAlpha); }

void NL3D::ITexture::setFilterMode (  TMagFilter  magf, TMinFilter  minf )  [virtual]

Reimplemented in NL3D::CTextureBump. Definition at line 100 of file texture.cpp. References _MagFilter, _MinFilter, mipMapOff(), and touch(). Referenced by NL3D::CShadowMapManager::allocateTexture(), NL3D::CTextureDLM::CTextureDLM(), NL3D::CTextureFar::CTextureFar(), NL3D::CTextureFont::CTextureFont(), NL3D::CTextureGrouped::CTextureGrouped(), NL3D::CTextureNear::CTextureNear(), and NL3D::CVegetableManager::loadTexture(). { _MagFilter= magf; // If the MipMap mode has siwtched Off/On, then must recompute... bool precOff= mipMapOff(); _MinFilter= minf; bool nowOff= mipMapOff(); if(precOff!=nowOff) { // Must recompute mipmaps!! touch(); } }

void NLMISC::CBitmap::setMipMapCount (  uint32  mmc  )  [inherited]

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 NLMISC::CBitmap::_MipMapCount, uint32, and uint8. Referenced by NL3D::CHLSColorTexture::buildColorVersion(). { _MipMapCount= uint8(mmc); }

void NL3D::ITexture::setReleasable (  bool  r  )  [inline]

Set if texture can be released If it is true, the driver will release the texture after generating it and upload it into the videomemory by calling release(). If it is false, the driver won't release the texture. See also: getReleasable(), generate() Parameters: true  if texture can be released, false else Definition at line 278 of file texture.h. References _Releasable, and r. Referenced by NL3D::CShadowMapManager::allocateTexture(), NL3D::CTextureDLM::CTextureDLM(), NL3D::CTextureFar::CTextureFar(), NL3D::CTextureFont::CTextureFont(), NL3D::CTextureNear::CTextureNear(), NL3D::CShapeBank::processWSUploadTexture(), NL3D::CWaterPoolManager::releaseBlendTextures(), NL3D::CWaterPoolManager::setBlendFactor(), and NL3D::CAsyncTextureManager::uploadTexturePart(). { _Releasable = r; }

bool NL3D::ITexture::setupedIntoDriver (   )  const [inline]

Tells if the texture has been setuped by the driver. Definition at line 343 of file texture.h. References TextureDrvShare. { return TextureDrvShare!=NULL; }

void NL3D::ITexture::setUploadFormat (  TUploadFormat  pf  )

Replace the uploaded format of the texture. If "Auto", the driver use CBitmap::getPixelFormat() to find the best associated pixelFormat. When no alpha is wanted (RGB, Luminance....), texture default output is 1.0. For "Alpha" mode, RGB output is (0,0,0). Definition at line 88 of file texture.cpp. References _UploadFormat, and touch(). Referenced by NL3D::CTextureDLM::CTextureDLM(), NL3D::CTextureFar::CTextureFar(), NL3D::CTextureFont::CTextureFont(), NL3D::CTextureNear::CTextureNear(), NL3D::CDriverGL::getSpecularCubeMap(), and NL3D::CDriverGL::setupWaterPassARB(). { if(pf!=_UploadFormat) { _UploadFormat= pf; // All the texture may be reloaded... touch(); } }

void NL3D::ITexture::setWrapS (  TWrapMode  mode  )  [inline]

By default, parameters are: WrapS==Repeat WrapT==Repeat UploadFormat== Auto MagFilter== Linear. MinFilter= LinearMipMapLinear. NB: if multiple ITexture acces the same data via the sharing system (such as a CTextureFile), then: WrapS/WrapT is LOCAL for each ITexture (ie each ITexture will have his own Wrap mode) => no duplication is made. UploadFormat may duplicate the texture in video memory. There is one texture per different UploadFormat. MinFilter may duplicate the texture in video memory in the same way, wether the texture has mipmap or not. Definition at line 202 of file texture.h. References _WrapS. Referenced by NL3D::CShadowMapManager::allocateTexture(), NL3D::CTextureFar::CTextureFar(), NL3D::CTextureFont::CTextureFont(), NL3D::CVegetableManager::loadTexture(), and NL3D::CSegRemanenceShape::setupMaterial(). {_WrapS= mode;}

void NL3D::ITexture::setWrapT (  TWrapMode  mode  )  [inline]

Definition at line 203 of file texture.h. References _WrapT. Referenced by NL3D::CShadowMapManager::allocateTexture(), NL3D::CTextureFar::CTextureFar(), NL3D::CTextureFont::CTextureFont(), and NL3D::CVegetableManager::loadTexture(). {_WrapT= mode;}

virtual bool NL3D::ITexture::supportSharing (   )  const [inline, virtual]

Does this texture support sharing system. Reimplemented in NL3D::CTextureBlend, NL3D::CTextureBump, NL3D::CTextureCube, NL3D::CTextureEmboss, NL3D::CTextureFile, NL3D::CTextureGrouped, NL3D::CTextureMem, and NL3D::CTextureMultiFile. Definition at line 332 of file texture.h. Referenced by NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CZoneLighter::getTexture(), NL3D::CCoarseMeshBuild::remapCoordinates(), NL3D::CAsyncFileManager3D::CMeshLoad::run(), NL3D::CDriverGL::setupTextureEx(), and touchRect(). {return false;}

void NL3D::ITexture::touch (   )  [inline]

This method invalidates all the texture surface. When the driver calls generate, the texture will rebuild all the texture and the driver will update it. See also: isAllInvalidated(), generate(), touchRect(), touched(), _ListInvalidRect Definition at line 227 of file texture.h. References _GoodGenerate, and _ListInvalidRect. Referenced by NL3D::CTextureFile::CTextureFile(), operator=(), NL3D::CTextureMultiFile::selectTexture(), NL3D::CTextureCube::selectTexture(), NL3D::CTextureEmboss::setAmbient(), NL3D::CTextureBlend::setBlendFactor(), NL3D::CTextureBlend::setBlendTexture(), NL3D::CTextureEmboss::setDiffuse(), NL3D::CTextureMultiFile::setFileName(), NL3D::CTextureFile::setFileName(), setFilterMode(), NL3D::CTextureEmboss::setHeightMap(), NL3D::CTextureBump::setHeightMap(), NL3D::CTextureEmboss::setLightDir(), NL3D::CTextureEmboss::setSlopeFactor(), NL3D::CTextureGrouped::setTextures(), and setUploadFormat(). { _ListInvalidRect.clear (); _Touched=true; _GoodGenerate= false; }

bool NL3D::ITexture::touched (  void   )  [inline]

This method return the touched flag. If it is true, the driver will call generate to rebuild the texture. See also: isAllInvalidated(), generate(), touch(), touchRect(), _ListInvalidRect Definition at line 438 of file texture.h. Referenced by NL3D::CDriverGL::setupTextureEx(). { return _Touched; }

void NL3D::ITexture::touchRect (  const NLMISC::CRect &  rect  )  [inline]

This method invalidates a rectangle of the texture surface. When the driver calls generate, the texture could rebuild only this part of texture and the driver will update only those rectangles. This method is incompatible with textures which support sharing (see class description). See also: isAllInvalidated(), generate(), touch(), touched(), _ListInvalidRect Definition at line 242 of file texture.h. References _GoodGenerate, _ListInvalidRect, isAllInvalidated(), nlassert, and supportSharing(). Referenced by NL3D::CTextureFont::getLetterInfo(). { // The texture must not support sharing.... nlassert(!supportSharing()); // Don't invalidate the rectangle if the full texture is already invalidated. if (!isAllInvalidated ()) { // Add the region to invalidate list _ListInvalidRect.push_back (rect); // Touch flag _Touched=true; } _GoodGenerate= false; }

void NL3D::ITexture::validateGenerateFlag (   )  [inline]

Advanced. erase the _GoodGenerate=true. Special if you want to setup directly the bitmap without using generate(). USE IT WITH CARE!! (used by the CAsyncTextureManager) Definition at line 322 of file texture.h. References _GoodGenerate. {_GoodGenerate=true;}

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

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 )  [inherited]

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(), NLMISC::CBitmap::PixelFormat, r, NLMISC::CBitmap::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; }

---

Friends And Related Function Documentation

friend struct CPtrInfo [friend, inherited]

Definition at line 67 of file smart_ptr.h.

---

Field Documentation

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

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

bool NL3D::ITexture::_GoodGenerate [private]

Definition at line 404 of file texture.h. Referenced by generate(), ITexture(), release(), touch(), touchRect(), and validateGenerateFlag().

uint32 NLMISC::CBitmap::_Height [protected, inherited]

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

std::list<NLMISC::CRect> NL3D::ITexture::_ListInvalidRect

List of invalided rectangle. If the list is empty, generate() will rebuild all the texture. See also: isAllInvalidated(), generate(), touch(), touchRect(), touched() Definition at line 422 of file texture.h. Referenced by clearTouched(), isAllInvalidated(), NL3D::CDriverGL::setupTextureEx(), touch(), and touchRect().

bool NLMISC::CBitmap::_LoadGrayscaleAsAlpha [protected, inherited]

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

TMagFilter NL3D::ITexture::_MagFilter [private]

Definition at line 410 of file texture.h. Referenced by getMagFilter(), ITexture(), operator=(), and setFilterMode().

TMinFilter NL3D::ITexture::_MinFilter [private]

Definition at line 409 of file texture.h. Referenced by getMinFilter(), ITexture(), mipMapOff(), operator=(), and setFilterMode().

uint8 NLMISC::CBitmap::_MipMapCount [protected, inherited]

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

bool NL3D::ITexture::_Releasable [private]

Definition at line 405 of file texture.h. Referenced by getReleasable(), ITexture(), operator=(), and setReleasable().

bool NL3D::ITexture::_Touched [protected]

Definition at line 387 of file texture.h.

TUploadFormat NL3D::ITexture::_UploadFormat [private]

Definition at line 406 of file texture.h. Referenced by getUploadFormat(), ITexture(), operator=(), and setUploadFormat().

uint32 NLMISC::CBitmap::_Width [protected, inherited]

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

TWrapMode NL3D::ITexture::_WrapS [private]

Definition at line 407 of file texture.h. Referenced by getWrapS(), ITexture(), operator=(), and setWrapS().

TWrapMode NL3D::ITexture::_WrapT [private]

Definition at line 408 of file texture.h. Referenced by getWrapT(), ITexture(), operator=(), and setWrapT().

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

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

sint NLMISC::CRefCount::crefs [mutable, inherited]

Definition at line 79 of file smart_ptr.h. Referenced by NLMISC::CRefCount::CRefCount(), NLMISC::CRefCount::getRefCount(), and NLMISC::CRefCount::~CRefCount().

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

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

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

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

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

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

CRefCount::CPtrInfo NLMISC::CRefCount::NullPtrInfo [static, inherited]

Referenced by NLMISC::CRefCount::CRefCount().

CPtrInfo* NLMISC::CRefCount::pinfo [mutable, inherited]

Definition at line 80 of file smart_ptr.h. Referenced by NLMISC::CRefCount::CRefCount(), and NLMISC::CRefCount::~CRefCount().

enum NLMISC::CBitmap::TType NLMISC::CBitmap::PixelFormat [inherited]

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

NLMISC::CRefPtr<CTextureDrvShare> NL3D::ITexture::TextureDrvShare

Definition at line 416 of file texture.h. Referenced by NL3D::CDriverGL::copyFrameBufferToTexture(), NL3D::getTextureGl(), NL3D::CDriverGL::getTextureHandle(), releaseDriverSetup(), setupedIntoDriver(), NL3D::CDriverGL::setupTextureEx(), NL3D::CDriverGL::uploadTexture(), and NL3D::CDriverGL::uploadTextureCube().

---

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

• texture.h
• texture.cpp

---