OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
81 Branches
23 Tags
172 MiB
Tree: ecb7d8b566
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ecb7d8b566'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plGImage/plMipmap.cpp

2195 lines
59 KiB
Raw Normal View History Unescape

Initial Commit of CyanWorlds.com Engine Open Source Client/Plugin
14 years ago
/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
// //
// plMipmap Class Functions //
// Derived bitmap class representing a single mipmap. //
// Cyan, Inc. //
// //
//// Version History //////////////////////////////////////////////////////////
// //
// 6.7.2001 mcn - Created. //
// //
///////////////////////////////////////////////////////////////////////////////
#include "hsTypes.h"
#include "plMipmap.h"
#include "hsStream.h"
#include "hsExceptions.h"
#include "hsUtils.h"
#include "hsColorRGBA.h"
#include "../plPipeline/hsGDeviceRef.h"
#include "plProfile.h"
#include "../plJPEG/plJPEG.h"
plProfile_CreateMemCounter("Mipmaps", "Memory", MemMipmaps);
//// Constructor & Destructor /////////////////////////////////////////////////
plMipmap::plMipmap() : fImage( nil ), fLevelSizes( nil ), fCurrLevelPtr( nil ), fCurrLevel( 0 ), fTotalSize( 0 )
{
SetConfig( kARGB32Config );
fCompressionType = kUncompressed;
fUncompressedInfo.fType = UncompressedInfo::kRGB8888;
#ifdef MEMORY_LEAK_TRACER
fNumMipmaps++;
#endif
}
plMipmap::~plMipmap()
{
Reset();
#ifdef MEMORY_LEAK_TRACER
fNumMipmaps--;
if( fNumMipmaps == 0 )
IReportLeaks();
#endif
}
plMipmap::plMipmap( UInt32 width, UInt32 height, unsigned config, UInt8 numLevels, UInt8 compType, UInt8 format )
{
Create( width, height, config, numLevels, compType, format );
#ifdef MEMORY_LEAK_TRACER
fNumMipmaps++;
#endif
}
//// Create ///////////////////////////////////////////////////////////////////
void plMipmap::Create( UInt32 width, UInt32 height, unsigned config, UInt8 numLevels, UInt8 compType, UInt8 format )
{
int i;
SetConfig( config );
fWidth = width;
fHeight = height;
fRowBytes = fWidth * fPixelSize >> 3;
if( numLevels > 0 )
fNumLevels = numLevels;
else
{
for( fNumLevels = 1; width > 1 || height > 1; fNumLevels++ )
{
if( width > 1 )
width >>= 1;
if( height > 1 )
height >>= 1;
}
}
fCompressionType = compType;
if( compType == kUncompressed )
{
fUncompressedInfo.fType = format;
}
else if( compType == kJPEGCompression )
{
fUncompressedInfo.fType = format;
}
else
{
fDirectXInfo.fBlockSize = ( format == DirectXInfo::kDXT1 ) ? 8 : 16;
fDirectXInfo.fCompressionType = format;
if( format == DirectXInfo::kDXT1 )
{
// Has an alpha bit, but no channel
fFlags |= kAlphaBitFlag;
fFlags &= ~kAlphaChannelFlag;
}
else // All other formats have an actual alpha channel
{
fFlags &= ~kAlphaBitFlag;
fFlags |= kAlphaChannelFlag;
}
}
fLevelSizes = nil;
IBuildLevelSizes();
fTotalSize = 0;
for( i = 0; i < fNumLevels; i++ )
fTotalSize += fLevelSizes[ i ];
fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
memset(fImage, 0, fTotalSize);
SetCurrLevel( 0 );
plProfile_NewMem(MemMipmaps, fTotalSize);
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaCreate );
#endif
}
//// Reset ////////////////////////////////////////////////////////////////////
void plMipmap::Reset()
{
delete [] fLevelSizes;
fLevelSizes = nil;
if( !( fFlags & kUserOwnsBitmap ) )
{
#ifdef MEMORY_LEAK_TRACER
if( fImage != nil )
IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
delete [] fImage;
plProfile_DelMem(MemMipmaps, fTotalSize);
}
fImage = nil;
}
///////////////////////////////////////////////////////////////////////////////
//// Virtual Functions ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//// GetTotalSize /////////////////////////////////////////////////////////////
// Get the total size in bytes
UInt32 plMipmap::GetTotalSize() const
{
return fTotalSize;
}
//// Read /////////////////////////////////////////////////////////////////////
UInt32 plMipmap::Read( hsStream *s )
{
UInt32 totalRead = plBitmap::Read( s );
// Decide to clamp if we were told to
int clampBy = fGlobalNumLevelsToChop;
const kMaxSkipLevels = 1;
if( clampBy > kMaxSkipLevels )
clampBy = kMaxSkipLevels;
if( fFlags & kNoMaxSize )
clampBy = 0;
else if( ( fFlags & kHalfSize ) && clampBy > 1 )
clampBy = 1;
UInt32 amtToSkip = 0;
fWidth = s->ReadSwap32();
fHeight = s->ReadSwap32();
fRowBytes = s->ReadSwap32();
fTotalSize = s->ReadSwap32();
fNumLevels = s->ReadByte();
totalRead += 4 * 4 + 1;
if( fTotalSize == 0 )
fImage = nil;
else
{
IBuildLevelSizes();
if (fCompressionType != kJPEGCompression) // JPEGs don't play nicely with quality settings the way they are written, so we ignore them
{
if( clampBy > 0 )
{
int i;
for( i = 0; i < clampBy && fNumLevels > 1 && fWidth > 4 && fHeight > 4; i++ )
{
amtToSkip += fLevelSizes[ i ];
fWidth >>= 1;
fHeight >>= 1;
fRowBytes >>= 1;
fNumLevels--;
}
fTotalSize -= amtToSkip;
IBuildLevelSizes();
}
}
fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaRead );
#endif
plProfile_NewMem(MemMipmaps, fTotalSize);
switch( fCompressionType )
{
case kDirectXCompression:
s->Skip( amtToSkip );
s->Read( fTotalSize, fImage );
break;
case kUncompressed:
s->Skip( amtToSkip );
IReadRawImage( s );
break;
case kJPEGCompression:
IReadJPEGImage( s );
break;
default:
hsAssert( false, "Unknown compression type in plMipmap::Read()" );
return totalRead;
}
totalRead += fTotalSize;
}
return totalRead;
}
//// Write ////////////////////////////////////////////////////////////////////
UInt32 plMipmap::Write( hsStream *s )
{
UInt32 totalWritten = plBitmap::Write( s );
s->WriteSwap32( fWidth );
s->WriteSwap32( fHeight );
s->WriteSwap32( fRowBytes );
s->WriteSwap32( fTotalSize );
s->WriteByte( fNumLevels );
totalWritten += 4 * 4 + 1;
if( fTotalSize > 0 )
{
switch( fCompressionType )
{
case kDirectXCompression:
s->Write( fTotalSize, fImage );
break;
case kUncompressed:
IWriteRawImage( s );
break;
case kJPEGCompression:
IWriteJPEGImage( s );
break;
default:
hsAssert( false, "Unknown compression type in plMipmap::Read()" );
return totalWritten;
}
totalWritten += fTotalSize;
}
return totalWritten;
}
///////////////////////////////////////////////////////////////////////////////
//// Utility Functions ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//// IReadRawImage ////////////////////////////////////////////////////////////
void plMipmap::IReadRawImage( hsStream *stream )
{
UInt32 i;
UInt8 *data = (UInt8 *)fImage;
switch( fPixelSize )
{
case 32:
for( i = 0; i < fNumLevels; i++ )
{
stream->ReadSwap32( fLevelSizes[ i ] >> 2, (UInt32 *)data );
data += fLevelSizes[ i ];
}
break;
case 16:
for( i = 0; i < fNumLevels; i++ )
{
stream->ReadSwap16( fLevelSizes[ i ] >> 1, (UInt16 *)data );
data += fLevelSizes[ i ];
}
break;
default:
hsThrow( hsBadParamException() );
}
}
//// IWriteRawImage ///////////////////////////////////////////////////////////
void plMipmap::IWriteRawImage( hsStream *stream )
{
UInt32 i;
UInt8 *data = (UInt8 *)fImage;
switch( fPixelSize )
{
case 32:
for( i = 0; i < fNumLevels; i++ )
{
stream->WriteSwap32( fLevelSizes[ i ] >> 2, (UInt32 *)data );
data += fLevelSizes[ i ];
}
break;
case 16:
for( i = 0; i < fNumLevels; i++ )
{
stream->WriteSwap16( fLevelSizes[ i ] >> 1, (UInt16 *)data );
data += fLevelSizes[ i ];
}
break;
default:
hsThrow( hsBadParamException() );
}
}
plMipmap *plMipmap::ISplitAlpha()
{
plMipmap *retVal = TRACKED_NEW plMipmap();
retVal->CopyFrom(this);
memset( retVal->fImage, 0, fTotalSize );
UInt8 *curLoc = (UInt8 *)fImage;
UInt8 *destLoc = (UInt8 *)retVal->fImage;
UInt32 numBytes = fTotalSize;
UInt32 curByte = 0;
switch( fUncompressedInfo.fType )
{
case fUncompressedInfo.kRGB8888:
// first byte is the alpha channel, we will drop this byte into the red channel for compression
while (curByte < numBytes)
{
curLoc += 3;
destLoc += 2; // make the destination pointer point at the red channel
*destLoc = *curLoc; // copy the information
destLoc += 2; // make the destination pointer point at the beginning of the next pixel
curLoc ++; // same here for source pointer
curByte += 4;
}
break;
default:
break; // not going to mess with other formats for now
}
return retVal;
}
// alphaChannel must be in the format generated from ISplitAlpha, or strange things will happen
void plMipmap::IRecombineAlpha( plMipmap *alphaChannel )
{
UInt8 *curLoc = (UInt8 *)alphaChannel->fImage;
UInt8 *destLoc = (UInt8 *)fImage;
UInt32 numBytes = fTotalSize;
UInt32 curByte = 0;
switch( fUncompressedInfo.fType )
{
case fUncompressedInfo.kRGB8888:
// first byte is the alpha channel, we will grab this byte from the red channel for reconstitution
while (curByte < numBytes)
{
curLoc += 2; // pointer points at the red channel (where the alpha is stored)
destLoc += 3;
*destLoc = *curLoc; // copy the data
destLoc++; // move the pointer to the next pixel
curLoc += 2;
curByte += 4;
}
break;
default:
break; // not going to mess with other formats for now
}
fFlags |= plBitmap::kAlphaChannelFlag;
}
plMipmap *plMipmap::IReadRLEImage( hsStream *stream )
{
UInt32 count,color;
bool done = false;
plMipmap *retVal = TRACKED_NEW plMipmap(fWidth,fHeight,plMipmap::kARGB32Config,1);
UInt32 *curPos = (UInt32*)retVal->fImage;
UInt32 curLoc = 0;
while (!done)
{
count = stream->ReadSwap32();
color = stream->ReadSwap32();
if (count == 0)
done = true;
else
{
for (UInt32 i=0; i<count; i++)
{
*curPos = color;
curPos++;
curLoc++;
}
}
}
// We really don't want to suddenly start calling this uncompressed now that it's read in.
// Case in point, on export we load in all previously exported textures (like this JPEG one)
// share those, add any textures that aren't already there, then write the whole thing back
// out. Viola, we just converted our nice small compressed 1024x1024 JPEG (~128k) to a
// monster uncompressed 4Mb which it will remain for ever more.
// retVal->fCompressionType = kUncompressed;
return retVal;
}
void plMipmap::IWriteRLEImage( hsStream *stream, plMipmap *mipmap )
{
UInt32 count=0,color=0,curColor=0;
UInt32 curPos = 0;
UInt32 totalSize = mipmap->fLevelSizes[0]/4; // we only save the first mipmap level
UInt32 *src = (UInt32*)mipmap->fImage;
curColor = *src;
curColor &= 0x00FFFFFF; // strip the alpha (if there is any)
while (curPos < totalSize)
{
color = *src;
color &= 0x00FFFFFF; // strip the alpha (if there is any)
if (color != curColor)
{
stream->WriteSwap32(count);
stream->WriteSwap32(curColor);
count = 0;
curColor = color;
}
count++;
src++;
curPos++;
}
stream->WriteSwap32(count);
stream->WriteSwap32(color);
stream->WriteSwap32(0); // terminate with zero count
stream->WriteSwap32(0);
}
void plMipmap::IReadJPEGImage( hsStream *stream )
{
UInt8 flags = 0;
flags = stream->ReadByte();
plMipmap *temp = nil;
plMipmap *alpha = nil;
if (flags & kColorDataRLE)
temp = IReadRLEImage(stream);
else
temp = plJPEG::Instance().ReadFromStream(stream);
if (temp)
{
// copy the data
CopyFrom(temp);
if (flags & kAlphaDataRLE)
alpha = IReadRLEImage(stream);
else
alpha = plJPEG::Instance().ReadFromStream(stream);
if (alpha)
{
IRecombineAlpha(alpha);
delete alpha;
}
delete temp;
}
}
void plMipmap::IWriteJPEGImage( hsStream *stream )
{
plMipmap *alpha = ISplitAlpha();
UInt8 flags = 0;
hsNullStream *nullStream = TRACKED_NEW hsNullStream();
IWriteRLEImage(nullStream,this);
if (nullStream->GetBytesWritten() < 5120) // we use RLE if it can get the image size under 5k, otherwise we use JPEG
flags |= kColorDataRLE;
delete nullStream;
nullStream = TRACKED_NEW hsNullStream();
IWriteRLEImage(nullStream,alpha);
if (nullStream->GetBytesWritten() < 5120)
flags |= kAlphaDataRLE;
delete nullStream;
stream->WriteByte(flags);
if (flags & kColorDataRLE)
IWriteRLEImage(stream,this);
else
{
plJPEG::Instance().SetWriteQuality(70);
plJPEG::Instance().WriteToStream(stream, this);
}
if (flags & kAlphaDataRLE)
IWriteRLEImage(stream,alpha);
else
{
plJPEG::Instance().SetWriteQuality(100);
plJPEG::Instance().WriteToStream(stream, alpha);
}
delete alpha;
}
//// GetLevelSize /////////////////////////////////////////////////////////////
// Get the size of a single mipmap level (0 is the largest)
UInt32 plMipmap::GetLevelSize( UInt8 level )
{
if( fLevelSizes == nil )
IBuildLevelSizes();
return fLevelSizes[ level ];
}
//// IBuildLevelSizes /////////////////////////////////////////////////////////
// Creates the table of level sizes, for quick reference
void plMipmap::IBuildLevelSizes()
{
UInt8 level;
UInt32 width, height, rowBytes;
delete [] fLevelSizes;
fLevelSizes = TRACKED_NEW UInt32[ fNumLevels ];
memset( fLevelSizes, 0, sizeof( UInt32 ) * fNumLevels );
for( level = 0, width = fWidth, height = fHeight, rowBytes = fRowBytes; level < fNumLevels; level++ )
{
switch( fCompressionType )
{
case kDirectXCompression:
if( ( width | height ) & 0x03 )
fLevelSizes[ level ] = height * rowBytes;
else
fLevelSizes[ level ] = ( height * width * (UInt32)fDirectXInfo.fBlockSize ) >> 4;
break;
case kUncompressed:
case kJPEGCompression:
fLevelSizes[ level ] = height * rowBytes;
break;
default:
hsAssert( false, "Bad compression type." );
return;
}
// Scale down and go!
if( width > 1 )
{
width >>= 1;
rowBytes >>= 1;
}
if( height > 1 )
height >>= 1;
}
}
//// GetLevelPtr //////////////////////////////////////////////////////////////
UInt8 *plMipmap::GetLevelPtr( UInt8 level, UInt32 *width, UInt32 *height, UInt32 *rowBytes )
{
UInt8 *data, i;
UInt32 w, h, r;
if( fLevelSizes == nil )
IBuildLevelSizes();
for( i = 0, data = (UInt8 *)fImage, w = fWidth, h = fHeight, r = fRowBytes; i < level; i++ )
{
data += fLevelSizes[ i ];
if( w > 1 )
{
w >>= 1;
r >>= 1;
}
if( h > 1 )
h >>= 1;
}
if( width != nil )
*width = w;
if( height != nil )
*height = h;
if( rowBytes != nil )
*rowBytes = r;
return data;
}
//// SetCurrLevel /////////////////////////////////////////////////////////////
// Sets the current level pointer for use with GetAddr*
void plMipmap::SetCurrLevel( UInt8 level )
{
fCurrLevel = level;
fCurrLevelPtr = GetLevelPtr( level, &fCurrLevelWidth, &fCurrLevelHeight, &fCurrLevelRowBytes );
}
//// SetConfig ////////////////////////////////////////////////////////////////
void plMipmap::SetConfig( unsigned config )
{
switch( config )
{
case kRGB32Config:
fPixelSize = 32;
fSpace = kDirectSpace;
fFlags = kNoFlag;
break;
case kARGB32Config:
fPixelSize = 32;
fSpace = kDirectSpace;
fFlags = kAlphaChannelFlag;
break;
case kRGB16Config:
fPixelSize = 16;
fSpace = kDirectSpace;
fFlags = kAlphaBitFlag;
break;
case kColor8Config:
fPixelSize = 8;
fSpace = kIndexSpace;
fFlags = kNoFlag;
break;
case kGray8Config:
fPixelSize = 8;
fSpace = kDirectSpace;
fFlags = kNoFlag;
break;
case kGray44Config:
fPixelSize = 8;
fSpace = kGraySpace;
fFlags = kAlphaChannelFlag;
break;
case kGray4Config:
fPixelSize = 4;
fSpace = kGraySpace;
fFlags = kNoFlag;
break;
default:
hsDebugMessage( "unknown config", config );
break;
}
}
//// ClipToMaxSize ////////////////////////////////////////////////////////////
// Looks for mipmap levels above the given dimension and "clips" them out,
// i.e. deletes them. So if you have a 512x1024 mipmap and call this with
// a size of 256, when this function returns the mipmap will be 256x128 in
// size.
void plMipmap::ClipToMaxSize( UInt32 maxDimension )
{
UInt8 *srcData, *destData, i;
UInt32 newSize;
for( i = 0, newSize = fTotalSize, srcData = (UInt8 *)fImage; fWidth > maxDimension || fHeight > maxDimension; i++ )
{
srcData += fLevelSizes[ i ];
newSize -= fLevelSizes[ i ];
if( fWidth > 1 )
{
fWidth >>= 1;
fRowBytes >>= 1;
}
if( fHeight > 1 )
fHeight >>= 1;
}
if( i == 0 )
// No change
return;
/// Create a new image pointer
destData = TRACKED_NEW UInt8[ newSize ];
hsAssert( destData != nil, "Out of memory in ClipToMaxSize()" );
memcpy( destData, srcData, newSize );
#ifdef MEMORY_LEAK_TRACER
IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
delete [] fImage;
plProfile_DelMem(MemMipmaps, fTotalSize);
fImage = destData;
fTotalSize = newSize;
fNumLevels -= i;
IBuildLevelSizes();
plProfile_NewMem(MemMipmaps, fTotalSize);
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaClipToMaxSize );
#endif
}
//// RemoveMipping ////////////////////////////////////////////////////////////
// Basically removes mipmap levels so that there is only one level remaining;
// i.e. a plain bitmap instead of a mipmap.
void plMipmap::RemoveMipping()
{
UInt8 *destData;
/// Create a new image pointer
destData = TRACKED_NEW UInt8[ fLevelSizes[ 0 ] ];
hsAssert( destData != nil, "Out of memory in ClipToMaxSize()" );
memcpy( destData, fImage, fLevelSizes[ 0 ] );
#ifdef MEMORY_LEAK_TRACER
IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
delete [] fImage;
plProfile_DelMem(MemMipmaps, fTotalSize);
fImage = destData;
fTotalSize = fLevelSizes[ 0 ];
fNumLevels = 1;
fFlags |= kForceOneMipLevel;
IBuildLevelSizes();
plProfile_NewMem(MemMipmaps, fTotalSize);
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaClipToMaxSize );
#endif
}
///////////////////////////////////////////////////////////////////////////////
#include "hsCodecManager.h"
namespace {
const UInt32 kVersion = 1;
const hsScalar kDefaultSigma = 1.f;
const UInt32 kDefaultDetailBias = 5;
// Color masks (out of 0-2)
const UInt8 fColorMasks[ 10 ][ 3 ] = { { 2, 0, 0 }, { 0, 2, 2 }, { 2, 0, 2 }, { 0, 2, 0 },
{ 0, 0, 2 }, { 2, 2, 0 }, { 2, 2, 2 }, { 2, 0, 1 }, { 0, 2, 1 }, { 1, 0, 2 } };
}
///////////////////////////////////////////////////////////////////////////////
//// plFilterMask Helper Class ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// This filter mask class actually introduces a half pixel per level shift
// artifact. It's done that since I wrote it a couple of years ago, and nobody's
// noticed but me, so it's probably okay. But fixing it would be easy. The
// mask needs to extend -n down and n+1 up. To see why, notice that the current
// upper level pixel (i,j) maps to four lower pixels (i<<1,j<<1) .. (i<<1+1,j<<1+1).
// So the mask value on pixel (i<<1,j<<1) should give equal weight to those other
// 3 pixels.
// The mask here is symmetric about the src pixel, which is right if you are
// just filtering the src bitmap. But we're filtering and resampling, so the
// mask needs to be symmetric about the dst pixel, which is off by a half
// dst pixel, or on whole src pixel.
class plFilterMask
{
protected:
int fExt;
hsScalar **fMask;
public:
plFilterMask( hsScalar sig );
virtual ~plFilterMask();
int Begin() const { return -fExt; }
int End() const { return fExt; }
hsScalar Mask( int i, int j ) const { return fMask[ i ][ j ]; }
};
plFilterMask::plFilterMask( hsScalar sig )
{
fExt = (int)( sig * 2.f );
if( fExt < 1 )
fExt = 1;
hsScalar **m = TRACKED_NEW hsScalar *[ ( fExt << 1 ) + 1 ];
m += fExt;
int i, j;
hsScalar ooSigSq = 1.f / ( sig * sig );
for( i = -fExt; i <= fExt; i++ )
{
m[ i ] = ( TRACKED_NEW hsScalar[ ( fExt << 1 ) + 1] ) + fExt;
for( j = -fExt; j <= fExt; j++ )
{
m[ i ][ j ] = expf( -( i*i + j*j ) * ooSigSq );
}
}
fMask = m;
}
plFilterMask::~plFilterMask()
{
int i;
for( i = -fExt; i <= fExt; i++ )
delete [] ( fMask[ i ] - fExt );
delete [] ( fMask - fExt );
}
///////////////////////////////////////////////////////////////////////////////
//// Some More Functions //////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
plMipmap::plMipmap( plMipmap *bm, hsScalar sig, UInt32 createFlags,
hsScalar detailDropoffStart, hsScalar detailDropoffStop,
hsScalar detailMax, hsScalar detailMin)
{
int i;
hsAssert(bm->GetHeight() && bm->GetWidth(), "Degenerate Bitmap into Mipmap");
if( sig <= 0 )
sig = kDefaultSigma;
fHeight = bm->GetHeight();
fWidth = bm->GetWidth();
fRowBytes = bm->GetRowBytes();
fPixelSize = bm->GetPixelSize();
fImage = nil;
fFlags = bm->GetFlags();
UInt32 minDim = fHeight < fWidth ? fHeight : fWidth;
for( fNumLevels = 0; (minDim >> fNumLevels); fNumLevels++ ) /* empty */;
fLevelSizes = nil;
fCompressionType = kUncompressed;
fUncompressedInfo.fType = bm->fUncompressedInfo.fType;
IBuildLevelSizes();
fTotalSize = 0;
for( i = 0; i < fNumLevels; i++ )
fTotalSize += fLevelSizes[ i ];
fCurrLevel = 0;
fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
memset(fImage, 0, fTotalSize);
memcpy( fImage, bm->fImage, bm->GetLevelSize( 0 ) );
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaDetailMapConstructor );
#endif
plProfile_NewMem(MemMipmaps, fTotalSize);
/// Filter levels!
plFilterMask mask(sig);
/// First, fill in all the mipmap levels sans detail levels
for( i = 1; i < fNumLevels; i++ )
ICreateLevelNoDetail(i, mask);
if (createFlags & kCreateDetailMask)
{
// Fill in the detail levels afterwards, so we can just grab the current level's texture
// alpha (old way did it at the same time, which accumulated the detail alpha each level down)
detailDropoffStart *= fNumLevels;
detailDropoffStop *= fNumLevels;
switch( createFlags & kCreateDetailMask )
{
case kCreateDetailAlpha:
fFlags |= kAlphaChannelFlag;
for( i = 0; i < fNumLevels; i++ )
IBlendLevelDetailAlpha(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
break;
case kCreateDetailAdd:
for( i = 0; i < fNumLevels; i++ )
IBlendLevelDetailAdd( i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
break;
case kCreateDetailMult:
for( i = 0; i < fNumLevels; i++ )
IBlendLevelDetailMult(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
break;
}
}
if( createFlags & kCreateCarryAlpha )
{
for( i = 1; i < fNumLevels; i++ )
ICarryZeroAlpha(i);
}
if( createFlags & (kCreateCarryWhite | kCreateCarryBlack) )
{
UInt32 col = createFlags & kCreateCarryWhite ? 0x00ffffff : 0x00000000;
for( i = 1; i < fNumLevels; i++ )
ICarryColor(i, col);
}
#ifdef MEMORY_LEAK_TRACER
fNumMipmaps++;
#endif
}
//// IGetDetailLevelAlpha /////////////////////////////////////////////////////
// Given the detail range and the current level, returns the detail's alpha
// value at that level.
hsScalar plMipmap::IGetDetailLevelAlpha( UInt8 level, hsScalar dropStart, hsScalar dropStop, hsScalar min, hsScalar max )
{
hsScalar detailAlpha;
detailAlpha = ( level - dropStart ) * ( min - max ) / ( dropStop - dropStart ) + max;
if( min < max )
detailAlpha = hsMinimum( max, hsMaximum( min, detailAlpha ) );
else
detailAlpha = hsMinimum( min, hsMaximum( max, detailAlpha ) );
return detailAlpha;
}
void plMipmap::SetBitmapAsLevel(UInt8 iDst, plMipmap *bm, hsScalar sig, UInt32 createFlags,
hsScalar detailDropoffStart, hsScalar detailDropoffStop,
hsScalar detailMax, hsScalar detailMin)
{
SetCurrLevel( iDst );
hsAssert((bm->fHeight == fCurrLevelHeight) && (bm->fWidth == fCurrLevelWidth), "Wrong size bitmap for Mipmap level.");
memcpy( fCurrLevelPtr, bm->fImage, bm->GetLevelSize( 0 ) );
plFilterMask mask(sig);
int i;
// Fill in levels w/o detail first
for( i = iDst+1; i < fNumLevels; i++ )
ICreateLevelNoDetail(i, mask);
// Now fill in the detail alphas, if we have any
switch( createFlags & kCreateDetailMask )
{
case 0:
break;
case kCreateDetailAlpha:
for( i = iDst; i < fNumLevels; i++ )
IBlendLevelDetailAlpha(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
break;
case kCreateDetailAdd:
for( i = iDst; i < fNumLevels; i++ )
IBlendLevelDetailAdd(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
break;
case kCreateDetailMult:
for( i = iDst; i < fNumLevels; i++ )
IBlendLevelDetailMult(i, mask, detailDropoffStart, detailDropoffStop, detailMax, detailMin);
break;
}
if( createFlags & kCreateCarryAlpha )
{
for( i = iDst+1; i < fNumLevels; i++ )
ICarryZeroAlpha(i);
}
if( createFlags & (kCreateCarryWhite | kCreateCarryBlack) )
{
UInt32 col = createFlags & kCreateCarryWhite ? 0x00ffffff : 0x00000000;
for( i = iDst+1; i < fNumLevels; i++ )
ICarryColor(i, col);
}
SetCurrLevel(0);
}
//// ICreateLevelNoDetail /////////////////////////////////////////////////////
// Creates one level of a mipmap based on a filter on the previous layer.
// This version assumes no detail map fading.
void plMipmap::ICreateLevelNoDetail( UInt8 iDst, const plFilterMask& mask )
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j, ii, jj;
if( 32 == fPixelSize )
{
SetCurrLevel(iDst);
UInt8 *src = (UInt8 *)GetLevelPtr( iDst-1 );
UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);
UInt32 srcRowBytes = fCurrLevelRowBytes << 1;
UInt32 srcHeight = fCurrLevelHeight << 1;
UInt32 srcWidth = fCurrLevelWidth << 1;
for( i = 0; i < fCurrLevelHeight; i++ )
{
for( j = 0; j < fCurrLevelWidth; j++ )
{
UInt8 *center = src + (i << 1) * srcRowBytes + (j << 3);
UInt32 chan;
for( chan = 0; chan < 4; chan++ )
{
hsScalar w = 0;
hsScalar a = 0;
for( ii = mask.Begin(); ii <= mask.End(); ii++ )
{
for( jj = mask.Begin(); jj <= mask.End(); jj++ )
{
if( (ii + (i << 1) >= 0)&&(ii + (i << 1) < srcHeight)
&&(jj + (j << 1) >= 0)&&(jj + (j << 1) < srcWidth) )
{
w += mask.Mask(ii, jj);
a += (hsScalar(center[ii*srcRowBytes + (jj<<2) + chan]) + 0.5f) * mask.Mask(ii, jj);
}
}
}
a /= w;
dst[i * fCurrLevelRowBytes + (j << 2) + chan] = (UInt8)a;
}
}
}
}
}
void plMipmap::ICarryZeroAlpha(UInt8 iDst)
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j;
if( 32 == fPixelSize )
{
SetCurrLevel(iDst);
UInt8 *src = (UInt8 *)GetLevelPtr( iDst-1 );
UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);
UInt32 srcRowBytes = fCurrLevelRowBytes << 1;
UInt32 srcHeight = fCurrLevelHeight << 1;
UInt32 srcWidth = fCurrLevelWidth << 1;
const UInt8 alphaOff = 3;
for( i = 0; i < fCurrLevelHeight; i++ )
{
for( j = 0; j < fCurrLevelWidth; j++ )
{
UInt8 *center = src + (i << 1) * srcRowBytes + (j << 3) + alphaOff;
if( !center[0]
|| !center[4]
|| !center[srcRowBytes + 0]
|| !center[srcRowBytes + 4] )
{
dst[i * fCurrLevelRowBytes + (j << 2) + alphaOff] = 0;
}
}
}
}
}
void plMipmap::ICarryColor(UInt8 iDst, UInt32 col)
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j;
if( 32 == fPixelSize )
{
SetCurrLevel(iDst);
UInt32* src = (UInt32*)GetLevelPtr( iDst-1 );
UInt32* dst = (UInt32*)GetLevelPtr(iDst);
UInt32 srcHeight = fCurrLevelHeight << 1;
UInt32 srcWidth = fCurrLevelWidth << 1;
const UInt8 alphaOff = 3;
for( i = 0; i < fCurrLevelHeight; i++ )
{
for( j = 0; j < fCurrLevelWidth; j++ )
{
UInt32* center = src + (i << 1) * srcWidth + (j << 1);
if( ((center[0] & 0x00ffffff) == col)
||((center[1] & 0x00ffffff) == col)
||((center[srcHeight] & 0x00ffffff) == col)
||((center[srcHeight+1] & 0x00ffffff) == col) )
{
dst[i * fCurrLevelWidth + j] &= 0xff000000;
dst[i * fCurrLevelWidth + j] |= col;
}
}
}
}
}
//// IBlendLevelDetailAlpha ///////////////////////////////////////////////////
// Blends in the detail alpha for a given level. This version assumes
// standard detail map blending.
void plMipmap::IBlendLevelDetailAlpha( UInt8 iDst, const plFilterMask& mask,
hsScalar detailDropoffStart, hsScalar detailDropoffStop,
hsScalar detailMax, hsScalar detailMin )
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j;
UInt32 offset;
SetCurrLevel(iDst);
UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);
hsScalar detailAlpha = IGetDetailLevelAlpha( iDst, detailDropoffStart, detailDropoffStop, detailMin, detailMax );
for( i = 0; i < fCurrLevelHeight; i++ )
{
for( j = 0; j < fCurrLevelWidth; j++ )
{
UInt32 chan = 3; // Alpha channel only
offset = i * fCurrLevelRowBytes + (j << 2) + chan;
float a = (float)dst[ offset ] * detailAlpha;
dst[ offset ] = (UInt8)a;
}
}
}
//// IBlendLevelDetailAdd /////////////////////////////////////////////////////
// Blends in the detail alpha for a given level. This version assumes additive
// detail map blending. (Shesh, gotta hate C sometimes....)
void plMipmap::IBlendLevelDetailAdd( UInt8 iDst, const plFilterMask& mask,
hsScalar detailDropoffStart, hsScalar detailDropoffStop,
hsScalar detailMax, hsScalar detailMin )
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j;
UInt32 offset;
SetCurrLevel(iDst);
UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);
hsScalar detailAlpha = IGetDetailLevelAlpha( iDst, detailDropoffStart, detailDropoffStop, detailMin, detailMax );
for( i = 0; i < fCurrLevelHeight; i++ )
{
for( j = 0; j < fCurrLevelWidth; j++ )
{
UInt32 chan;
/// Blend all but the alpha channel, since we're doing additive blending
for( chan = 0; chan < 3; chan++ )
{
offset = i * fCurrLevelRowBytes + (j << 2) + chan;
float a = (float)dst[ offset ] * detailAlpha;
dst[ offset ] = (UInt8)a;
}
}
}
}
//// IBlendLevelDetailMult ////////////////////////////////////////////////////
// Blends in the detail alpha for a given level. This version assumes
// multiplicitive detail map blending. (Shesh, gotta hate C sometimes....)
void plMipmap::IBlendLevelDetailMult( UInt8 iDst, const plFilterMask& mask,
hsScalar detailDropoffStart, hsScalar detailDropoffStop,
hsScalar detailMax, hsScalar detailMin )
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j;
UInt32 offset;
SetCurrLevel(iDst);
UInt8 *dst = (UInt8 *)GetLevelPtr(iDst);
hsScalar detailAlpha = IGetDetailLevelAlpha( iDst, detailDropoffStart, detailDropoffStop, detailMin, detailMax );
hsScalar invDetailAlpha = ( 1.f - detailAlpha ) * 255.f;
for( i = 0; i < fCurrLevelHeight; i++ )
{
for( j = 0; j < fCurrLevelWidth; j++ )
{
UInt32 chan;
for( chan = 0; chan < 4; chan++ )
{
offset = i * fCurrLevelRowBytes + (j << 2) + chan;
float a = (float)dst[ offset ];
// Mult should fade to white, not black like with additive blending
a = invDetailAlpha + a * detailAlpha;
dst[ offset ] = (UInt8)a;
}
}
}
}
//// EnsureKonstantBorder /////////////////////////////////////////////////////
// Checks a mipmap's levels and makes sure that if the top level has constant
// border color/alpha, the rest of the levels get that border, too, regardless
// of filtering. (This is us guessing that that border was apparently what
// was intented, thus removing ugly stretching problems on clamped textures).
void plMipmap::EnsureKonstantBorder( hsBool clampU, hsBool clampV )
{
if( fPixelSize != 32 )
{
hsAssert( false, "Only 32 bit color supported in EnsureKonstantBorder()" );
return;
}
if( !clampU && !clampV )
return; // Um, exactly what are we supposed to do, again?
UInt32 uColor, vColor;
int i;
if( clampU && !IGrabBorderColor( false, &uColor ) )
return;
if( clampV && !IGrabBorderColor( true, &vColor ) )
return;
if( clampU && clampV && ( uColor != vColor ) )
return;
for( i = 1; i < fNumLevels; i++ )
{
SetCurrLevel( i );
if( clampU )
ISetCurrLevelUBorder( uColor );
if( clampV )
ISetCurrLevelVBorder( vColor );
}
SetCurrLevel( 0 );
}
//// IGrabBorderColor /////////////////////////////////////////////////////////
// Grabs the top level's border color, or returns false if not all pixels
// on the border are the same color/alpha.
hsBool plMipmap::IGrabBorderColor( hsBool grabVNotU, UInt32 *color )
{
int i;
UInt32 *src1 = (UInt32 *)fImage, *src2, testColor;
if( !grabVNotU )
{
src2 = (UInt32 *)( (UInt8 *)fImage + fRowBytes * ( fHeight - 1 ) );
testColor = *src1;
for( i = 0; i < fWidth; i++ )
{
if( src1[ i ] != testColor || src2[ i ] != testColor )
return false;
}
*color = testColor;
return true;
}
else
{
src2 = src1 + ( fWidth - 1 );
testColor = *src1;
for( i = 0; i < fHeight; i++ )
{
if( *src1 != testColor || *src2 != testColor )
return false;
src1 += fWidth;
src2 += fWidth;
}
*color = testColor;
return true;
}
}
//// ISetCurrLevelUBorder /////////////////////////////////////////////////////
void plMipmap::ISetCurrLevelUBorder( UInt32 color )
{
int i;
UInt32 *src1 = (UInt32 *)fCurrLevelPtr, *src2;
src2 = (UInt32 *)( (UInt8 *)fCurrLevelPtr + fCurrLevelRowBytes * ( fCurrLevelHeight - 1 ) );
for( i = 0; i < fCurrLevelWidth; i++ )
{
src1[ i ] = color;
src2[ i ] = color;
}
}
//// ISetCurrLevelVBorder /////////////////////////////////////////////////////
void plMipmap::ISetCurrLevelVBorder( UInt32 color )
{
int i;
UInt32 *src1 = (UInt32 *)fCurrLevelPtr, *src2;
src2 = src1 + ( fCurrLevelWidth - 1 );
for( i = 0; i < fCurrLevelHeight; i++ )
{
*src1 = color;
*src2 = color;
src1 += fCurrLevelWidth;
src2 += fCurrLevelWidth;
}
}
void plMipmap::Filter(hsScalar sig)
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i, j, ii, jj;
if( 32 == fPixelSize )
{
UInt8 *dst = (UInt8 *)(fImage);
UInt8* src = (UInt8*)HSMemory::New(fRowBytes * fHeight);
HSMemory::BlockMove(dst, src, fRowBytes * fHeight);
if( sig <= 0 )
sig = kDefaultSigma;
plFilterMask mask(sig);
UInt32 srcRowBytes = fRowBytes;
UInt32 srcHeight = fHeight;
UInt32 srcWidth = fWidth;
for( i = 0; i < fHeight; i++ )
{
for( j = 0; j < fWidth; j++ )
{
UInt8 *center = src + i * srcRowBytes + (j << 2);
UInt32 chan;
for( chan = 0; chan < 4; chan++ )
{
hsScalar w = 0;
hsScalar a = 0;
for( ii = mask.Begin(); ii <= mask.End(); ii++ )
{
for( jj = mask.Begin(); jj <= mask.End(); jj++ )
{
if( (ii + i >= 0)&&(ii + i < srcHeight)
&&(jj + j >= 0)&&(jj + j < srcWidth) )
{
w += mask.Mask(ii, jj);
a += (hsScalar(center[ii*srcRowBytes + (jj<<2) + chan]) + 0.5f) * mask.Mask(ii, jj);
}
}
}
a /= w;
dst[i * fRowBytes + (j << 2) + chan] = (UInt8)(a);
}
}
}
HSMemory::Delete(src);
}
}
static void CopyPixels(UInt32 srcWidth, UInt32 srcHeight,void *srcPixels,
UInt32 skipX, UInt32 skipY, UInt32 dstFormat,
void * &destPixels, UInt32 copyOptions)
{
int y;
int xInc = skipX + 1;
int yInc = skipY + 1;
int i = 0;
int firstX = 0;
int rowSkip = yInc * srcWidth; // Number of pixels to skip for each line
const hsRGBAColor32 *p =(const hsRGBAColor32 *)srcPixels;
UInt16 *pixels16 = (UInt16*)destPixels;
UInt8 *pixels8 = (UInt8*)destPixels;
for(y = 0; y < srcHeight; y += yInc, firstX += rowSkip)
{
const hsRGBAColor32 *srcPix = &(p[firstX]);
int x;
switch (dstFormat)
{
case plMipmap::kPixelAI88:
for(x =0; x < srcWidth; x += xInc)
pixels16[i++]= ((srcPix[x].a & 0xff) << 8) | (srcPix[x].r & 0xff);
break;
case plMipmap::kPixelI8:
for(x =0; x < srcWidth; x += xInc)
pixels8[i++]= srcPix[x].r;
break;
case plMipmap::kPixelARGB4444:
for(x = 0; x < srcWidth; x += xInc)
pixels16[i++]= (((srcPix[x].r>>4) & 0xf) << 8)
| (((srcPix[x].g >> 4) & 0xf) << 4)
| (((srcPix[x].b >> 4) & 0xf) )
| (((srcPix[x].a >> 4) & 0xf) << 12);
break;
case plMipmap::kPixelARGB1555:
for(x = 0; x < srcWidth; x += xInc)
pixels16[i++]= (((srcPix[x].r>>3) & 0x1f) << 10) |
(((srcPix[x].g >> 3) & 0x1f) << 5) |
((srcPix[x].b >> 3) & 0x1f) | ((srcPix[x].a == 0) ? 0 : 0x8000);
break;
}
}
destPixels = (char *)destPixels + (i * ((dstFormat == plMipmap::kPixelI8 ) ? 1 : 2));
}
UInt32 plMipmap::CopyOutPixels(UInt32 destXSize, UInt32 destYSize,
UInt32 dstFormat, void *destPixels, UInt32 copyOptions)
{
hsAssert(fPixelSize == 32, "Only 32 bit implemented");
ASSERT_UNCOMPRESSED();
int i;
int skipX = fWidth/destXSize - 1;
int skipY = fHeight/destYSize - 1;
hsAssert(!fCurrLevel,"Mip Map not at level 0");
for(i = 0 ; i < (fNumLevels - fCurrLevel); i++)
{
CopyPixels(fWidth >> i , fHeight >> i, GetLevelPtr( i ), skipX, skipY,
dstFormat, destPixels, copyOptions);
}
return 0;
}
//// CopyFrom /////////////////////////////////////////////////////////////////
void plMipmap::CopyFrom( const plMipmap *source )
{
hsAssert( source != nil, "nil source in plMipmap::CopyFrom()" );
plProfile_DelMem(MemMipmaps, fTotalSize);
#ifdef MEMORY_LEAK_TRACER
IRemoveFromMemRecord( (UInt8 *)fImage );
#endif
delete [] fImage;
fWidth = source->fWidth;
fHeight = source->fHeight;
fRowBytes = source->fRowBytes;
fPixelSize = source->fPixelSize;
fFlags = source->fFlags;
fSpace = source->fSpace;
fCompressionType = source->fCompressionType;
fTotalSize = source->fTotalSize;
fImage = (void *)TRACKED_NEW UInt8[ fTotalSize ];
memcpy( fImage, source->fImage, fTotalSize );
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaCopyFrom );
#endif
plProfile_NewMem(MemMipmaps, fTotalSize);
fNumLevels = source->fNumLevels;
switch( fCompressionType )
{
case kDirectXCompression:
{
fDirectXInfo.fBlockSize = source->fDirectXInfo.fBlockSize;
fDirectXInfo.fCompressionType = source->fDirectXInfo.fCompressionType;
}
break;
case kUncompressed:
case kJPEGCompression:
fUncompressedInfo.fType = source->fUncompressedInfo.fType;
break;
default:
hsAssert(false, "Reading unknown compression format.");
break;
}
// Gotta do this AFTER we set our block size, etc.
IBuildLevelSizes();
// We just changed our texture, so if we have a texture ref, we better dirty it
if( GetDeviceRef() != nil )
GetDeviceRef()->SetDirty( true );
}
//// Clone ////////////////////////////////////////////////////////////////////
plMipmap *plMipmap::Clone() const
{
plMipmap *newMap = TRACKED_NEW plMipmap;
newMap->CopyFrom( this );
return newMap;
}
//// Composite ////////////////////////////////////////////////////////////////
// Compositing function. Take a (smaller) mipmap and composite it onto this one
// at the given location
void plMipmap::Composite( plMipmap *source, UInt16 x, UInt16 y, plMipmap::CompositeOptions *options )
{
UInt8 level, numLevels, srcNumLevels, srcLevelOffset, levelsToSkip;
UInt16 pX, pY;
UInt32 *srcLevelPtr, *dstLevelPtr, *srcPtr, *dstPtr;
UInt32 srcRowBytes, dstRowBytes, srcRowBytesToCopy, r, g, b, dR, dG, dB, srcWidth, srcHeight;
UInt32 srcAlpha, oneMinusAlpha, destAlpha;
UInt16 srcClipX, srcClipY;
// Currently we only support 32 bit uncompressed mipmaps
if( fPixelSize != 32 || fCompressionType == kDirectXCompression )
{
hsAssert( false, "Destination mipmap on composite has unsupported format" );
return;
}
if( source->fPixelSize != 32 || source->fCompressionType == kDirectXCompression )
{
hsAssert( false, "Source mipmap on composite has unsupported format" );
return;
}
// Grab the correct options pointer
if( options == nil )
{
static CompositeOptions defaultOptions;
options = &defaultOptions;
}
// Src level skipping
srcWidth = source->fWidth;
srcHeight = source->fHeight;
srcLevelPtr = (UInt32 *)source->fImage;
srcRowBytes = source->fRowBytes;
srcNumLevels = source->fNumLevels;
for( srcLevelOffset = 0, levelsToSkip = options->fSrcLevelsToSkip; levelsToSkip > 0; levelsToSkip--, srcLevelOffset++ )
{
srcWidth >>= 1;
srcHeight >>= 1;
srcLevelPtr += source->fLevelSizes[ srcLevelOffset ] >> 2;
srcRowBytes >>= 1;
srcNumLevels--;
}
// Src clipping setup
srcClipX = srcClipY = 0;
srcRowBytesToCopy = srcRowBytes;
if( options->fSrcClipY > 0 )
{
srcHeight -= options->fSrcClipY;
srcClipY = options->fSrcClipY;
}
if( options->fSrcClipHeight > 0 )
{
srcHeight = options->fSrcClipHeight;
}
if( options->fSrcClipX > 0 )
{
srcWidth -= options->fSrcClipX;
srcClipX = options->fSrcClipX;
srcRowBytesToCopy -= options->fSrcClipX * ( source->fPixelSize >> 3 );
}
if( options->fSrcClipWidth > 0 )
{
srcWidth = options->fSrcClipWidth;
srcRowBytesToCopy = srcWidth * ( source->fPixelSize >> 3 );
}
// Position checks
if( x + srcWidth > fWidth || y + srcHeight > fHeight )
{
hsAssert( false, "Illegal position on mipmap composite" );
return;
}
// Do the composite on each level
numLevels = fNumLevels;
if( numLevels > srcNumLevels )
numLevels = srcNumLevels;
dstLevelPtr = (UInt32 *)fImage;
dstRowBytes = fRowBytes;
if( options->fFlags & kForceOpaque )
{
for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
{
srcPtr = srcLevelPtr;
dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;
// Clipping
srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;
for( pY = (UInt16)srcHeight; pY > 0; pY-- )
{
memcpy( dstPtr, srcPtr, srcRowBytesToCopy );
for( pX = 0; pX < srcWidth; pX++ )
{
// Force the alpha opaque
dstPtr[ pX ] |= 0xff000000;
}
dstPtr += dstRowBytes >> 2;
srcPtr += srcRowBytes >> 2;
}
srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
dstLevelPtr += fLevelSizes[ level ] >> 2;
srcRowBytes >>= 1;
dstRowBytes >>= 1;
srcRowBytesToCopy >>= 1;
if( srcHeight > 1 )
srcHeight >>= 1;
srcClipX >>= 1;
srcClipY >>= 1;
}
}
else if( options->fFlags & kCopySrcAlpha )
{
for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
{
srcPtr = srcLevelPtr;
dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;
// Clipping
srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;
for( pY = (UInt16)srcHeight; pY > 0; pY-- )
{
memcpy( dstPtr, srcPtr, srcRowBytesToCopy );
dstPtr += dstRowBytes >> 2;
srcPtr += srcRowBytes >> 2;
}
srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
dstLevelPtr += fLevelSizes[ level ] >> 2;
srcRowBytes >>= 1;
dstRowBytes >>= 1;
srcRowBytesToCopy >>= 1;
if( srcHeight > 1 )
srcHeight >>= 1;
srcClipX >>= 1;
srcClipY >>= 1;
}
}
else if( options->fFlags & kMaskSrcAlpha )
{
for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
{
srcPtr = srcLevelPtr;
dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;
// Clipping
srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;
for( pY = (UInt16)srcHeight; pY > 0; pY-- )
{
for( pX = 0; pX < srcWidth; pX++ )
{
srcAlpha = options->fOpacity * ( ( srcPtr[ pX ] >> 16 ) & 0x0000ff00 ) / 255 / 256;
if( srcAlpha != 0 )
dstPtr[ pX ] = ( srcPtr[ pX ] & 0x00ffffff ) | ( srcAlpha << 24 );
}
dstPtr += dstRowBytes >> 2;
srcPtr += srcRowBytes >> 2;
}
srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
dstLevelPtr += fLevelSizes[ level ] >> 2;
srcRowBytes >>= 1;
dstRowBytes >>= 1;
srcRowBytesToCopy >>= 1;
if( srcHeight > 1 )
srcHeight >>= 1;
srcClipX >>= 1;
srcClipY >>= 1;
}
}
else
{
for( level = 0; level < numLevels; level++, y >>= 1, x >>= 1 )
{
srcPtr = srcLevelPtr;
dstPtr = dstLevelPtr + ( y * dstRowBytes >> 2 ) + x;
// Clipping
srcPtr += srcClipY * ( srcRowBytes >> 2 ) + srcClipX;
for( pY = (UInt16)srcHeight; pY > 0; pY-- )
{
// Reverse the loop so we can count downwards--slightly faster
pX = (UInt16)srcWidth;
do
{
pX--;
// Wacko trick here. Alphas are 0-255, which means scaling by alpha would
// be a v' = v * alpha / 255 operation sequence. However, since we hate
// dividing by 255 all the time, we actually scale the alpha just ever so
// slightly so it's 0-256, which makes the divide a simple shift. Note
// that this will result in some tiny bit of aliasing, but it shouldn't be
// enough to notice
if (!(srcPtr[pX] >> 24)) // Zero alpha. Skip this pixel
continue;
srcAlpha = options->fOpacity * ( ( srcPtr[ pX ] >> 16 ) & 0x0000ff00 ) / 255 / 256;
oneMinusAlpha = 256 - srcAlpha;
destAlpha = dstPtr[ pX ] & 0xff000000;
r = (UInt32)((( srcPtr[ pX ] >> 16 ) & 0x000000ff) * options->fRedTint);
g = (UInt32)((( srcPtr[ pX ] >> 8 ) & 0x000000ff) * options->fGreenTint);
b = (UInt32)((( srcPtr[ pX ] ) & 0x000000ff) * options->fBlueTint);
dR = ( dstPtr[ pX ] >> 16 ) & 0x000000ff;
dG = ( dstPtr[ pX ] >> 8 ) & 0x000000ff;
dB = ( dstPtr[ pX ] ) & 0x000000ff;
r = ( r * srcAlpha ) >> 8;
g = ( g * srcAlpha ) >> 8;
b = ( b * srcAlpha ) >> 8;
dR = ( dR * oneMinusAlpha ) >> 8;
dG = ( dG * oneMinusAlpha ) >> 8;
dB = ( dB * oneMinusAlpha ) >> 8;
// Dest alpha for now is just our original dest alpha
dstPtr[ pX ] = ( ( r + dR ) << 16 ) | ( ( g + dG ) << 8 ) | ( b + dB ) | destAlpha;
if( !( options->fFlags & kBlendWriteAlpha ) )
continue;
// Unless our blend option is set of course
dstPtr[ pX ] = ( dstPtr[ pX ] & 0x00ffffff ) | ( srcAlpha << 24 );
} while( pX > 0 );
dstPtr += dstRowBytes >> 2;
srcPtr += srcRowBytes >> 2;
}
srcLevelPtr += source->fLevelSizes[ level + srcLevelOffset ] >> 2;
dstLevelPtr += fLevelSizes[ level ] >> 2;
srcRowBytes >>= 1;
dstRowBytes >>= 1;
if( srcWidth > 1 )
srcWidth >>= 1;
if( srcHeight > 1 )
srcHeight >>= 1;
srcClipX >>= 1;
srcClipY >>= 1;
}
}
// All done!
if( GetDeviceRef() != nil )
GetDeviceRef()->SetDirty( true );
}
//// Colorize /////////////////////////////////////////////////////////////////
// Colorizes a mipmap so that each level is color-coded. Assume max 10 levels
// (coloring wraps after 10).
void plMipmap::Colorize()
{
UInt32 currColor, width, height;
UInt8 currLevel;
if( fPixelSize != 32 && fCompressionType != kDirectXCompression )
{
/// Most likely this is a luminance or luminance/alpha map,
/// so we ignore it (it's up to the device to make sure we
/// only get 32-bit or compressed mipmaps)
return;
}
if( fFlags & kForceOneMipLevel )
{
// Don't colorize if it's not mipmapped...
return;
}
/// First handle compressed levels, if any
currLevel = 0;
currColor = 0;
width = fWidth;
height = fHeight;
if( fCompressionType == kDirectXCompression )
{
for( ; currLevel < fNumLevels; currLevel++ )
{
/// Are we over the threshold?
SetCurrLevel( currLevel );
if( ( fCurrLevelWidth | fCurrLevelHeight ) & 0x03 )
break;
/// Since this level is compressed, we have to use the codec...
hsCodecManager::Instance().ColorizeCompMipmap( this, fColorMasks[ currColor ] );
/// Increment the color
currColor = ( currColor >=9 ) ? 0 : currColor + 1;
}
}
/// Now loop through the uncompressed levels
for( ; currLevel < fNumLevels; currLevel++ )
{
/// Do this one
IColorLevel( currLevel, fColorMasks[ currColor ] );
/// Increment the color
currColor = ( currColor >=9 ) ? 0 : currColor + 1;
}
SetCurrLevel( 0 );
}
//// IColorLevel //////////////////////////////////////////////////////////////
// Colorizes the current level of a mipmap according to the color mask given
// (percentages of r, g & b in the range of 0-2).
void plMipmap::IColorLevel( UInt8 level, const UInt8 *colorMask )
{
UInt32 index, max, color, gray, grayDiv2, *data, width, height;
UInt8 compMasks[ 3 ][ 2 ] = { { 0, 0 }, { 0, 0xff }, { 0xff, 0 } };
data = (UInt32 *)GetLevelPtr( level, &width, &height );
max = fLevelSizes[ level ] >> 2;
for( index = 0; index < max; index++ )
{
/// Get color and calculate gray (average of r, g & b)
color = data[ index ];
gray = ( ( color >> 16 ) & 0xff ) + ( ( color >> 8 ) & 0xff ) + ( color & 0xff );
gray /= 3;
gray = 0xff - ( ( 0xff - gray ) >> 1 ); // Lighten it 50%
grayDiv2 = gray >> 1;
/// Preserve alpha
color &= 0xff000000;
/// Now rewrite the components based on the color mask
color |= ( ( gray & compMasks[ colorMask[ 0 ] ][ 0 ] ) |
( grayDiv2 & compMasks[ colorMask[ 0 ] ][ 1 ] ) ) << 16;
color |= ( ( gray & compMasks[ colorMask[ 1 ] ][ 0 ] ) |
( grayDiv2 & compMasks[ colorMask[ 1 ] ][ 1 ] ) ) << 8;
color |= ( ( gray & compMasks[ colorMask[ 2 ] ][ 0 ] ) |
( grayDiv2 & compMasks[ colorMask[ 2 ] ][ 1 ] ) );
data[ index ] = color;
}
}
///////////////////////////////////////////////////////////////////////////////
//// Scaling //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//// ScaleNicely //////////////////////////////////////////////////////////////
// Does a nice (smoothed) scaling of a 1-level mipmap onto another 1-level
// mipmap. Works only for 32-bit mipmaps.
void plMipmap::ScaleNicely( UInt32 *destPtr, UInt16 destWidth, UInt16 destHeight,
UInt16 destStride, plMipmap::ScaleFilter filter ) const
{
UInt16 destX, destY, srcX, srcY;
Int16 srcStartX, srcEndX, srcStartY, srcEndY;
float srcPosX, srcPosY, destToSrcXScale, destToSrcYScale, filterWidth, filterHeight, weight;
float totalWeight;
hsColorRGBA color, accumColor;
float whyWaits[ 16 ], whyWait, xWeights[ 16 ];
UInt32 *srcPtr;
// Init
destToSrcXScale = (float)fWidth / (float)destWidth;
destToSrcYScale = (float)fHeight / (float)destHeight;
// Filter size is the radius of the area (or rather, half the box size) around the source position
// that we sample from. We calculate it so that a 1:1 scale would result in a filter size of 1 (thus
// making a box filter at 1:1 result in a straight copy of the original)
filterWidth = 1.f * destToSrcXScale;
filterHeight = 1.f * destToSrcYScale;
// If we are upsampling, we still want a filter at least a pixel half-width/height, which will just do
// a bilerp up. That doesn't make this function correctly resample, or excuse the incredibly complicated
// code to do something incredibly simple, but at least it doesn't fail so obviously.
if( filterWidth < 1.f )
filterWidth = 1.f;
if( filterHeight < 1.f )
filterHeight = 1.f;
// Process
for( destY = 0; destY < destHeight; destY++ )
{
// Calculate the span across this row
srcPosY = destY * destToSrcYScale;
srcStartY = (Int16)( srcPosY - filterHeight );
if( srcStartY < 0 )
srcStartY = 0;
srcEndY = (Int16)( srcPosY + filterHeight );
if( srcEndY >= fHeight )
srcEndY = (Int16)(fHeight - 1);
// Precalc the y weights
for( srcY = srcStartY; srcY <= srcEndY && ( srcY - srcStartY ) < 16; srcY++ )
whyWaits[ srcY - srcStartY ] = 1.f - ( fabs( (float)srcY - srcPosY ) / filterHeight );
for( destX = 0; destX < destWidth; destX++ )
{
// For this pixel in the destination, figure out where in the source image we virtually are
srcPosX = destX * destToSrcXScale;
// Range of pixels that the filter covers
srcStartX = (Int16)( srcPosX - filterWidth );
if( srcStartX < 0 )
srcStartX = 0;
srcEndX = (Int16)( srcPosX + filterWidth );
if( srcEndX >= fWidth )
srcEndX = (Int16)(fWidth - 1);
// Precalc the x weights
for( srcX = srcStartX; srcX <= srcEndX && ( srcX - srcStartX ) < 16; srcX++ )
xWeights[ srcX - srcStartX ] = 1.f - ( fabs( (float)srcX - srcPosX ) / filterWidth );
// Sum up all the weighted colors in the filter area
accumColor.Set( 0.f, 0.f, 0.f, 0.f );
totalWeight = 0.f;
for( srcY = srcStartY; srcY <= srcEndY; srcY++ )
{
if( srcY - srcStartY < 16 )
whyWait = whyWaits[ srcY - srcStartY ];
else
whyWait = 1.f - ( fabs( (float)srcY - srcPosY ) / filterHeight );
if( whyWait <= 0.f )
continue;
srcPtr = GetAddr32( srcStartX, srcY );
for( srcX = srcStartX; srcX <= srcEndX; srcX++, srcPtr++ )
{
// Our weight...
weight = ( srcX - srcStartX < 16 ) ? xWeights[ srcX - srcStartX ] :
( 1.f - ( fabs( (float)srcX - srcPosX ) / filterWidth ) );
weight *= whyWait;
if( weight > 0.f )
{
// Grab pixel values from us...
color.FromARGB32( *srcPtr );
color *= weight;
accumColor += color;
totalWeight += weight;
}
}
}
accumColor *= 1.f / totalWeight;
// Set the final value
*destPtr = accumColor.ToARGB32();
destPtr++;
}
destPtr += destStride - destWidth;
}
}
//// ResizeNicely /////////////////////////////////////////////////////////////
// Resizes us using the ScaleNicely function. Only works for 1-level, 32bpp
// uncompressed mipmaps.
hsBool plMipmap::ResizeNicely( UInt16 newWidth, UInt16 newHeight, plMipmap::ScaleFilter filter )
{
// Make a temp buffer
UInt32 *newData = TRACKED_NEW UInt32[ newWidth * newHeight ];
if( newData == nil )
return false;
// Scale to it
ScaleNicely( newData, newWidth, newHeight, newWidth, filter );
// Reset us to that
Reset();
fWidth = newWidth;
fHeight = newHeight;
fRowBytes = fWidth * fPixelSize >> 3;
fTotalSize = fRowBytes * fWidth;
fNumLevels = 1;
IBuildLevelSizes();
fImage = newData;
SetCurrLevel( 0 );
plProfile_NewMem(MemMipmaps, fTotalSize);
#ifdef MEMORY_LEAK_TRACER
IAddToMemRecord( this, plRecord::kViaResize );
#endif
// All done!
return true;
}
#ifdef MEMORY_LEAK_TRACER
//// Debug Mipmap Memory Leak Tracker /////////////////////////////////////////
plMipmap::plRecord *plMipmap::fRecords = nil;
UInt32 plMipmap::fNumMipmaps = 0;
void plMipmap::IAddToMemRecord( plMipmap *mip, plRecord::Method method )
{
plRecord *newRecord = TRACKED_NEW plRecord;
newRecord->fCompressionType = mip->fCompressionType;
newRecord->fCreationMethod = method;
newRecord->fHeight = mip->fHeight;
newRecord->fWidth = mip->fWidth;
newRecord->fImage = mip->fImage;
newRecord->fNumLevels = mip->fNumLevels;
newRecord->fRowBytes = mip->fRowBytes;
if( mip->GetKey() )
strcpy( newRecord->fKeyName, mip->GetKeyName() );
else
strcpy( newRecord->fKeyName, "<noKey>" );
if( mip->fCompressionType != kDirectXCompression )
newRecord->fUncompressedInfo.fType = mip->fUncompressedInfo.fType;
else
{
newRecord->fDirectXInfo.fBlockSize = mip->fDirectXInfo.fBlockSize;
newRecord->fDirectXInfo.fCompressionType = mip->fDirectXInfo.fCompressionType;
}
newRecord->Link( &fRecords );
}
void plMipmap::IRemoveFromMemRecord( UInt8 *image )
{
plRecord *record;
for( record = fRecords; record != nil; record = record->fNext )
{
if( record->fImage == image )
{
record->Unlink();
delete record;
return;
}
}
}
void plMipmap::IReportLeaks()
{
plRecord *record, *next;
static char msg[ 512 ], m2[ 128 ];
UInt32 size;
hsStatusMessage( "--- plMipmap Leaks ---\n" );
for( record = fRecords; record != nil; )
{
size = record->fHeight * record->fRowBytes;
if( size >= 1024 )
sprintf( msg, "%s, %4.1f kB: \t%dx%d, %d levels, %d bpr", record->fKeyName, size / 1024.f, record->fWidth, record->fHeight, record->fNumLevels, record->fRowBytes );
else
sprintf( msg, "%s, %u bytes: \t%dx%d, %d levels, %d bpr", record->fKeyName, size, record->fWidth, record->fHeight, record->fNumLevels, record->fRowBytes );
if( record->fCompressionType != kDirectXCompression )
sprintf( m2, " UType: %d", record->fUncompressedInfo.fType );
else
sprintf( m2, " DXT%d BSz: %d", record->fDirectXInfo.fCompressionType, record->fDirectXInfo.fBlockSize );
strcat( msg, m2 );
switch( record->fCreationMethod )
{
case plRecord::kViaCreate: strcat( msg, " via Create\n" ); break;
case plRecord::kViaRead: strcat( msg, " via Read\n" ); break;
case plRecord::kViaClipToMaxSize: strcat( msg, " via ClipToMaxSize\n" ); break;
case plRecord::kViaDetailMapConstructor: strcat( msg, " via DetailMapConstructor\n" ); break;
case plRecord::kViaCopyFrom: strcat( msg, " via CopyFrom\n" ); break;
case plRecord::kViaResize: strcat( msg, " via Resize\n" ); break;
}
hsStatusMessage( msg );
next = record->fNext;
record->Unlink();
delete record;
record = next;
}
hsStatusMessage( "--- End of plMipmap Leaks ---\n" );
}
#endif