OODefaultShaderSynthesizer.m File Reference

import "OODefaultShaderSynthesizer.h"
import "OOMesh.h"
import "OOTexture.h"
import "OOColor.h"
import "NSStringOOExtensions.h"
import "OOCollectionExtractors.h"
import "NSDictionaryOOExtensions.h"
import "OOMaterialSpecifier.h"
import "ResourceManager.h"

Include dependency graph for OODefaultShaderSynthesizer.m:

Go to the source code of this file.

Classes
class	OODefaultShaderSynthesizer

Macros
#define	REQUIRE_STAGE(NAME)

Functions
static NSDictionary *	CanonicalizeMaterialSpecifier (NSDictionary *spec, NSString *materialKey)
static NSString *	FormatFloat (double value)
static NSString *	GetExtractMode (NSDictionary *textureSpecifier)
BOOL	OOSynthesizeMaterialShader (NSDictionary *configuration, NSString *materialKey, NSString *entityName, NSString **outVertexShader, NSString **outFragmentShader, NSArray **outTextureSpecs, NSDictionary **outUniformSpecs)

Macro Definition Documentation

REQUIRE_STAGE

#define REQUIRE_STAGE

(

NAME

)

Value:

if (!_completed_##NAME) { [self performStage:@selector(NAME)]; _completed_##NAME = YES; }

Definition at line 252 of file OODefaultShaderSynthesizer.m.

Function Documentation

CanonicalizeMaterialSpecifier()

static NSDictionary * CanonicalizeMaterialSpecifier ( NSDictionary * spec, NSString * materialKey )

static

Definition at line 1330 of file OODefaultShaderSynthesizer.m.

{
    NSMutableDictionary     *result = [NSMutableDictionary dictionary];
    OOColor                 *col = nil;
    id                      texSpec = nil;
    
    // Colours.
    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialDiffuseColorName]];
    if (col == nil)  col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialDiffuseColorLegacyName]];
    if (col != nil)  [result setObject:[col normalizedArray] forKey:kOOMaterialDiffuseColorName];
    
    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialAmbientColorName]];
    if (col == nil)  col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialAmbientColorLegacyName]];
    if (col != nil)  [result setObject:[col normalizedArray] forKey:kOOMaterialAmbientColorName];
    
    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialSpecularColorName]];
    if (col == nil)  col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialSpecularColorLegacyName]];
    if (col != nil)  [result setObject:[col normalizedArray] forKey:kOOMaterialSpecularColorName];
    
    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialSpecularModulateColorName]];
    if (col != nil)  [result setObject:[col normalizedArray] forKey:kOOMaterialSpecularModulateColorName];
    
    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialEmissionColorName]];
    if (col == nil)  col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialEmissionColorLegacyName]];
    if (col != nil)  [result setObject:[col normalizedArray] forKey:kOOMaterialEmissionColorName];
    
    // Diffuse map.
    texSpec = [spec objectForKey:kOOMaterialDiffuseMapName];
    if ([texSpec isKindOfClass:[NSString class]])
    {
        if ([texSpec length] > 0)
        {
            texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
        }
    }
    else if ([texSpec isKindOfClass:[NSDictionary class]])
    {
        /*  Special case for diffuse map: no name is changed to
            name = materialKey, while name = "" is changed to no name.
        */
        NSString *name = [texSpec objectForKey:kOOTextureSpecifierNameKey];
        if (name == nil)  texSpec = [texSpec dictionaryByAddingObject:materialKey forKey:kOOTextureSpecifierNameKey];
        else if ([name length] == 0)
        {
            texSpec = [texSpec dictionaryByRemovingObjectForKey:kOOTextureSpecifierNameKey];
        }
    }
    else
    {
        // Special case for unspecified diffuse map.
        texSpec = [NSDictionary dictionaryWithObject:materialKey forKey:kOOTextureSpecifierNameKey];
    }
    [result setObject:texSpec forKey:kOOMaterialDiffuseMapName];
    
    // Specular maps.
    {
        BOOL haveNewSpecular = NO;
        texSpec = [spec objectForKey:kOOMaterialSpecularColorMapName];
        if ([texSpec isKindOfClass:[NSString class]])
        {
            texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
        }
        else if (![texSpec isKindOfClass:[NSDictionary class]])
        {
            texSpec = nil;
        }
        if (texSpec != nil)
        {
            haveNewSpecular = YES;
            [result setObject:texSpec forKey:kOOMaterialSpecularColorMapName];
        }
        
        texSpec = [spec objectForKey:kOOMaterialSpecularExponentMapName];
        if ([texSpec isKindOfClass:[NSString class]])
        {
            texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
        }
        else if (![texSpec isKindOfClass:[NSDictionary class]])
        {
            texSpec = nil;
        }
        if (texSpec != nil)
        {
            haveNewSpecular = YES;
            [result setObject:texSpec forKey:kOOMaterialSpecularExponentMapName];
        }
        
        if (!haveNewSpecular)
        {
            // Fall back to legacy combined specular map if defined.
            texSpec = [spec objectForKey:kOOMaterialCombinedSpecularMapName];
            if ([texSpec isKindOfClass:[NSString class]])
            {
                texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
            }
            else if (![texSpec isKindOfClass:[NSDictionary class]])
            {
                texSpec = nil;
            }
            if (texSpec != nil)
            {
                [result setObject:texSpec forKey:kOOMaterialSpecularColorMapName];
                texSpec = [texSpec dictionaryByAddingObject:@"a" forKey:kOOTextureSpecifierSwizzleKey];
                [result setObject:texSpec forKey:kOOMaterialSpecularExponentMapName];
            }
        }
    }
    
    // Normal and parallax maps.
    {
        BOOL haveParallax = NO;
        BOOL haveNewNormal = NO;
        texSpec = [spec objectForKey:kOOMaterialNormalMapName];
        if ([texSpec isKindOfClass:[NSString class]])
        {
            texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
        }
        else if (![texSpec isKindOfClass:[NSDictionary class]])
        {
            texSpec = nil;
        }
        if (texSpec != nil)
        {
            haveNewNormal = YES;
            [result setObject:texSpec forKey:kOOMaterialNormalMapName];
        }
        
        texSpec = [spec objectForKey:kOOMaterialParallaxMapName];
        if ([texSpec isKindOfClass:[NSString class]])
        {
            texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
        }
        else if (![texSpec isKindOfClass:[NSDictionary class]])
        {
            texSpec = nil;
        }
        if (texSpec != nil)
        {
            haveNewNormal = YES;
            haveParallax = YES;
            [result setObject:texSpec forKey:kOOMaterialParallaxMapName];
        }
        
        if (!haveNewNormal)
        {
            // Fall back to legacy combined normal and parallax map if defined.
            texSpec = [spec objectForKey:kOOMaterialNormalAndParallaxMapName];
            if ([texSpec isKindOfClass:[NSString class]])
            {
                texSpec = [NSDictionary dictionaryWithObject:texSpec forKey:kOOTextureSpecifierNameKey];
            }
            else if (![texSpec isKindOfClass:[NSDictionary class]])
            {
                texSpec = nil;
            }
            if (texSpec != nil)
            {
                haveParallax = YES;
                [result setObject:texSpec forKey:kOOMaterialNormalMapName];
                texSpec = [texSpec dictionaryByAddingObject:@"a" forKey:kOOTextureSpecifierSwizzleKey];
                [result setObject:texSpec forKey:kOOMaterialParallaxMapName];
            }
        }
        
        // Additional parallax parameters.
        if (haveParallax)
        {
            float parallaxScale = [spec oo_floatForKey:kOOMaterialParallaxScaleName defaultValue:kOOMaterialDefaultParallaxScale];
            [result oo_setFloat:parallaxScale forKey:kOOMaterialParallaxScaleName];
            
            float parallaxBias = [spec oo_floatForKey:kOOMaterialParallaxBiasName];
            [result oo_setFloat:parallaxBias forKey:kOOMaterialParallaxBiasName];
        }
    }
    
    // Light maps.
    {
        NSMutableArray *lightMaps = [NSMutableArray array];
        id lightMapSpecs = [spec objectForKey:kOOMaterialLightMapsName];
        if (lightMapSpecs != nil && ![lightMapSpecs isKindOfClass:[NSArray class]])
        {
            lightMapSpecs = [NSArray arrayWithObject:lightMapSpecs];
        }
        
        id lmSpec = nil;
        foreach (lmSpec, lightMapSpecs)
        {
            if ([lmSpec isKindOfClass:[NSString class]])
            {
                lmSpec = [NSMutableDictionary dictionaryWithObject:lmSpec forKey:kOOTextureSpecifierNameKey];
            }
            else if ([lmSpec isKindOfClass:[NSDictionary class]])
            {
                lmSpec = [[lmSpec mutableCopy] autorelease];
            }
            else
            {
                continue;
            }
            
            id modulateColor = [lmSpec objectForKey:kOOTextureSpecifierModulateColorKey];
            if (modulateColor != nil && ![modulateColor isKindOfClass:[NSArray class]])
            {
                // Don't convert arrays here, because we specifically don't want the behaviour of treating numbers greater than 1 as 0..255 components.
                col = [OOColor colorWithDescription:modulateColor];
                [lmSpec setObject:[col normalizedArray] forKey:kOOTextureSpecifierModulateColorKey];
            }
            
            id binding = [lmSpec objectForKey:kOOTextureSpecifierBindingKey];
            if (binding != nil)
            {
                if ([binding isKindOfClass:[NSString class]])
                {
                    NSDictionary *expandedBinding = [NSDictionary dictionaryWithObjectsAndKeys:@"binding", @"type", binding, @"binding", nil];
                    [lmSpec setObject:expandedBinding forKey:kOOTextureSpecifierBindingKey];
                }
                else if (![binding isKindOfClass:[NSDictionary class]] || [[binding oo_stringForKey:@"binding"] length] == 0)
                {
                    [lmSpec removeObjectForKey:kOOTextureSpecifierBindingKey];
                }
            }
            
            [lightMaps addObject:[[lmSpec copy] autorelease]];
        }
        
        if ([lightMaps count] == 0)
        {
            // If light_map isn't use, handle legacy emission_map, illumination_map and emission_and_illumination_map.
            id emissionSpec = [spec objectForKey:kOOMaterialEmissionMapName];
            id illuminationSpec = [spec objectForKey:kOOMaterialIlluminationMapName];
            
            if (emissionSpec == nil && illuminationSpec == nil)
            {
                emissionSpec = [spec objectForKey:kOOMaterialEmissionAndIlluminationMapName];
                if ([emissionSpec isKindOfClass:[NSString class]])
                {
                    // Redundantish check required because we want to modify this as a dictionary to make illuminationSpec.
                    emissionSpec = [NSDictionary dictionaryWithObject:emissionSpec forKey:kOOTextureSpecifierNameKey];
                }
                else if (![emissionSpec isKindOfClass:[NSDictionary class]])
                {
                    emissionSpec = nil;
                }
                
                if (emissionSpec != nil)
                {
                    illuminationSpec = [emissionSpec dictionaryByAddingObject:@"a" forKey:kOOTextureSpecifierSwizzleKey];
                }
            }
            
            if (emissionSpec != nil)
            {
                if ([emissionSpec isKindOfClass:[NSString class]])
                {
                    emissionSpec = [NSDictionary dictionaryWithObject:emissionSpec forKey:kOOTextureSpecifierNameKey];
                }
                if ([emissionSpec isKindOfClass:[NSDictionary class]])
                {
                    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialEmissionModulateColorName]];
                    if (col != nil)  emissionSpec = [emissionSpec dictionaryByAddingObject:[col normalizedArray] forKey:kOOTextureSpecifierModulateColorKey];
                    
                    [lightMaps addObject:emissionSpec];
                }
            }
            
            if (illuminationSpec != nil)
            {
                if ([illuminationSpec isKindOfClass:[NSString class]])
                {
                    illuminationSpec = [NSDictionary dictionaryWithObject:illuminationSpec forKey:kOOTextureSpecifierNameKey];
                }
                if ([illuminationSpec isKindOfClass:[NSDictionary class]])
                {
                    col = [OOColor colorWithDescription:[spec objectForKey:kOOMaterialIlluminationModulateColorName]];
                    if (col != nil)  illuminationSpec = [illuminationSpec dictionaryByAddingObject:[col normalizedArray] forKey:kOOTextureSpecifierModulateColorKey];
                    
                    illuminationSpec = [illuminationSpec dictionaryByAddingObject:[NSNumber numberWithBool:YES] forKey:kOOTextureSpecifierIlluminationModeKey];
                    
                    [lightMaps addObject:illuminationSpec];
                }
            }
        }
        
        [result setObject:lightMaps forKey:kOOMaterialLightMapsName];
    }
    
    OOLog(@"material.canonicalForm", @"Canonicalized material %@:\nORIGINAL:\n%@\n\n@CANONICAL:\n%@", materialKey, spec, result);
    
    return result;
}

References OOColor::colorWithDescription:, count, OODefaultShaderSynthesizer::materialKey, nil, OOColor::normalizedArray, and OOLog.

Here is the call graph for this function:

FormatFloat()

static NSString * FormatFloat ( double value )

static

Definition at line 1622 of file OODefaultShaderSynthesizer.m.

{
    long long intValue = value;
    if (value == intValue)
    {
        return [NSString stringWithFormat:@"%lli.0", intValue];
    }
    else
    {
        return [NSString stringWithFormat:@"%g", value];
    }
}

GetExtractMode()

static NSString * GetExtractMode ( NSDictionary * textureSpecifier )

static

OOSynthesizeMaterialShader()

BOOL OOSynthesizeMaterialShader	(	NSDictionary *	configuration,
		NSString *	materialKey,
		NSString *	entityName,
		NSString **	outVertexShader,
		NSString **	outFragmentShader,
		NSArray **	outTextureSpecs,
		NSDictionary **	outUniformSpecs )

Definition at line 264 of file OODefaultShaderSynthesizer.m.

{
    NSCParameterAssert(configuration != nil && outVertexShader != NULL && outFragmentShader != NULL && outTextureSpecs != NULL && outUniformSpecs != NULL);
    
    NSAutoreleasePool *pool = [NSAutoreleasePool new];
    
    OODefaultShaderSynthesizer *synthesizer = [[OODefaultShaderSynthesizer alloc]
                                               initWithMaterialConfiguration:configuration
                                                                 materialKey:materialKey
                                                                  entityName:entityName];
    [synthesizer autorelease];
    
    BOOL OK = [synthesizer run];
    if (OK)
    {
        *outVertexShader = [[synthesizer vertexShader] retain];
        *outFragmentShader = [[synthesizer fragmentShader] retain];
        *outTextureSpecs = [[synthesizer textureSpecifications] retain];
        *outUniformSpecs = [[synthesizer uniformSpecifications] retain];
    }
    else
    {
        *outVertexShader = nil;
        *outFragmentShader = nil;
        *outTextureSpecs = nil;
        *outUniformSpecs = nil;
    }
    
    [pool release];
    
    [*outVertexShader autorelease];
    [*outFragmentShader autorelease];
    [*outTextureSpecs autorelease];
    [*outUniformSpecs autorelease];
    
    return YES;
}

References OODefaultShaderSynthesizer::fragmentShader, nil, OODefaultShaderSynthesizer::run, OODefaultShaderSynthesizer::textureSpecifications, OODefaultShaderSynthesizer::uniformSpecifications, and OODefaultShaderSynthesizer::vertexShader.

Here is the call graph for this function: