{

for( int i = 0; i < 256; i++ )

{

pTable[i] = 255.0 * pow( (float)i / 255.0f, srcGamma / dstGamma );

}

{

int v;

for( int i = 0; i < 256; i++ )

{

double f;

f = 255.0 * pow( (float)i / 255.0f, srcGamma / dstGamma );

v = ( int )(f + 0.5f);

if( v < 0 )

{

v = 0;

}

else if( v > 255 )

{

v = 255;

}

pTable[i] = ( unsigned char )v;

}

unsigned char* pGammaTable )

{

for (int h = 0; h < depth; ++h )

{

for (int i = 0; i < height; ++i )

{

for (int j = 0; j < width; ++j )

{

int idx = (h * width * height + i * width + j) * 4;

// don't gamma correct alpha

pDst[idx] = pGammaTable[pSrc[idx]];

pDst[idx+1] = pGammaTable[pSrc[idx+1]];

pDst[idx+2] = pGammaTable[pSrc[idx+2]];

}

}

}

float srcGamma, float dstGamma )

{

if (srcGamma == dstGamma)

{

if (src != dst)

{

memcpy( dst, src, GetMemRequired( width, height, depth, IMAGE_FORMAT_RGBA8888, false ) );

}

return;

}

static unsigned char gamma[256];

static float lastSrcGamma = -1;

static float lastDstGamma = -1;

if (lastSrcGamma != srcGamma || lastDstGamma != dstGamma)

{

ConstructGammaTable( gamma, srcGamma, dstGamma );

lastSrcGamma = srcGamma;

lastDstGamma = dstGamma;

}

GammaCorrectRGBA8888( src, dst, width, height, depth, gamma );

{

// Compute a kernel...

int h, i, j;

int kernelWidth = kernelDiameter * wratio;

int kernelHeight = kernelDiameter * hratio;

int kernelDepth = ( dratio != 0 ) ? kernelDiameter * dratio : 1;

// This is a NICE filter

// sinc pi*x * a box from -3 to 3 * sinc ( pi * x/3)

// where x is the pixel # in the destination (shrunken) image.

// only problem here is that the NICE filter has a very large kernel

// (7x7 x wratio x hratio x dratio)

float dx = 1.0f / (float)wratio;

float dy = 1.0f / (float)hratio;

float z, dz;

if (dratio != 0.0f)

{

dz = 1.0f / (float)dratio;

z = -((float)kernelDiameter - dz) * 0.5f;

}

else

{

dz = 0.0f;

z = 0.0f;

}

float total = 0.0f;

for ( h = 0; h < kernelDepth; ++h )

{

float y = -((float)kernelDiameter - dy) * 0.5f;

for ( i = 0; i < kernelHeight; ++i )

{

float x = -((float)kernelDiameter - dx) * 0.5f;

for ( j = 0; j < kernelWidth; ++j )

{

int nKernelIndex = kernelWidth * ( i + h * kernelHeight ) + j;

float d = sqrt( x * x + y * y + z * z );

if (d > kernelDiameter * 0.5f)

{

pKernel[nKernelIndex] = 0.0f;

}

else

{

float t = M_PI * d;

if ( t != 0 )

{

float sinc = sin( t ) / t;

float sinc3 = 3.0f * sin( t / 3.0f ) / t;

pKernel[nKernelIndex] = sinc * sinc3;

}

else

{

pKernel[nKernelIndex] = 1.0f;

}

total += pKernel[nKernelIndex];

}

x += dx;

}

y += dy;

}

z += dz;

}

// normalize

float flInvFactor = ( dratio == 0 ) ? wratio * hratio : dratio * wratio * hratio;

float flInvTotal = (total != 0.0f) ? 1.0f / total : 1.0f;

for ( h = 0; h < kernelDepth; ++h )

{

for ( i = 0; i < kernelHeight; ++i )

{

int nPixel = kernelWidth * ( h * kernelHeight + i );

for ( j = 0; j < kernelWidth; ++j )

{

pKernel[nPixel + j] *= flInvTotal;

pInvKernel[nPixel + j] = flInvFactor * pKernel[nPixel + j];

}

}

}

{

int idx = (int)(x + 0.5f);

if (idx < 0) idx = 0;

else if (idx > 255) idx = 255;

return idx;

{

float *m_pKernel;

float *m_pInvKernel;

int m_nWidth;

int m_nHeight;

int m_nDepth;

int m_nDiameter;

{

KERNEL_DEFAULT = 0,

KERNEL_NORMALMAP,

KERNEL_ALPHATEST,

{

static inline int ActualX( int x, const ResampleInfo_t &info )

{

if ( info.m_nFlags & RESAMPLE_CLAMPS )

return clamp( x, 0, info.m_nSrcWidth - 1 );

// This works since info.m_nSrcWidth is a power of two.

// Even for negative #s!

return x & (info.m_nSrcWidth - 1);

}

static inline int ActualY( int y, const ResampleInfo_t &info )

{

if ( info.m_nFlags & RESAMPLE_CLAMPT )

return clamp( y, 0, info.m_nSrcHeight - 1 );

// This works since info.m_nSrcHeight is a power of two.

// Even for negative #s!

return y & (info.m_nSrcHeight - 1);

}

static inline int ActualZ( int z, const ResampleInfo_t &info )

{

if ( info.m_nFlags & RESAMPLE_CLAMPU )

return clamp( z, 0, info.m_nSrcDepth - 1 );

// This works since info.m_nSrcDepth is a power of two.

// Even for negative #s!

return z & (info.m_nSrcDepth - 1);

}

static void ComputeAveragedColor( const KernelInfo_t &kernel, const ResampleInfo_t &info,

int startX, int startY, int startZ, float *gammaToLinear, float *total )

{

total[0] = total[1] = total[2] = total[3] = 0.0f;

for ( int j = 0, srcZ = startZ; j < kernel.m_nDepth; ++j, ++srcZ )

{

int sz = ActualZ( srcZ, info );

sz *= info.m_nSrcWidth * info.m_nSrcHeight;

for ( int k = 0, srcY = startY; k < kernel.m_nHeight; ++k, ++srcY )

{

int sy = ActualY( srcY, info );

sy *= info.m_nSrcWidth;

int kernelIdx;

if ( bNiceFilter )

{

kernelIdx = kernel.m_nWidth * ( k + j * kernel.m_nHeight );

}

else

{

kernelIdx = 0;

}

for ( int l = 0, srcX = startX; l < kernel.m_nWidth; ++l, ++srcX, ++kernelIdx )

{

int sx = ActualX( srcX, info );

int srcPixel = (sz + sy + sx) << 2;

float flKernelFactor;

if ( bNiceFilter )

{

flKernelFactor = kernel.m_pKernel[kernelIdx];

if ( flKernelFactor == 0.0f )

continue;

}

else

{

flKernelFactor = kernel.m_pKernel[0];

}

if ( type == KERNEL_NORMALMAP )

{

total[0] += flKernelFactor * info.m_pSrc[srcPixel + 0];

total[1] += flKernelFactor * info.m_pSrc[srcPixel + 1];

total[2] += flKernelFactor * info.m_pSrc[srcPixel + 2];

total[3] += flKernelFactor * info.m_pSrc[srcPixel + 3];

}

else if ( type == KERNEL_ALPHATEST )

{

total[0] += flKernelFactor * gammaToLinear[ info.m_pSrc[srcPixel + 0] ];

total[1] += flKernelFactor * gammaToLinear[ info.m_pSrc[srcPixel + 1] ];

total[2] += flKernelFactor * gammaToLinear[ info.m_pSrc[srcPixel + 2] ];

if ( info.m_pSrc[srcPixel + 3] > 192 )

{

total[3] += flKernelFactor * 255.0f;

}

}

else

{

total[0] += flKernelFactor * gammaToLinear[ info.m_pSrc[srcPixel + 0] ];

total[1] += flKernelFactor * gammaToLinear[ info.m_pSrc[srcPixel + 1] ];

total[2] += flKernelFactor * gammaToLinear[ info.m_pSrc[srcPixel + 2] ];

total[3] += flKernelFactor * info.m_pSrc[srcPixel + 3];

}

}

}

}

}

static void AddAlphaToAlphaResult( const KernelInfo_t &kernel, const ResampleInfo_t &info,

int startX, int startY, int startZ, float flAlpha, float *pAlphaResult )

{

for ( int j = 0, srcZ = startZ; j < kernel.m_nDepth; ++j, ++srcZ )

{

int sz = ActualZ( srcZ, info );

sz *= info.m_nSrcWidth * info.m_nSrcHeight;

for ( int k = 0, srcY = startY; k < kernel.m_nHeight; ++k, ++srcY )

{

int sy = ActualY( srcY, info );

sy *= info.m_nSrcWidth;

int kernelIdx;

if ( bNiceFilter )

{

kernelIdx = k * kernel.m_nWidth + j * kernel.m_nWidth * kernel.m_nHeight;

}

else

{

kernelIdx = 0;

}

for ( int l = 0, srcX = startX; l < kernel.m_nWidth; ++l, ++srcX, ++kernelIdx )

{

int sx = ActualX( srcX, info );

int srcPixel = sz + sy + sx;

float flKernelFactor;

if ( bNiceFilter )

{

flKernelFactor = kernel.m_pInvKernel[kernelIdx];

if ( flKernelFactor == 0.0f )

continue;

}

else

{

flKernelFactor = kernel.m_pInvKernel[0];

}

pAlphaResult[srcPixel] += flKernelFactor * flAlpha;

}

}

}

}

static void AdjustAlphaChannel( const KernelInfo_t &kernel, const ResampleInfo_t &info,

int wratio, int hratio, int dratio, float *pAlphaResult )

{

// Find the delta between the alpha + source image

for ( int k = 0; k < info.m_nSrcDepth; ++k )

{

for ( int i = 0; i < info.m_nSrcHeight; ++i )

{

int dstPixel = i * info.m_nSrcWidth + k * info.m_nSrcWidth * info.m_nSrcHeight;

for ( int j = 0; j < info.m_nSrcWidth; ++j, ++dstPixel )

{

pAlphaResult[dstPixel] = fabs( pAlphaResult[dstPixel] - info.m_pSrc[dstPixel * 4 + 3] );

}

}

}

// Apply the kernel to the image

int nInitialZ = (dratio >> 1) - ((dratio * kernel.m_nDiameter) >> 1);

int nInitialY = (hratio >> 1) - ((hratio * kernel.m_nDiameter) >> 1);

int nInitialX = (wratio >> 1) - ((wratio * kernel.m_nDiameter) >> 1);

float flAlphaThreshhold = (info.m_flAlphaHiFreqThreshhold >= 0 ) ? 255.0f * info.m_flAlphaHiFreqThreshhold : 255.0f * 0.4f;

float flInvFactor = (dratio == 0) ? 1.0f / (hratio * wratio) : 1.0f / (hratio * wratio * dratio);

for ( int h = 0; h < info.m_nDestDepth; ++h )

{

int startZ = dratio * h + nInitialZ;

for ( int i = 0; i < info.m_nDestHeight; ++i )

{

int startY = hratio * i + nInitialY;

int dstPixel = ( info.m_nDestWidth * (i + h * info.m_nDestHeight) ) << 2;

for ( int j = 0; j < info.m_nDestWidth; ++j, dstPixel += 4 )

{

if ( info.m_pDest[ dstPixel + 3 ] == 255 )

continue;

int startX = wratio * j + nInitialX;

float flAlphaDelta = 0.0f;

for ( int m = 0, srcZ = startZ; m < dratio; ++m, ++srcZ )

{

int sz = ActualZ( srcZ, info );

sz *= info.m_nSrcWidth * info.m_nSrcHeight;

for ( int k = 0, srcY = startY; k < hratio; ++k, ++srcY )

{

int sy = ActualY( srcY, info );

sy *= info.m_nSrcWidth;

for ( int l = 0, srcX = startX; l < wratio; ++l, ++srcX )

{

// HACK: This temp variable fixes an internal compiler error in vs2005

int temp = srcX;

int sx = ActualX( temp, info );

int srcPixel = sz + sy + sx;

flAlphaDelta += pAlphaResult[srcPixel];

}

}

}

flAlphaDelta *= flInvFactor;

if ( flAlphaDelta > flAlphaThreshhold )

{

info.m_pDest[ dstPixel + 3 ] = 255.0f;

}

}

}

}

}

static void ApplyKernel( const KernelInfo_t &kernel, const ResampleInfo_t &info, int wratio, int hratio, int dratio, float* gammaToLinear, float *pAlphaResult )

{

float invDstGamma = 1.0f / info.m_flDestGamma;

// Apply the kernel to the image

int nInitialZ = (dratio >> 1) - ((dratio * kernel.m_nDiameter) >> 1);

int nInitialY = (hratio >> 1) - ((hratio * kernel.m_nDiameter) >> 1);

int nInitialX = (wratio >> 1) - ((wratio * kernel.m_nDiameter) >> 1);

float flAlphaThreshhold = (info.m_flAlphaThreshhold >= 0 ) ? 255.0f * info.m_flAlphaThreshhold : 255.0f * 0.4f;

for ( int k = 0; k < info.m_nDestDepth; ++k )

{

int startZ = dratio * k + nInitialZ;

for ( int i = 0; i < info.m_nDestHeight; ++i )

{

int startY = hratio * i + nInitialY;

int dstPixel = (i * info.m_nDestWidth + k * info.m_nDestWidth * info.m_nDestHeight) << 2;

for ( int j = 0; j < info.m_nDestWidth; ++j, dstPixel += 4 )

{

int startX = wratio * j + nInitialX;

float total[4];

ComputeAveragedColor( kernel, info, startX, startY, startZ, gammaToLinear, total );

// NOTE: Can't use a table here, we lose too many bits

if( type == KERNEL_NORMALMAP )

{

for ( int ch = 0; ch < 4; ++ ch )

info.m_pDest[ dstPixel + ch ] = Clamp( info.m_flColorGoal[ch] + ( info.m_flColorScale[ch] * ( total[ch] - info.m_flColorGoal[ch] ) ) );

}

else if ( type == KERNEL_ALPHATEST )

{

// If there's more than 40% coverage, then keep the pixel (renormalize the color based on coverage)

float flAlpha = ( total[3] >= flAlphaThreshhold ) ? 255 : 0;

for ( int ch = 0; ch < 3; ++ ch )

info.m_pDest[ dstPixel + ch ] = Clamp( 255.0f * pow( ( info.m_flColorGoal[ch] + ( info.m_flColorScale[ch] * ( ( total[ch] > 0 ? total[ch] : 0 ) - info.m_flColorGoal[ch] ) ) ) / 255.0f, invDstGamma ) );

info.m_pDest[ dstPixel + 3 ] = Clamp( flAlpha );

AddAlphaToAlphaResult( kernel, info, startX, startY, startZ, flAlpha, pAlphaResult );

}

else

{

for ( int ch = 0; ch < 3; ++ ch )

info.m_pDest[ dstPixel + ch ] = Clamp( 255.0f * pow( ( info.m_flColorGoal[ch] + ( info.m_flColorScale[ch] * ( ( total[ch] > 0 ? total[ch] : 0 ) - info.m_flColorGoal[ch] ) ) ) / 255.0f, invDstGamma ) );

info.m_pDest[ dstPixel + 3 ] = Clamp( info.m_flColorGoal[3] + ( info.m_flColorScale[3] * ( total[3] - info.m_flColorGoal[3] ) ) );

}

}

}

if ( type == KERNEL_ALPHATEST )

{

AdjustAlphaChannel( kernel, info, wratio, hratio, dratio, pAlphaResult );

}

}

}

{

// No resampling needed, just gamma correction

if ( info.m_nSrcWidth == info.m_nDestWidth && info.m_nSrcHeight == info.m_nDestHeight && info.m_nSrcDepth == info.m_nDestDepth )

{

// Here, we need to gamma convert the source image..

GammaCorrectRGBA8888( info.m_pSrc, info.m_pDest, info.m_nSrcWidth, info.m_nSrcHeight, info.m_nSrcDepth, info.m_flSrcGamma, info.m_flDestGamma );

return true;

}

// fixme: has to be power of two for now.

if( !IsPowerOfTwo(info.m_nSrcWidth) || !IsPowerOfTwo(info.m_nSrcHeight) || !IsPowerOfTwo(info.m_nSrcDepth) ||

!IsPowerOfTwo(info.m_nDestWidth) || !IsPowerOfTwo(info.m_nDestHeight) || !IsPowerOfTwo(info.m_nDestDepth) )

{

return false;

}

// fixme: can only downsample for now.

if( (info.m_nSrcWidth < info.m_nDestWidth) || (info.m_nSrcHeight < info.m_nDestHeight) || (info.m_nSrcDepth < info.m_nDestDepth) )

{

return false;

}

// Compute gamma tables...

static float gammaToLinear[256];

static float lastSrcGamma = -1;

if (lastSrcGamma != info.m_flSrcGamma)

{

ConstructFloatGammaTable( gammaToLinear, info.m_flSrcGamma, 1.0f );

lastSrcGamma = info.m_flSrcGamma;

}

int wratio = info.m_nSrcWidth / info.m_nDestWidth;

int hratio = info.m_nSrcHeight / info.m_nDestHeight;

int dratio = (info.m_nSrcDepth != info.m_nDestDepth) ? info.m_nSrcDepth / info.m_nDestDepth : 0;

KernelInfo_t kernel;

float* pTempMemory = 0;

float* pTempInvMemory = 0;

static float* kernelCache[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

static float* pInvKernelCache[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

float pKernelMem[1];

float pInvKernelMem[1];

if ( info.m_nFlags & RESAMPLE_NICE_FILTER )

{

// Kernel size is measured in dst pixels

kernel.m_nDiameter = 6;

// Compute a kernel...

kernel.m_nWidth = kernel.m_nDiameter * wratio;

kernel.m_nHeight = kernel.m_nDiameter * hratio;

kernel.m_nDepth = kernel.m_nDiameter * dratio;

if ( kernel.m_nDepth == 0 )

{

kernel.m_nDepth = 1;

}

// Cache the filter (2d kernels only)....

int power = -1;

if ( (wratio == hratio) && (dratio == 0) )

{

power = 0;

int tempWidth = wratio;

while (tempWidth > 1)

{

++power;

tempWidth >>= 1;

}

// Don't cache anything bigger than 512x512

if (power >= 10)

{

power = -1;

}

}

if (power >= 0)

{

if (!kernelCache[power])

{

kernelCache[power] = new float[kernel.m_nWidth * kernel.m_nHeight];

pInvKernelCache[power] = new float[kernel.m_nWidth * kernel.m_nHeight];

GenerateNiceFilter( wratio, hratio, dratio, kernel.m_nDiameter, kernelCache[power], pInvKernelCache[power] );

}

kernel.m_pKernel = kernelCache[power];

kernel.m_pInvKernel = pInvKernelCache[power];

}

else

{

// Don't cache non-square kernels, or 3d kernels

pTempMemory = new float[kernel.m_nWidth * kernel.m_nHeight * kernel.m_nDepth];

pTempInvMemory = new float[kernel.m_nWidth * kernel.m_nHeight * kernel.m_nDepth];

GenerateNiceFilter( wratio, hratio, dratio, kernel.m_nDiameter, pTempMemory, pTempInvMemory );

kernel.m_pKernel = pTempMemory;

kernel.m_pInvKernel = pTempInvMemory;

}

}

else

{

// Compute a kernel...

kernel.m_nWidth = wratio;

kernel.m_nHeight = hratio;

kernel.m_nDepth = dratio ? dratio : 1;

kernel.m_nDiameter = 1;

// Simple implementation of a box filter that doesn't block the stack!

pKernelMem[0] = 1.0f / (float)(kernel.m_nWidth * kernel.m_nHeight * kernel.m_nDepth);

pInvKernelMem[0] = 1.0f;

kernel.m_pKernel = pKernelMem;

kernel.m_pInvKernel = pInvKernelMem;

}

float *pAlphaResult = NULL;

KernelType_t type;

if ( info.m_nFlags & RESAMPLE_NORMALMAP )

{

type = KERNEL_NORMALMAP;

}

else if ( info.m_nFlags & RESAMPLE_ALPHATEST )

{

int nSize = info.m_nSrcHeight * info.m_nSrcWidth * info.m_nSrcDepth * sizeof(float);

pAlphaResult = (float*)malloc( nSize );

memset( pAlphaResult, 0, nSize );

type = KERNEL_ALPHATEST;

}

else

{

type = KERNEL_DEFAULT;

}

if ( info.m_nFlags & RESAMPLE_NICE_FILTER )

{

g_KernelFuncNice[type]( kernel, info, wratio, hratio, dratio, gammaToLinear, pAlphaResult );

if (pTempMemory)

{

delete[] pTempMemory;

}

}

else

{

g_KernelFunc[type]( kernel, info, wratio, hratio, dratio, gammaToLinear, pAlphaResult );

}

if ( pAlphaResult )

{

free( pAlphaResult );

}

return true;

{

// HDRFIXME: This is some lame shit right here. (We need to get NICE working, etc, etc.)

// Make sure everything is power of two.

Assert( ( info.m_nSrcWidth & ( info.m_nSrcWidth - 1 ) ) == 0 );

Assert( ( info.m_nSrcHeight & ( info.m_nSrcHeight - 1 ) ) == 0 );

Assert( ( info.m_nDestWidth & ( info.m_nDestWidth - 1 ) ) == 0 );

Assert( ( info.m_nDestHeight & ( info.m_nDestHeight - 1 ) ) == 0 );

// Make sure that we aren't upscsaling the image. . .we do`n't support that very well.

Assert( info.m_nSrcWidth >= info.m_nDestWidth );

Assert( info.m_nSrcHeight >= info.m_nDestHeight );

int nSampleWidth = info.m_nSrcWidth / info.m_nDestWidth;

int nSampleHeight = info.m_nSrcHeight / info.m_nDestHeight;

unsigned short *pSrc = ( unsigned short * )info.m_pSrc;

unsigned short *pDst = ( unsigned short * )info.m_pDest;

int x, y;

for( y = 0; y < info.m_nDestHeight; y++ )

{

for( x = 0; x < info.m_nDestWidth; x++ )

{

int accum[4];

accum[0] = accum[1] = accum[2] = accum[3] = 0;

int nSampleY;

for( nSampleY = 0; nSampleY < nSampleHeight; nSampleY++ )

{

int nSampleX;

for( nSampleX = 0; nSampleX < nSampleWidth; nSampleX++ )

{

accum[0] += ( int )pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+0];

accum[1] += ( int )pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+1];

accum[2] += ( int )pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+2];

accum[3] += ( int )pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+3];

}

}

int i;

for( i = 0; i < 4; i++ )

{

accum[i] /= ( nSampleWidth * nSampleHeight );

accum[i] = max( accum[i], 0 );

accum[i] = min( accum[i], 65535 );

pDst[(x+y*info.m_nDestWidth)*4+i] = ( unsigned short )accum[i];

}

}

}

return true;

{

// HDRFIXME: This is some lame shit right here. (We need to get NICE working, etc, etc.)

// Make sure everything is power of two.

Assert( ( info.m_nSrcWidth & ( info.m_nSrcWidth - 1 ) ) == 0 );

Assert( ( info.m_nSrcHeight & ( info.m_nSrcHeight - 1 ) ) == 0 );

Assert( ( info.m_nDestWidth & ( info.m_nDestWidth - 1 ) ) == 0 );

Assert( ( info.m_nDestHeight & ( info.m_nDestHeight - 1 ) ) == 0 );

// Make sure that we aren't upscaling the image. . .we do`n't support that very well.

Assert( info.m_nSrcWidth >= info.m_nDestWidth );

Assert( info.m_nSrcHeight >= info.m_nDestHeight );

int nSampleWidth = info.m_nSrcWidth / info.m_nDestWidth;

int nSampleHeight = info.m_nSrcHeight / info.m_nDestHeight;

float *pSrc = ( float * )info.m_pSrc;

float *pDst = ( float * )info.m_pDest;

int x, y;

for( y = 0; y < info.m_nDestHeight; y++ )

{

for( x = 0; x < info.m_nDestWidth; x++ )

{

float accum[4];

accum[0] = accum[1] = accum[2] = accum[3] = 0;

int nSampleY;

for( nSampleY = 0; nSampleY < nSampleHeight; nSampleY++ )

{

int nSampleX;

for( nSampleX = 0; nSampleX < nSampleWidth; nSampleX++ )

{

accum[0] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*3+0];

accum[1] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*3+1];

accum[2] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*3+2];

}

}

int i;

for( i = 0; i < 3; i++ )

{

accum[i] /= ( nSampleWidth * nSampleHeight );

pDst[(x+y*info.m_nDestWidth)*3+i] = accum[i];

}

}

}

return true;

int height, int depth, ImageFormat imageFormat, float srcGamma, float dstGamma, int numLevels )

{

int dstWidth = width;

int dstHeight = height;

int dstDepth = depth;

// temporary storage for the mipmaps

int tempMem = GetMemRequired( dstWidth, dstHeight, dstDepth, IMAGE_FORMAT_RGBA8888, false );

CUtlMemory<unsigned char> tmpImage;

tmpImage.EnsureCapacity( tempMem );

while( true )

{

// This generates a mipmap in RGBA8888, linear space

ResampleInfo_t info;

info.m_pSrc = pSrc;

info.m_pDest = tmpImage.Base();

info.m_nSrcWidth = width;

info.m_nSrcHeight = height;

info.m_nSrcDepth = depth;

info.m_nDestWidth = dstWidth;

info.m_nDestHeight = dstHeight;

info.m_nDestDepth = dstDepth;

info.m_flSrcGamma = srcGamma;

info.m_flDestGamma = dstGamma;

ResampleRGBA8888( info );

// each mipmap level needs to be color converted separately

ConvertImageFormat( tmpImage.Base(), IMAGE_FORMAT_RGBA8888,

pDst, imageFormat, dstWidth, dstHeight, 0, 0 );

if (numLevels == 0)

{

// We're done after we've made the 1x1 mip level

if (dstWidth == 1 && dstHeight == 1 && dstDepth == 1)

return;

}

else

{

if (--numLevels <= 0)

return;

}

// Figure out where the next level goes

int memRequired = ImageLoader::GetMemRequired( dstWidth, dstHeight, dstDepth, imageFormat, false);

pDst += memRequired;

// shrink by a factor of 2, but clamp at 1 pixel (non-square textures)

dstWidth = dstWidth > 1 ? dstWidth >> 1 : 1;

dstHeight = dstHeight > 1 ? dstHeight >> 1 : 1;

dstDepth = dstDepth > 1 ? dstDepth >> 1 : 1;

}

ImageFormat imageFormat, int numLevels )

{

CUtlMemory<unsigned char> tmpImage;

const unsigned char* pSrcLevel = pSrc;

int mipmap0Size = GetMemRequired( width, height, 1, IMAGE_FORMAT_RGBA8888, false );

// TODO: Could work with any 8888 format without conversion.

if ( imageFormat != IMAGE_FORMAT_RGBA8888 )

{

// Damn and blast, had to allocate memory.

tmpImage.EnsureCapacity( mipmap0Size );

ConvertImageFormat( tmpImage.Base(), IMAGE_FORMAT_RGBA8888, pSrc, imageFormat, width, height, 0, 0 );

pSrcLevel = tmpImage.Base();

}

// Copy the 0th level over.

memcpy( pDst, pSrcLevel, mipmap0Size );

int dstWidth = width;

int dstHeight = height;

unsigned char* pDstLevel = pDst + mipmap0Size;

int srcWidth = width;

int srcHeight = height;

// Distance from one pixel to the next

const int cStride = 4;

do

{

dstWidth = Max( 1, dstWidth >> 1 );

dstHeight = Max( 1, dstHeight >> 1 );

// Distance from one row to the next.

const int cSrcPitch = cStride * srcWidth * ( srcHeight > 1 ? 1 : 0);

const int cSrcStride = srcWidth > 1 ? cStride : 0;

const unsigned char* pSrcPixel = pSrcLevel;

unsigned char* pDstPixel = pDstLevel;

for ( int j = 0; j < dstHeight; ++j )

{

for ( int i = 0; i < dstWidth; ++i )

{

// This doesn't round. It's crappy. It's a simple bilerp.

pDstPixel[ 0 ] = ( ( unsigned int ) pSrcPixel[ 0 ] + ( unsigned int ) pSrcPixel[ 0 + cSrcStride ] + ( unsigned int ) pSrcPixel[ 0 + cSrcPitch ] + ( unsigned int ) pSrcPixel[ 0 + cSrcPitch + cSrcStride ] ) >> 2;

pDstPixel[ 1 ] = ( ( unsigned int ) pSrcPixel[ 1 ] + ( unsigned int ) pSrcPixel[ 1 + cSrcStride ] + ( unsigned int ) pSrcPixel[ 1 + cSrcPitch ] + ( unsigned int ) pSrcPixel[ 1 + cSrcPitch + cSrcStride ] ) >> 2;

pDstPixel[ 2 ] = ( ( unsigned int ) pSrcPixel[ 2 ] + ( unsigned int ) pSrcPixel[ 2 + cSrcStride ] + ( unsigned int ) pSrcPixel[ 2 + cSrcPitch ] + ( unsigned int ) pSrcPixel[ 2 + cSrcPitch + cSrcStride ] ) >> 2;

pDstPixel[ 3 ] = ( ( unsigned int ) pSrcPixel[ 3 ] + ( unsigned int ) pSrcPixel[ 3 + cSrcStride ] + ( unsigned int ) pSrcPixel[ 3 + cSrcPitch ] + ( unsigned int ) pSrcPixel[ 3 + cSrcPitch + cSrcStride ] ) >> 2;

pDstPixel += cStride;

pSrcPixel += cStride * 2; // We advance 2 source pixels for each pixel.

}

// Need to bump down a row.

pSrcPixel += cSrcPitch;

}

// Update for the next go round!

pSrcLevel = pDstLevel;

pDstLevel += GetMemRequired( dstWidth, dstHeight, 1, IMAGE_FORMAT_RGBA8888, false );

srcWidth = Max( 1, srcWidth >> 1 );

srcHeight = Max( 1, srcHeight >> 1 );

} while ( srcWidth > 1 || srcHeight > 1 );