OOTextureScaling.h File Reference

import "OOPixMap.h"

Include dependency graph for OOTextureScaling.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
OOPixMap	OOScalePixMap (OOPixMap srcPixMap, OOPixMapDimension dstWidth, OOPixMapDimension dstHeight, BOOL leaveSpaceForMipMaps)
BOOL	OOGenerateMipMaps (void *textureBytes, OOPixMapDimension width, OOPixMapDimension height, OOPixMapFormat format)

Function Documentation

OOGenerateMipMaps()

BOOL OOGenerateMipMaps	(	void *	textureBytes,
		OOPixMapDimension	width,
		OOPixMapDimension	height,
		OOPixMapFormat	format
	)

Definition at line 343 of file OOTextureScaling.m.

{
    if (EXPECT_NOT(width != OORoundUpToPowerOf2_PixMap(width) || height != OORoundUpToPowerOf2_PixMap(height)))
    {
        OOLog(kOOLogParameterError, @"Non-power-of-two dimensions (%ux%u) passed to %s() - ignoring, data will be junk.", width, height, __PRETTY_FUNCTION__);
        return NO;
    }
    if (EXPECT_NOT(textureBytes == NULL))
    {
        OOLog(kOOLogParameterError, @"%@", @"NULL texture pointer passed to GenerateMipMaps().");
        return NO;
    }
    
    switch (format)
    {
        case kOOPixMapRGBA:
            return GenerateMipMaps4(textureBytes, width, height);
            
        case kOOPixMapGrayscale:
            return GenerateMipMaps1(textureBytes, width, height);
            
        case kOOPixMapGrayscaleAlpha:
            return GenerateMipMaps2(textureBytes, width, height);
            
        case kOOPixMapInvalidFormat:
            break;
    }
    
 
    OOLog(kOOLogParameterError, @"%s(): bad pixmap format (%@) - ignoring, data will be junk.", __PRETTY_FUNCTION__, OOPixMapFormatName(format));
    return NO;
}

References EXPECT_NOT, GenerateMipMaps1(), GenerateMipMaps2(), GenerateMipMaps4(), kOOLogParameterError, kOOPixMapGrayscale, kOOPixMapGrayscaleAlpha, kOOPixMapInvalidFormat, kOOPixMapRGBA, OOLog, OOPixMapFormatName(), and OORoundUpToPowerOf2_PixMap.

Here is the call graph for this function:

OOScalePixMap()

OOPixMap OOScalePixMap	(	OOPixMap	srcPixMap,
		OOPixMapDimension	dstWidth,
		OOPixMapDimension	dstHeight,
		BOOL	leaveSpaceForMipMaps
	)

Definition at line 245 of file OOTextureScaling.m.

{
    OOPixMap            dstPx = {0}, sparePx = {0};
    BOOL                OK = YES;
    
    //  Sanity check.
    if (EXPECT_NOT(!OOIsValidPixMap(srcPx)))
    {
        OOLogGenericParameterError();
        free(srcPx.pixels);
        return kOONullPixMap;
    }
    
    DUMP_SCALE_PREPARE();
    DUMP_SCALE_DUMP(srcPx, @"initial");
    
    if (srcPx.height < dstHeight)
    {
        // Stretch vertically. This requires a separate buffer.
        size_t dstSize = srcPx.rowBytes * dstHeight;
        if (leaveSpaceForMipMaps && dstWidth <= srcPx.width)  dstSize = dstSize * 4 / 3;
        
        dstPx = OOAllocatePixMap(srcPx.width, dstHeight, srcPx.format, 0, dstSize);
        if (EXPECT_NOT(!OOIsValidPixMap(dstPx)))  { OK = NO; goto FAIL; }
        
        StretchVertically(srcPx, dstPx);
        DUMP_SCALE_DUMP(dstPx, @"stretched vertically");
        
        sparePx = srcPx;
        srcPx = dstPx;
    }
    else if (dstHeight < srcPx.height)
    {
        // Squeeze vertically. This can be done in-place.
        SqueezeVertically(srcPx, dstHeight);
        srcPx.height = dstHeight;
        DUMP_SCALE_DUMP(srcPx, @"squeezed vertically");
    }
    
    if (srcPx.width < dstWidth)
    {
        // Stretch horizontally. This requires a separate buffer.
        size_t dstSize = OOPixMapBytesPerPixel(srcPx) * dstWidth * srcPx.height;
        if (leaveSpaceForMipMaps)  dstSize = dstSize * 4 / 3;
        
        if (dstSize <= sparePx.bufferSize)
        {
            dstPx = OOMakePixMap(sparePx.pixels, dstWidth, srcPx.height, srcPx.format, 0, sparePx.bufferSize);
            sparePx = kOONullPixMap;
        }
        else
        {
            dstPx = OOAllocatePixMap(dstWidth, srcPx.height, srcPx.format, 0, dstSize);
        }
        if (EXPECT_NOT(!OOIsValidPixMap(dstPx)))  { OK = NO; goto FAIL; }
        
        StretchHorizontally(srcPx, dstPx);
        DUMP_SCALE_DUMP(dstPx, @"stretched horizontally");
    }
    else if (dstWidth < srcPx.width)
    {
        // Squeeze horizontally. This can be done in-place.
        SqueezeHorizontally(srcPx, dstWidth);
        
        dstPx = srcPx;
        dstPx.width = dstWidth;
        dstPx.rowBytes = dstPx.width * OOPixMapBytesPerPixel(dstPx);
        DUMP_SCALE_DUMP(dstPx, @"squeezed horizontally");
    }
    else
    {
        // No horizontal scaling.
        dstPx = srcPx;
    }
    
    // Avoid a potential double free (if the realloc in EnsureCorrectDataSize() relocates the block).
    if (srcPx.pixels == dstPx.pixels)  srcPx.pixels = NULL;
    
    // dstPx is now the result.
    OK = EnsureCorrectDataSize(&dstPx, leaveSpaceForMipMaps);
    
FAIL:
    free(srcPx.pixels);
    if (sparePx.pixels != dstPx.pixels && sparePx.pixels != srcPx.pixels)
    {
        free(sparePx.pixels);
    }
    if (!OK)
    {
        free(dstPx.pixels);
        dstPx.pixels = NULL;
    }
    
    return OK ? dstPx : kOONullPixMap;
}

References DUMP_SCALE_DUMP, DUMP_SCALE_PREPARE, EnsureCorrectDataSize(), EXPECT_NOT, FAIL, OOPixMap::format, OOPixMap::height, kOONullPixMap, OOAllocatePixMap(), OOIsValidPixMap(), OOLogGenericParameterError, OOMakePixMap(), OOPixMapBytesPerPixel(), OOPixMap::pixels, OOPixMap::rowBytes, SqueezeHorizontally(), SqueezeVertically(), StretchHorizontally(), StretchVertically(), and OOPixMap::width.

Referenced by OOCombinedEmissionMapGenerator::anisotropy, and OOConvertCubeMapToLatLong().

Here is the call graph for this function:

Here is the caller graph for this function: