#include <OOCombinedEmissionMapGenerator.h>

Inheritance diagram for OOCombinedEmissionMapGenerator:

Collaboration diagram for OOCombinedEmissionMapGenerator:

Instance Methods
(id)	- initWithEmissionMapSpec:emissionColor:diffuseMap:diffuseColor:illuminationMapSpec:illuminationColor:optionsSpecifier:

(id)	- initWithEmissionAndIlluminationMapSpec:diffuseMap:diffuseColor:emissionColor:illuminationColor:optionsSpecifier:

(id)	- initWithEmissionMapSpec:emissionColor:diffuseMap:diffuseColor:illuminationMapSpec:illuminationColor:isCombinedMap:optionsSpecifier: `[implementation]`

(NSString *)	- constructCacheKey `[implementation]`

(void)	- dealloc `[implementation]`

(NSString *)	- descriptionComponents `[implementation]`

(uint32_t)	- textureOptions `[implementation]`

(GLfloat)	- anisotropy `[implementation]`

(GLfloat)	- lodBias `[implementation]`

(NSString *)	- cacheKey `[implementation]`

(void)	- loadTexture `[implementation]`

Instance Methods inherited from OOTextureGenerator
(BOOL)	- enqueue

Instance Methods inherited from OOTextureLoader
(BOOL)	- isReady

(BOOL)	- getResult:format:originalWidth:originalHeight:

(id)	- initWithPath:options:

(NSString *)	- path

(NSString *)	- shortDescriptionComponents `[implementation]`

(void)	- performAsyncTask `[implementation]`

(void)	- generateMipMapsForCubeMap `[implementation]`

(void)	- applySettings `[implementation]`

(void)	- getDesiredWidth:andHeight: `[implementation]`

(void)	- completeAsyncTask `[implementation]`

Instance Methods inherited from <OOAsyncWorkTask>

Private Attributes
NSString *	_cacheKey

NSDictionary *	_emissionSpec

NSDictionary *	_illuminationSpec

OOTexture *	_diffuseMap

OOPixMap	_emissionPx

OOPixMap	_diffusePx

OOPixMap	_illuminationPx

OOColor *	_emissionColor

OOColor *	_illuminationColor

BOOL	_isCombinedMap

uint32_t	_textureOptions

GLfloat	_anisotropy

GLfloat	_lodBias

NSString *	_emissionDesc

NSString *	_illuminationDesc

NSString *	_diffuseDesc

Additional Inherited Members
Class Methods inherited from OOTextureLoader
(id)	+ loaderWithPath:options:

(id)	+ loaderWithTextureSpecifier:extraOptions:folder:

(void)	+ setUp `[implementation]`

Protected Attributes inherited from OOTextureLoader
NSString *	_path

OOTextureFlags	_options

uint8_t	_generateMipMaps: 1

uint8_t	_scaleAsNormalMap: 1

uint8_t	_avoidShrinking: 1

uint8_t	_noScalingWhatsoever: 1

uint8_t	_extractChannel: 1

uint8_t	_allowCubeMap: 1

uint8_t	_isCubeMap: 1

uint8_t	_ready: 1

uint8_t	_extractChannelIndex

OOTextureDataFormat	_format

void *	_data

uint32_t	_width

uint32_t	_height

uint32_t	_originalWidth

uint32_t	_originalHeight

uint32_t	_shrinkThreshold

uint32_t	_maxSize

size_t	_rowBytes

Detailed Description

Definition at line 38 of file OOCombinedEmissionMapGenerator.h.

Method Documentation

◆ anisotropy

- (GLfloat) anisotropy

implementation

Reimplemented from OOTextureGenerator.

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

{
    return _anisotropy;
}

References OOPixMap::height, MIN, OOIsValidPixMap(), OOScalePixMap(), and OOPixMap::width.

Here is the call graph for this function:

◆ cacheKey

- (NSString *) cacheKey

implementation

Reimplemented from OOTextureGenerator.

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

{
    return _cacheKey;
}

◆ constructCacheKey

- (NSString *) constructCacheKey

implementation

Provided by category OOCombinedEmissionMapGenerator(Private).

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

{
    NSMutableString *cacheKey = [NSMutableString string];
    
    if (_isCombinedMap)  [cacheKey appendString:@"combined emission and illumination map;"];
    else  if (_emissionSpec == nil)  [cacheKey appendString:@"illumination map;"];
    else  if (_illuminationSpec == nil)  [cacheKey appendString:@"emission map;"];
    else [cacheKey appendString:@"merged emission and illumination map;"];
    
    NSString *emissionDesc = nil;
    if (_emissionSpec != nil)
    {
        emissionDesc = OOTextureCacheKeyForSpecifier(_emissionSpec);
        [cacheKey appendFormat:@"emission:{%@}", emissionDesc];
        if (_emissionColor != nil)  [cacheKey appendFormat:@"*%@", [_emissionColor rgbaDescription]];
        [cacheKey appendString:@";"];
    }
    
    NSString *illuminationDesc = nil;
    if (_isCombinedMap)
    {
        illuminationDesc = [NSString stringWithFormat:@"%@:a", emissionDesc];
    }
    else if (_illuminationSpec != nil)
    {
        illuminationDesc = OOTextureCacheKeyForSpecifier(_illuminationSpec);
    }
    
    if (illuminationDesc != nil)
    {
        [cacheKey appendFormat:@"illumination:{%@}*{%@}", illuminationDesc, [_diffuseMap cacheKey]];
        if (_illuminationColor != nil)  [cacheKey appendFormat:@"*%@", [_illuminationColor rgbaDescription]];
        [cacheKey appendString:@";"];
    }
    
    return cacheKey;
}

◆ dealloc

- (void) dealloc

implementation

Reimplemented from OOTextureLoader.

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

{
    DESTROY(_emissionSpec);
    DESTROY(_illuminationSpec);
    DESTROY(_diffuseMap);
    
    OOFreePixMap(&_emissionPx);
    OOFreePixMap(&_illuminationPx);
    OOFreePixMap(&_diffusePx);
    DESTROY(_emissionColor);
    DESTROY(_illuminationColor);
    
#ifndef NDEBUG
    DESTROY(_diffuseDesc);
    DESTROY(_emissionDesc);
    DESTROY(_illuminationDesc);
#endif
    
    [super dealloc];
}

◆ descriptionComponents

- (NSString *) descriptionComponents

implementation

Reimplemented from OOTextureLoader.

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

{
    NSMutableString *result = [NSMutableString string];
    BOOL haveIllumination = NO;
    
    if (_emissionDesc != nil)
    {
        [result appendFormat:@"emission map: %@", _emissionDesc];
        if (_isCombinedMap)
        {
            [result appendString:@".rgb"];
        }
        if (_emissionColor != nil)
        {
            [result appendFormat:@" * %@", [_emissionColor rgbaDescription]];
        }
        
        if (_isCombinedMap)
        {
            [result appendFormat:@", illumination map: %@.a", _emissionDesc];
            haveIllumination = YES;
        }
    }
    
    if (_illuminationDesc != nil)
    {
        if (_emissionDesc != nil)  [result appendString:@", "];
        [result appendFormat:@"illumination map: %@", _illuminationDesc];
        haveIllumination = YES;
    }
    
    if (haveIllumination)
    {
        if (_diffuseDesc != nil)
        {
            [result appendFormat:@" * %@", _diffuseDesc];
        }
        if (_illuminationColor != nil)
        {
            [result appendFormat:@" * %@", [_illuminationColor rgbaDescription]];
        }
    }
    
    return result;
}

◆ initWithEmissionAndIlluminationMapSpec:diffuseMap:diffuseColor:emissionColor:illuminationColor:optionsSpecifier:

- (id) initWithEmissionAndIlluminationMapSpec:	(NSDictionary *)	emissionAndIlluminationMapSpec
diffuseMap:	(OOTexture *)	diffuseMap
diffuseColor:	(OOColor *)	diffuseColor
emissionColor:	(OOColor *)	emissionColor
illuminationColor:	(OOColor *)	illuminationColor
optionsSpecifier:	(NSDictionary *)	spec

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

                                             :(NSDictionary *)emissionAndIlluminationMapSpec
                                   diffuseMap:(OOTexture *)diffuseMap
                                 diffuseColor:(OOColor *)diffuseColor
                                emissionColor:(OOColor *)emissionColor
                            illuminationColor:(OOColor *)illuminationColor
                             optionsSpecifier:(NSDictionary *)spec
{
    return [self initWithEmissionMapSpec:emissionAndIlluminationMapSpec
                           emissionColor:emissionColor
                              diffuseMap:diffuseMap
                            diffuseColor:diffuseColor
                     illuminationMapSpec:nil
                       illuminationColor:illuminationColor
                           isCombinedMap:YES
                        optionsSpecifier:spec];
}

◆ initWithEmissionMapSpec:emissionColor:diffuseMap:diffuseColor:illuminationMapSpec:illuminationColor:isCombinedMap:optionsSpecifier:

- (id) initWithEmissionMapSpec:	(NSDictionary *)	emissionMapSpec
emissionColor:	(OOColor *)	emissionColor
diffuseMap:	(OOTexture *)	diffuseMap
diffuseColor:	(OOColor *)	diffuseColor
illuminationMapSpec:	(NSDictionary *)	illuminationMapSpec
illuminationColor:	(OOColor *)	illuminationColor
isCombinedMap:	(BOOL)	isCombinedMap
optionsSpecifier:	(NSDictionary *)	spec

implementation

Provided by category OOCombinedEmissionMapGenerator(Private).

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

                              :(NSDictionary *)emissionMapSpec
                 emissionColor:(OOColor *)emissionColor
                    diffuseMap:(OOTexture *)diffuseMap
                  diffuseColor:(OOColor *)diffuseColor
           illuminationMapSpec:(NSDictionary *)illuminationMapSpec
             illuminationColor:(OOColor *)illuminationColor
                 isCombinedMap:(BOOL)isCombinedMap
              optionsSpecifier:(NSDictionary *)spec
{
    if (emissionMapSpec == nil && illuminationMapSpec == nil)
    {
        [self release];
        return nil;
    }
    
    NSParameterAssert(illuminationMapSpec == nil || !isCombinedMap);
    
    uint32_t options;
    GLfloat anisotropy;
    GLfloat lodBias;
    OOInterpretTextureSpecifier(spec, NULL, &options, &anisotropy, &lodBias, YES);
    options = OOApplyTextureOptionDefaults(options);
    
    if ((self = [super initWithPath:@"<generated emission map>" options:options]))
    {
        /*  Illumination contribution is:
            illuminationMap * illuminationColor * diffuseMap * diffuseColor
            Since illuminationColor and diffuseColor aren't used otherwise,
            we may as well combine them up front.
        */
        illuminationColor = ModulateColor(diffuseColor, illuminationColor);
                                          
        if ([emissionColor isWhite])  emissionColor = nil;
        if ([illuminationColor isWhite])  illuminationColor = nil;
        if (!isCombinedMap && illuminationMapSpec == nil)  diffuseMap = nil;    // Diffuse map is only used with illumination
        
        // Insert extraShrink flag here instead of using extraOptions later because we need it in cache key too.
        NSMutableDictionary *emissionSpec = [emissionMapSpec mutableCopy];
        [emissionSpec oo_setBool:YES forKey:kOOTextureSpecifierExtraShrinkKey];
        _emissionSpec = emissionSpec;
        
        NSMutableDictionary *illuminationSpec = [illuminationMapSpec mutableCopy];
        [illuminationSpec oo_setBool:YES forKey:kOOTextureSpecifierExtraShrinkKey];
        _illuminationSpec = illuminationSpec;
        
        _diffuseMap = [diffuseMap retain];
        
        _emissionColor = [emissionColor retain];
        _illuminationColor = [illuminationColor retain];
        _isCombinedMap = isCombinedMap;
        
        _textureOptions = options;
        _anisotropy = anisotropy;
        _lodBias = lodBias;
        
        _cacheKey = [self constructCacheKey];
        
        if ([OOTexture existingTextureForKey:_cacheKey] == nil)
        {
            /*  Extract pixmap from diffuse map. This must be done in the main
                thread even if scheduling is fixed, because it might involve
                reading back pixels from OpenGL.
            */
            if (diffuseMap != nil)
            {
                _diffusePx = [diffuseMap copyPixMapRepresentation];
#ifndef NDEBUG
                _diffuseDesc = [[diffuseMap shortDescription] copy];
#endif
            }
            
            /*  Extract emission and illumination pixmaps from loaders. Ideally,
                this would be done asynchronously, but that requires dependency
                management in OOAsyncWorkManager.
            */
            OOTextureDataFormat format;
            if (_emissionSpec != nil)
            {
                OOTextureLoader *emissionMapLoader = [OOTextureLoader loaderWithTextureSpecifier:_emissionSpec
                                                                                    extraOptions:0
                                                                                          folder:@"Textures"];
                [emissionMapLoader getResult:&_emissionPx format:&format originalWidth:NULL originalHeight:NULL];
#ifndef NDEBUG
                _emissionDesc = [[emissionMapLoader shortDescription] copy];
#endif
            }
            if (_illuminationSpec != nil)
            {
                OOTextureLoader *illuminationMapLoader = [OOTextureLoader loaderWithTextureSpecifier:_illuminationSpec
                                                                                        extraOptions:0
                                                                                              folder:@"Textures"];
                [illuminationMapLoader getResult:&_illuminationPx format:&format originalWidth:NULL originalHeight:NULL];
#ifndef NDEBUG
                _illuminationDesc = [[illuminationMapLoader shortDescription] copy];
#endif
            }
        }
    }
    
    return self;
}

◆ initWithEmissionMapSpec:emissionColor:diffuseMap:diffuseColor:illuminationMapSpec:illuminationColor:optionsSpecifier:

- (id) initWithEmissionMapSpec:	(NSDictionary *)	emissionMapSpec
emissionColor:	(OOColor *)	emissionColor
diffuseMap:	(OOTexture *)	diffuseMap
diffuseColor:	(OOColor *)	diffuseColor
illuminationMapSpec:	(NSDictionary *)	illuminationMapSpec
illuminationColor:	(OOColor *)	illuminationColor
optionsSpecifier:	(NSDictionary *)	spec

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

                              :(NSDictionary *)emissionMapSpec
                 emissionColor:(OOColor *)emissionColor
                    diffuseMap:(OOTexture *)diffuseMap
                  diffuseColor:(OOColor *)diffuseColor
           illuminationMapSpec:(NSDictionary *)illuminationMapSpec
             illuminationColor:(OOColor *)illuminationColor
              optionsSpecifier:(NSDictionary *)spec
{
    return [self initWithEmissionMapSpec:emissionMapSpec
                           emissionColor:emissionColor
                              diffuseMap:diffuseMap
                            diffuseColor:diffuseColor
                     illuminationMapSpec:illuminationMapSpec
                       illuminationColor:illuminationColor
                           isCombinedMap:NO
                        optionsSpecifier:spec];
}

◆ loadTexture

- (void) loadTexture

implementation

Reimplemented from OOTextureLoader.

Definition at line 463 of file OOCombinedEmissionMapGenerator.m.

{
    OOPixMap illuminationPx = kOONullPixMap;
    BOOL haveEmission = NO, haveIllumination = NO, haveDiffuse = NO;
    
#if DUMP_COMBINER
    static unsigned sTexID = 0;
    unsigned texID = ++sTexID, dumpCount = 0;
    
#define DUMP(pm, label) OODumpPixMap(pm, [NSString stringWithFormat:@"lightmap %u.%u - %@", texID, ++dumpCount, label]);
#else
#define DUMP(pm, label) do {} while (0)
#endif
    
    haveEmission = !OOIsNullPixMap(_emissionPx);
    if (haveEmission)  DUMP(_emissionPx, @"source emission map");
    
    // Extract illumination component if emission_and_illumination_map.
    if (haveEmission && _isCombinedMap && OOPixMapFormatHasAlpha(_emissionPx.format))
    {
        OOPixMapToRGBA(&_emissionPx);
        illuminationPx = OODuplicatePixMap(_emissionPx, 0);
        OOExtractPixMapChannel(&illuminationPx, 3, YES);
        haveIllumination = YES;
        DUMP(illuminationPx, @"extracted illumination map");
    }
    
    // Tint emission map if necessary.
    if (haveEmission && _emissionColor != nil)
    {
        OOPixMapModulateUniform(&_emissionPx, [_emissionColor redComponent], [_emissionColor greenComponent], [_emissionColor blueComponent], 1.0);
        DUMP(_emissionPx, @"modulated emission map");
    }
    
    if (!OOIsNullPixMap(_illuminationPx))
    {
        NSAssert(!_isCombinedMap, @"OOCombinedEmissionMapGenerator configured with both illumination map and combined emission/illumination map.");
        
        illuminationPx = _illuminationPx;
        _illuminationPx.pixels = NULL;
        haveIllumination = YES;
        DUMP(illuminationPx, @"source illumination map");
    }
    
    // Tint illumination map if necessary.
    if (haveIllumination && _illuminationColor != nil)
    {
        OOPixMapModulateUniform(&illuminationPx, [_illuminationColor redComponent], [_illuminationColor greenComponent], [_illuminationColor blueComponent], 1.0);
        DUMP(illuminationPx, @"modulated illumination map");
    }
    
    // Load diffuse map and combine with illumination map.
    haveDiffuse = !OOIsNullPixMap(_diffusePx);
    if (haveDiffuse)  DUMP(_diffusePx, @"source diffuse map");
    
    if (haveIllumination && haveDiffuse)
    {
        // Modulate illumination with diffuse map.
        ScaleToMatch(&_diffusePx, &illuminationPx);
        OOPixMapToRGBA(&_diffusePx);
        OOPixMapModulatePixMap(&illuminationPx, _diffusePx);
        DUMP(illuminationPx, @"combined diffuse and illumination map");
    }
    OOFreePixMap(&_diffusePx);
    
    if (haveIllumination)
    {
        if (haveEmission)
        {
            OOPixMapToRGBA(&illuminationPx);
            OOPixMapAddPixMap(&_emissionPx, illuminationPx);
            OOFreePixMap(&illuminationPx);
            DUMP(_emissionPx, @"combined emission and illumination map");
        }
        else if (haveIllumination)
        {
            // No explicit emission map -> modulated illumination map is our only emission map.
            _emissionPx = illuminationPx;
            haveEmission = YES;
            illuminationPx.pixels = NULL;
        }
        haveIllumination = NO;  // Either way, illumination is now baked into emission.
    }
    
    (void)haveEmission;
    (void)haveIllumination;
    
    // Done: emissionPx now contains combined emission map.
    OOCompactPixMap(&_emissionPx);
    if (OOIsValidPixMap(_emissionPx))
    {
        _data = _emissionPx.pixels;
        _width = _emissionPx.width;
        _height = _emissionPx.height;
        _rowBytes = _emissionPx.rowBytes;
        _format = _emissionPx.format;
        
        _emissionPx.pixels = NULL;  // So it won't be freed by -dealloc.
    }
    if (_data == NULL)
    {
        OOLogERR(@"texture.combinedEmissionMap.error", @"Unknown error loading %@", self);
    }
}