Inheritance diagram for OODefaultShaderSynthesizer:

Collaboration diagram for OODefaultShaderSynthesizer:

Instance Methods
(id)	- initWithMaterialConfiguration:materialKey:entityName:

(BOOL)	- run

(NSString *)	- vertexShader

(NSString *)	- fragmentShader

(NSArray *)	- textureSpecifications

(NSDictionary *)	- uniformSpecifications

(NSString *)	- materialKey

(NSString *)	- entityName

(void)	- createTemporaries

(void)	- destroyTemporaries

(void)	- composeVertexShader

(void)	- composeFragmentShader

(void)	- appendVariable:ofType:withPrefix:to:

(void)	- addAttribute:ofType:

(void)	- addVarying:ofType:

(void)	- addVertexUniform:ofType:

(void)	- addFragmentUniform:ofType:

(NSString *)	- defineBindingUniform:ofType:

(NSString *)	- readRGBForTextureSpec:mapName:

(NSString *)	- readOneChannelForTextureSpec:mapName:

(NSUInteger)	- textureIDForSpec:

(void)	- setUpOneTexture:

(void)	- getSampleName:andSwizzleOp:forTextureSpec:

(void)	- writeTextureCoordRead

(void)	- writeDiffuseColorTermIfNeeded

(void)	- writeDiffuseColorTerm

(void)	- writeDiffuseLighting

(void)	- writeLightVector

(void)	- writeEyeVector

(void)	- writeVertexTangentBasis

(void)	- writeNormalIfNeeded

(void)	- writeNormal

(void)	- writeSpecularLighting

(void)	- writeLightMaps

(void)	- writeVertexPosition

(void)	- writeTotalColor

(void)	- writeFinalColorComposite

(void)	- performStage:

(void)	- dealloc `[implementation]`

(NSUInteger)	- assignIDForTexture: `[implementation]`

Class Methods
(static void)	+ AppendIfNotEmpty `[implementation]`

(static NSString *)	+ GetExtractMode `[implementation]`

(static NSString *)	+ KeyFromTextureParameters `[implementation]`

(static NSString *)	+ KeyFromTextureSpec `[implementation]`

Private Attributes
NSDictionary *	_configuration

NSString *	_materialKey

NSString *	_entityName

NSString *	_vertexShader

NSString *	_fragmentShader

NSMutableArray *	_textures

NSMutableDictionary *	_uniforms

NSMutableString *	_attributes

NSMutableString *	_varyings

NSMutableString *	_vertexUniforms

NSMutableString *	_fragmentUniforms

NSMutableString *	_vertexHelpers

NSMutableString *	_fragmentHelpers

NSMutableString *	_vertexBody

NSMutableString *	_fragmentPreTextures

NSMutableString *	_fragmentTextureLookups

NSMutableString *	_fragmentBody

NSMutableDictionary *	_texturesByName

NSMutableDictionary *	_textureIDs

NSHashTable *	_sampledTextures

NSMutableDictionary *	_uniformBindingNames

NSUInteger	_usesNormalMap: 1

NSUInteger	_usesDiffuseTerm: 1

NSUInteger	_constZNormal: 1

NSUInteger	_haveDiffuseLight: 1

NSUInteger	_completed_writeFinalColorComposite: 1

NSUInteger	_completed_writeDiffuseColorTerm: 1

NSUInteger	_completed_writeSpecularLighting: 1

NSUInteger	_completed_writeLightMaps: 1

NSUInteger	_completed_writeDiffuseLighting: 1

NSUInteger	_completed_writeDiffuseColorTermIfNeeded: 1

NSUInteger	_completed_writeVertexPosition: 1

NSUInteger	_completed_writeNormalIfNeeded: 1

NSUInteger	_completed_writeLightVector: 1

NSUInteger	_completed_writeEyeVector: 1

NSUInteger	_completed_writeTotalColor: 1

NSUInteger	_completed_writeTextureCoordRead: 1

NSUInteger	_completed_writeVertexTangentBasis: 1

NSHashTable *	_stagesInProgress

Detailed Description

Definition at line 56 of file OODefaultShaderSynthesizer.m.

Method Documentation

◆ addAttribute:ofType:

- (void) addAttribute:		(NSString *)	name
ofType:		(NSString *)	type

Definition at line 418 of file OODefaultShaderSynthesizer.m.

                     :(NSString *)name ofType:(NSString *)type
{
    [self appendVariable:name ofType:type withPrefix:@"attribute" to:_attributes];
}

References nil.

◆ addFragmentUniform:ofType:

- (void) addFragmentUniform:		(NSString *)	name
ofType:		(NSString *)	type

Definition at line 418 of file OODefaultShaderSynthesizer.m.

                           :(NSString *)name ofType:(NSString *)type
{
    [self appendVariable:name ofType:type withPrefix:@"uniform" to:_fragmentUniforms];
}

◆ addVarying:ofType:

- (void) addVarying:		(NSString *)	name
ofType:		(NSString *)	type

Definition at line 418 of file OODefaultShaderSynthesizer.m.

                   :(NSString *)name ofType:(NSString *)type
{
    [self appendVariable:name ofType:type withPrefix:@"varying" to:_varyings];
}

◆ addVertexUniform:ofType:

- (void) addVertexUniform:		(NSString *)	name
ofType:		(NSString *)	type

Definition at line 418 of file OODefaultShaderSynthesizer.m.

                         :(NSString *)name ofType:(NSString *)type
{
    [self appendVariable:name ofType:type withPrefix:@"uniform" to:_vertexUniforms];
}

◆ AppendIfNotEmpty

+ (static void) AppendIfNotEmpty	(NSMutableString *)	buffer
	(NSString *)	segment
	(NSString *)	name

implementation

Definition at line 407 of file OODefaultShaderSynthesizer.m.

{
    if ([segment length] > 0)
    {
        if ([buffer length] > 0)  [buffer appendString:@"\n\n"];
        if ([name length] > 0)  [buffer appendFormat:@"// %@\n", name];
        [buffer appendString:segment];
    }
}

◆ appendVariable:ofType:withPrefix:to:

- (void) appendVariable:	(NSString *)	name
ofType:	(NSString *)	type
withPrefix:	(NSString *)	prefix
to:	(NSMutableString *)	buffer

Definition at line 418 of file OODefaultShaderSynthesizer.m.

                       :(NSString *)name ofType:(NSString *)type withPrefix:(NSString *)prefix to:(NSMutableString *)buffer
{
    NSUInteger typeDeclLength = [prefix length] + [type length] + 1;
    NSUInteger padding = (typeDeclLength < 20) ? (23 - typeDeclLength) / 4 : 1;
    [buffer appendFormat:@"%@ %@%@%@;\n", prefix, type, OOTabString(padding), name];
}

◆ assignIDForTexture:

- (NSUInteger) assignIDForTexture: (NSDictionary *) spec

implementation

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                                 :(NSDictionary *)spec
{
    NSParameterAssert(spec != nil);
    
    // extract_channel doesn't affect uniqueness, and we don't want OOTexture to do actual extraction.
    if ([spec objectForKey:kOOTextureSpecifierSwizzleKey] != nil)
    {
        spec = [spec dictionaryByRemovingObjectForKey:kOOTextureSpecifierSwizzleKey];
    }
    
    NSString *texName = nil;
    OOTextureFlags texOptions;
    float anisotropy, lodBias;
    if (!OOInterpretTextureSpecifier(spec, &texName, &texOptions, &anisotropy, &lodBias, YES))
    {
        // OOInterpretTextureSpecifier() will have logged something.
        [NSException raise:NSGenericException format:@"Invalid texture specifier"];
    }
    
    if (texOptions & kOOTextureAllowCubeMap)
    {
        // cube_map = true; fail regardless of whether actual texture qualifies.
        OOLogERR(@"material.synthesis.error.cubeMap", @"The material \"%@\" of \"%@\" specifies a cube map texture, but doesn't have custom shaders. Cube map textures are not supported with the default shaders.", [self materialKey], [self entityName]);
        [NSException raise:NSGenericException format:@"Invalid material"];
    }
    
    NSString *key = KeyFromTextureParameters(texName, texOptions, anisotropy, lodBias);
    NSUInteger texID;
    NSObject *existing = [_texturesByName objectForKey:key];
    if (existing == nil)
    {
        texID = [_texturesByName count];
        NSNumber    *texIDObj = [NSNumber numberWithUnsignedInteger:texID];
        NSString    *texUniform = [NSString stringWithFormat:@"uTexture%lu", texID];
        
#ifndef NDEBUG
        BOOL useInternalFormat = NO;
#else
        BOOL useInternalFormat = YES;
#endif
        
        [_textures addObject:OOMakeTextureSpecifier(texName, texOptions, anisotropy, lodBias, useInternalFormat)];
        [_texturesByName setObject:spec forKey:key];
        [_textureIDs setObject:texIDObj forKey:key];
        [_uniforms setObject:[NSDictionary dictionaryWithObjectsAndKeys:@"texture", @"type", texIDObj, @"value", nil]
                      forKey:texUniform];
        
        [self addFragmentUniform:texUniform ofType:@"sampler2D"];
    }
    else
    {
        texID = [_textureIDs oo_unsignedIntegerForKey:texName];
    }
    
    return texID;
}

References KeyFromTextureParameters, nil, and OOInterpretTextureSpecifier().

Here is the call graph for this function:

◆ composeFragmentShader

- (void) composeFragmentShader

Definition at line 418 of file OODefaultShaderSynthesizer.m.

{
    while ([_fragmentBody hasSuffix:@"\t\n"])
    {
        [_fragmentBody deleteCharactersInRange:(NSRange){ [_fragmentBody length] - 2, 2 }];
    }
    
    NSMutableString *fragmentShader = [NSMutableString string];
    AppendIfNotEmpty(fragmentShader, _fragmentUniforms, @"Uniforms");
    AppendIfNotEmpty(fragmentShader, _varyings, @"Varyings");
    AppendIfNotEmpty(fragmentShader, _fragmentHelpers, @"Helper functions");
    AppendIfNotEmpty(fragmentShader, _fragmentPreTextures, nil);
    if ([_fragmentTextureLookups length] > 0)
    {
        [fragmentShader appendString:@"\t\n\t// Texture lookups\n"];
        [fragmentShader appendString:_fragmentTextureLookups];
    }
    [fragmentShader appendString:@"\t\n"];
    [fragmentShader appendString:_fragmentBody];
    [fragmentShader appendString:@"}"];
    
#ifndef NDEBUG
    _fragmentShader = [fragmentShader copy];
#else
    _fragmentShader = [fragmentShader retain];
#endif
}

◆ composeVertexShader

- (void) composeVertexShader

Definition at line 418 of file OODefaultShaderSynthesizer.m.

{
    while ([_vertexBody hasSuffix:@"\t\n"])
    {
        [_vertexBody deleteCharactersInRange:(NSRange){ [_vertexBody length] - 2, 2 }];
    }
    [_vertexBody appendString:@"}"];
    
    NSMutableString *vertexShader = [NSMutableString string];
    AppendIfNotEmpty(vertexShader, _attributes, @"Attributes");
    AppendIfNotEmpty(vertexShader, _vertexUniforms, @"Uniforms");
    AppendIfNotEmpty(vertexShader, _varyings, @"Varyings");
    AppendIfNotEmpty(vertexShader, _vertexHelpers, @"Helper functions");
    AppendIfNotEmpty(vertexShader, _vertexBody, nil);
    
#ifndef NDEBUG
    _vertexShader = [vertexShader copy];
#else
    _vertexShader = [vertexShader retain];
#endif
}

◆ createTemporaries

- (void) createTemporaries

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    _attributes = [[NSMutableString alloc] init];
    _varyings = [[NSMutableString alloc] init];
    _vertexUniforms = [[NSMutableString alloc] init];
    _fragmentUniforms = [[NSMutableString alloc] init];
    _vertexHelpers = [[NSMutableString alloc] init];
    _fragmentHelpers = [[NSMutableString alloc] init];
    _vertexBody = [[NSMutableString alloc] init];
    _fragmentPreTextures = [[NSMutableString alloc] init];
    _fragmentTextureLookups = [[NSMutableString alloc] init];
    _fragmentBody = [[NSMutableString alloc] init];
    
    _textures = [[NSMutableArray alloc] init];
    _texturesByName = [[NSMutableDictionary alloc] init];
    _textureIDs = [[NSMutableDictionary alloc] init];
    _sampledTextures = NSCreateHashTable(NSIntegerHashCallBacks, 0);
    
    _uniformBindingNames = [[NSMutableDictionary alloc] init];
    
#ifndef NDEBUG
    _stagesInProgress = NSCreateHashTable(NSNonOwnedPointerHashCallBacks, 0);
#endif
}

◆ dealloc

- (void) dealloc

implementation

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
    [self destroyTemporaries];
    DESTROY(_configuration);
    DESTROY(_materialKey);
    DESTROY(_entityName);
    DESTROY(_vertexShader);
    DESTROY(_fragmentShader);
    DESTROY(_textures);
    
    [super dealloc];
}

◆ defineBindingUniform:ofType:

- (NSString *) defineBindingUniform:		(NSDictionary *)	binding
ofType:		(NSString *)	type

Definition at line 418 of file OODefaultShaderSynthesizer.m.

                                   :(NSDictionary *)binding ofType:(NSString *)type
{
    NSString *name = [binding oo_stringForKey:@"binding"];
    NSParameterAssert([name length] > 0);
    
    NSMutableDictionary *bindingSpec = [[binding mutableCopy] autorelease];
    if ([bindingSpec oo_stringForKey:@"type"] == nil)  [bindingSpec setObject:@"binding" forKey:@"type"];
    
    // Use existing uniform if one is defined.
    NSString *uniformName = [_uniformBindingNames objectForKey:bindingSpec];
    if (uniformName != nil)  return uniformName;
    
    // Capitalize first char of name, and prepend u.
    unichar firstChar = toupper([name characterAtIndex:0]);
    NSString *baseName = [NSString stringWithFormat:@"u%C%@", firstChar, [name substringFromIndex:1]];
    
    // Ensure name is unique.
    name = baseName;
    unsigned idx = 1;
    while ([_uniforms objectForKey:name] != nil)
    {
        name = [NSString stringWithFormat:@"%@%u", baseName, ++idx];
    }
    
    [self addFragmentUniform:name ofType:type];
    
    [_uniforms setObject:bindingSpec forKey:name];
    [_uniformBindingNames setObject:name forKey:bindingSpec];
    
    return name;
}

◆ destroyTemporaries

- (void) destroyTemporaries

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    DESTROY(_attributes);
    DESTROY(_varyings);
    DESTROY(_vertexUniforms);
    DESTROY(_fragmentUniforms);
    DESTROY(_vertexHelpers);
    DESTROY(_fragmentHelpers);
    DESTROY(_vertexBody);
    DESTROY(_fragmentPreTextures);
    DESTROY(_fragmentTextureLookups);
    DESTROY(_fragmentBody);
    
    DESTROY(_texturesByName);
    DESTROY(_textureIDs);
    if (_sampledTextures != NULL)
    {
        NSFreeHashTable(_sampledTextures);
        _sampledTextures = NULL;
    }
    
    DESTROY(_uniformBindingNames);
    
#ifndef NDEBUG
    if (_stagesInProgress != NULL)
    {
        NSFreeHashTable(_stagesInProgress);
        _stagesInProgress = NULL;
    }
#endif
}

◆ entityName

- (NSString *) entityName

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
    return _entityName;
}

◆ fragmentShader

- (NSString *) fragmentShader

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
    return _fragmentShader;
}

Referenced by OOSynthesizeMaterialShader().

Here is the caller graph for this function:

◆ GetExtractMode

+ (static NSString *) GetExtractMode (NSDictionary *) textureSpecifier

implementation

Definition at line 418 of file OODefaultShaderSynthesizer.m.

{
    NSString *result = nil;
    
    NSString *rawMode = [textureSpecifier oo_stringForKey:kOOTextureSpecifierSwizzleKey];
    if (rawMode != nil)
    {
        NSUInteger length = [rawMode length];
        if (1 <= length && length <= 4)
        {
            static NSCharacterSet *nonRGBACharset = nil;
            if (nonRGBACharset == nil)
            {
                nonRGBACharset = [[[NSCharacterSet characterSetWithCharactersInString:@"rgba"] invertedSet] retain];
            }
            
            if ([rawMode rangeOfCharacterFromSet:nonRGBACharset].location == NSNotFound)
            {
                result = rawMode;
            }
        }
    }
    
    return result;
}

◆ getSampleName:andSwizzleOp:forTextureSpec:

- (void) getSampleName:	(NSString **)	outSampleName
andSwizzleOp:	(NSString **)	outSwizzleOp
forTextureSpec:	(NSDictionary *)	textureSpec

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                      :(NSString **)outSampleName andSwizzleOp:(NSString **)outSwizzleOp forTextureSpec:(NSDictionary *)textureSpec
{
    NSParameterAssert(outSampleName != NULL && outSwizzleOp != NULL && textureSpec != nil);
    
    [self setUpOneTexture:textureSpec];
    NSUInteger  texID = [self textureIDForSpec:textureSpec];
    
    *outSampleName = [NSString stringWithFormat:@"tex%luSample", texID];
    *outSwizzleOp = GetExtractMode(textureSpec);
}

◆ initWithMaterialConfiguration:materialKey:entityName:

- (id) initWithMaterialConfiguration:	(NSDictionary *)	configuration
materialKey:	(NSString *)	materialKey
entityName:	(NSString *)	name

Definition at line 110 of file OODefaultShaderSynthesizer.m.

                                    :(NSDictionary *)configuration
                         materialKey:(NSString *)materialKey
                          entityName:(NSString *)name
{
    if ((self = [super init]))
    {
        _configuration = [CanonicalizeMaterialSpecifier(configuration, materialKey) retain];
        _materialKey = [materialKey copy];
        _entityName = [_entityName copy];
    }
    
    return self;
}

◆ KeyFromTextureParameters

+ (static NSString *) KeyFromTextureParameters	(NSString *)	name
	(OOTextureFlags)	options
	(float)	anisotropy
	(float)	lodBias

implementation

Definition at line 568 of file OODefaultShaderSynthesizer.m.

{
#ifndef NDEBUG
    options = OOApplyTextureOptionDefaults(options);
#endif
    
    // Extraction modes are ignored in synthesized shaders, since we use swizzling instead.
    options &= ~kOOTextureExtractChannelMask;
    
    return [NSString stringWithFormat:@"%@:%X:%g:%g", name, options, anisotropy, lodBias];
}

References OOApplyTextureOptionDefaults().

Referenced by assignIDForTexture:.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ KeyFromTextureSpec

+ (static NSString *) KeyFromTextureSpec (NSDictionary *) spec

implementation

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    NSString *texName = nil;
    OOTextureFlags texOptions;
    float anisotropy, lodBias;
    if (!OOInterpretTextureSpecifier(spec, &texName, &texOptions, &anisotropy, &lodBias, YES))
    {
        // OOInterpretTextureSpecifier() will have logged something.
        [NSException raise:NSGenericException format:@"Invalid texture specifier"];
    }
    
    return KeyFromTextureParameters(texName, texOptions, anisotropy, lodBias);
}

◆ materialKey

- (NSString *) materialKey

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
    return _materialKey;
}

Referenced by CanonicalizeMaterialSpecifier().

Here is the caller graph for this function:

◆ performStage:

- (void) performStage: (SEL) stage

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                     :(SEL)stage
{
    // Ensure that we aren’t recursing.
    if (NSHashGet(_stagesInProgress, stage) != NULL)
    {
        OOLogERR(@"material.synthesis.error.recursion", @"Shader synthesis recursion for stage %@.", NSStringFromSelector(stage));
        [NSException raise:NSInternalInconsistencyException format:@"stage recursion"];
    }
    
    NSHashInsertKnownAbsent(_stagesInProgress, stage);
    
    [self performSelector:stage];
    
    NSHashRemove(_stagesInProgress, stage);
}

◆ readOneChannelForTextureSpec:mapName:

- (NSString *) readOneChannelForTextureSpec:		(NSDictionary *)	textureSpec
mapName:		(NSString *)	mapName

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                                           :(NSDictionary *)textureSpec mapName:(NSString *)mapName
{
    NSString *sample, *swizzle;
    [self getSampleName:&sample andSwizzleOp:&swizzle forTextureSpec:textureSpec];
    
    if (swizzle == nil)
    {
        return [sample stringByAppendingString:@".r"];
    }
    
    NSUInteger channelCount = [swizzle length];
    
    if (channelCount == 1)
    {
        return [NSString stringWithFormat:@"%@.%@", sample, swizzle];
    }
    
    OOLogWARN(@"material.synthesis.warning.extractionMismatch", @"The %@ map for material \"%@\" of \"%@\" specifies %lu channels to extract, but only %@ may be used.", mapName, [self materialKey], [self entityName], channelCount, @"1");
    return nil;
}

◆ readRGBForTextureSpec:mapName:

- (NSString *) readRGBForTextureSpec:		(NSDictionary *)	textureSpec
mapName:		(NSString *)	mapName

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                                    :(NSDictionary *)textureSpec mapName:(NSString *)mapName
{
    NSString *sample, *swizzle;
    [self getSampleName:&sample andSwizzleOp:&swizzle forTextureSpec:textureSpec];
    
    if (swizzle == nil)
    {
        return [sample stringByAppendingString:@".rgb"];
    }
    
    NSUInteger channelCount = [swizzle length];
    
    if (channelCount == 1)
    {
        return [NSString stringWithFormat:@"%@.%@%@%@", sample, swizzle, swizzle, swizzle];
    }
    else if (channelCount == 3)
    {
        return [NSString stringWithFormat:@"%@.%@", sample, swizzle];
    }
    
    OOLogWARN(@"material.synthesis.warning.extractionMismatch", @"The %@ map for material \"%@\" of \"%@\" specifies %lu channels to extract, but only %@ may be used.", mapName, [self materialKey], [self entityName], channelCount, @"1 or 3");
    return nil;
}

◆ run

- (BOOL) run

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
    [self createTemporaries];
    _uniforms = [[NSMutableDictionary alloc] init];
    [_vertexBody appendString:@"void main(void)\n{\n"];
    [_fragmentPreTextures appendString:@"void main(void)\n{\n"];
    
    @try
    {
        REQUIRE_STAGE(writeFinalColorComposite);
        
        [self composeVertexShader];
        [self composeFragmentShader];
    }
    @catch (NSException *exception)
    {
        // Error should have been reported already.
        return NO;
    }
    @finally
    {
        [self destroyTemporaries];
    }
    
    return YES;
}

Referenced by OOSynthesizeMaterialShader().

Here is the caller graph for this function:

◆ setUpOneTexture:

- (void) setUpOneTexture: (NSDictionary *) textureSpec

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                        :(NSDictionary *)textureSpec
{
    if (textureSpec == nil)  return;
    
    REQUIRE_STAGE(writeTextureCoordRead);
    
    NSUInteger texID = [self assignIDForTexture:textureSpec];
    if ((NSUInteger)NSHashGet(_sampledTextures, (const void *)(texID + 1)) == 0)
    {
        NSHashInsertKnownAbsent(_sampledTextures, (const void *)(texID + 1));
        [_fragmentTextureLookups appendFormat:@"\tvec4 tex%luSample = texture2D(uTexture%lu, texCoords);  // %@\n", texID, texID, [textureSpec oo_stringForKey:kOOTextureSpecifierNameKey]];
    }
}

◆ textureIDForSpec:

- (NSUInteger) textureIDForSpec: (NSDictionary *) textureSpec

Definition at line 580 of file OODefaultShaderSynthesizer.m.

                               :(NSDictionary *)textureSpec
{
    return [_textureIDs oo_unsignedIntegerForKey:KeyFromTextureSpec(textureSpec)];
}

◆ textureSpecifications

- (NSArray *) textureSpecifications

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
#ifndef NDEBUG
    return [NSArray arrayWithArray:_textures];
#else
    return _textures;
#endif
}

Referenced by OOSynthesizeMaterialShader().

Here is the caller graph for this function:

◆ uniformSpecifications

- (NSDictionary *) uniformSpecifications

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
#ifndef NDEBUG
    return [NSDictionary dictionaryWithDictionary:_uniforms];
#else
    return _uniforms;
#endif
}

Referenced by OOSynthesizeMaterialShader().

Here is the caller graph for this function:

◆ vertexShader

- (NSString *) vertexShader

Definition at line 110 of file OODefaultShaderSynthesizer.m.

{
    return _vertexShader;
}

Referenced by OOSynthesizeMaterialShader().

Here is the caller graph for this function:

◆ writeDiffuseColorTerm

- (void) writeDiffuseColorTerm

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeDiffuseColorTermIfNeeded);
    
    if (!_usesDiffuseTerm)
    {
        [_fragmentBody appendString:@"\tconst vec3 diffuseColor = vec3(0.0);  // Diffuse colour is black.\n\t\n"];
    }
}

◆ writeDiffuseColorTermIfNeeded

- (void) writeDiffuseColorTermIfNeeded

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    NSDictionary        *diffuseMap = [_configuration oo_diffuseMapSpecifierWithDefaultName:[self materialKey]];
    OOColor             *diffuseColor = [_configuration oo_diffuseColor] ?: [OOColor whiteColor];
    
    if ([diffuseColor isBlack])  return;
    _usesDiffuseTerm = YES;
    
    BOOL haveDiffuseColor = NO;
    if (diffuseMap != nil)
    {
        NSString *readInstr = [self readRGBForTextureSpec:diffuseMap mapName:@"diffuse"];
        if (EXPECT_NOT(readInstr == nil))
        {
            [_fragmentBody appendString:@"\t// INVALID EXTRACTION KEY\n\t\n"];
        }
        else
        {
            [_fragmentBody appendFormat:@"\tvec3 diffuseColor = %@;\n", readInstr];
             haveDiffuseColor = YES;
        }
    }
    
    if (!haveDiffuseColor || ![diffuseColor isWhite])
    {
        float rgba[4];
        [diffuseColor getRed:&rgba[0] green:&rgba[1] blue:&rgba[2] alpha:&rgba[3]];
        NSString *format = nil;
        if (haveDiffuseColor)
        {
            format = @"\tdiffuseColor *= vec3(%@, %@, %@);\n";
        }
        else
        {
            format = @"\tconst vec3 diffuseColor = vec3(%@, %@, %@);\n";
            haveDiffuseColor = YES;
        }
        [_fragmentBody appendFormat:format, FormatFloat(rgba[0]), FormatFloat(rgba[1]), FormatFloat(rgba[2])];
    }
    
    (void) haveDiffuseColor;
    [_fragmentBody appendString:@"\t\n"];
}

◆ writeDiffuseLighting

- (void) writeDiffuseLighting

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeDiffuseColorTermIfNeeded);
    if (!_usesDiffuseTerm)  return;
    
    REQUIRE_STAGE(writeTotalColor);
    REQUIRE_STAGE(writeVertexPosition);
    REQUIRE_STAGE(writeNormalIfNeeded);
    REQUIRE_STAGE(writeLightVector);
    
    // FIXME: currently uncoloured diffuse and ambient lighting.
    NSString *normalDotLight = _constZNormal ? @"lightVector.z" : @"dot(normal, lightVector)";
    
    [_fragmentBody appendFormat:
    @"\t// Diffuse (Lambertian) and ambient lighting\n"
     "\tvec3 diffuseLight = (gl_LightSource[1].diffuse * max(0.0, %@) + gl_LightModel.ambient).rgb;\n\t\n",
     normalDotLight];
    
    _haveDiffuseLight = YES;
}

◆ writeEyeVector

- (void) writeEyeVector

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeVertexPosition);
    REQUIRE_STAGE(writeVertexTangentBasis);
    
    [self addVarying:@"vEyeVector" ofType:@"vec3"];
    
    [_vertexBody appendString:@"\tvEyeVector = position.xyz * TBN;\n\t\n"];
    [_fragmentPreTextures appendString:@"\tvec3 eyeVector = normalize(vEyeVector);\n\t\n"];
}

◆ writeFinalColorComposite

- (void) writeFinalColorComposite

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeTotalColor); // Needed even if none of the following stages does anything.
    REQUIRE_STAGE(writeDiffuseLighting);
    REQUIRE_STAGE(writeSpecularLighting);
    REQUIRE_STAGE(writeLightMaps);
    
    if (_haveDiffuseLight)
    {
        [_fragmentBody appendString:@"\ttotalColor += diffuseColor * diffuseLight;\n"];
    }
    
    [_fragmentBody appendString:@"\tgl_FragColor = vec4(totalColor, 1.0);\n\t\n"];
}

◆ writeLightMaps

- (void) writeLightMaps

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    NSArray *lightMaps = [_configuration oo_arrayForKey:kOOMaterialLightMapsName];
    NSUInteger idx, count = [lightMaps count];
    if (count == 0)  return;
    
    REQUIRE_STAGE(writeTotalColor);
    
    // Check if we need the diffuse colour term.
    for (idx = 0; idx < count; idx++)
    {
        NSDictionary *lightMapSpec = [lightMaps oo_dictionaryAtIndex:idx];
        if ([lightMapSpec oo_boolForKey:kOOTextureSpecifierIlluminationModeKey])
        {
            REQUIRE_STAGE(writeDiffuseColorTerm);
            REQUIRE_STAGE(writeDiffuseLighting);
            break;
        }
    }
    
    [_fragmentBody appendString:@"\tvec3 lightMapColor;\n"];
    
    for (idx = 0; idx < count; idx++)
    {
        NSDictionary    *lightMapSpec = [lightMaps oo_dictionaryAtIndex:idx];
        NSDictionary    *textureSpec = OOTextureSpecFromObject(lightMapSpec, nil);
        NSArray         *color = [lightMapSpec oo_arrayForKey:kOOTextureSpecifierModulateColorKey];
        float           rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
        BOOL            isIllumination = [lightMapSpec oo_boolForKey:kOOTextureSpecifierIlluminationModeKey];
        
        if (EXPECT_NOT(color == nil && textureSpec == nil))
        {
            [_fragmentBody appendString:@"\t// Light map with neither colour nor texture has no effect.\n\t\n"];
            continue;
        }
        
        if (color != nil)
        {
            NSUInteger idx, count = [color count];
            if (count > 4)  count = 4;
            for (idx = 0; idx < count; idx++)
            {
                rgba[idx] = [color oo_doubleAtIndex:idx];
            }
            rgba[0] *= rgba[3]; rgba[1] *= rgba[3]; rgba[2] *= rgba[3];
        }
        
        if (EXPECT_NOT((rgba[0] == 0.0f && rgba[1] == 0.0f && rgba[2] == 0.0f) ||
                       (!_usesDiffuseTerm && isIllumination)))
        {
            [_fragmentBody appendString:@"\t// Light map tinted black has no effect.\n\t\n"];
            continue;
        }
        
        if (textureSpec != nil)
        {
            NSString *readInstr = [self readRGBForTextureSpec:textureSpec mapName:@"light"];
            if (EXPECT_NOT(readInstr == nil))
            {
                [_fragmentBody appendString:@"\t// INVALID EXTRACTION KEY\n\n"];
                continue;
            }
            
            [_fragmentBody appendFormat:@"\tlightMapColor = %@;\n", readInstr];
            
            if (rgba[0] != 1.0f || rgba[1] != 1.0f || rgba[2] != 1.0f)
            {
                [_fragmentBody appendFormat:@"\tlightMapColor *= vec3(%@, %@, %@);\n", FormatFloat(rgba[0]), FormatFloat(rgba[1]), FormatFloat(rgba[2])];
            }
        }
        else
        {
            [_fragmentBody appendFormat:@"\tlightMapColor = vec3(%@, %@, %@);\n", FormatFloat(rgba[0]), FormatFloat(rgba[1]), FormatFloat(rgba[2])];
        }
        
        NSDictionary *binding = [textureSpec oo_dictionaryForKey:kOOTextureSpecifierBindingKey];
        if (binding != nil)
        {
            NSString *bindingName = [binding oo_stringForKey:@"binding"];
            NSDictionary *typeDict = [[ResourceManager shaderBindingTypesDictionary] oo_dictionaryForKey:@"player"];    // FIXME: select appropriate binding subset.
            NSString *bindingType = [typeDict oo_stringForKey:bindingName];
            NSString *glslType = nil;
            NSString *swizzle = @"";
            
            if ([bindingType isEqualToString:@"float"])
            {
                glslType = @"float";
            }
            else if ([bindingType isEqualToString:@"vector"])
            {
                glslType = @"vec3";
            }
            else if ([bindingType isEqualToString:@"color"])
            {
                glslType = @"vec4";
                swizzle = @".rgb";
            }
            
            if (glslType != nil)
            {
                NSString *uniformName = [self defineBindingUniform:binding ofType:bindingType];
                [_fragmentBody appendFormat:@"\tlightMapColor *= %@%@;\n", uniformName, swizzle];
            }
            else
            {
                if (bindingType == nil)
                {
                    OOLogERR(@"material.binding.error.unknown", @"Cannot bind light map to unknown attribute \"%@\".", bindingName);
                }
                else
                {
                    OOLogERR(@"material.binding.error.badType", @"Cannot bind light map to attribute \"%@\" of type %@.", bindingName, bindingType);
                }
                [_fragmentBody appendString:@"\tlightMapColor = vec3(0.0);  // Bad binding, see log.\n"];
            }
        }
        
        if (!isIllumination)
        {
            [_fragmentBody appendString:@"\ttotalColor += lightMapColor;\n\t\n"];
        }
        else
        {
            [_fragmentBody appendString:@"\tdiffuseLight += lightMapColor;\n\t\n"];
        }
    }
}

◆ writeLightVector

- (void) writeLightVector

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeVertexPosition);
    REQUIRE_STAGE(writeNormalIfNeeded);
    
    [self addVarying:@"vLightVector" ofType:@"vec3"];
    
    [_vertexBody appendString:
     @"\tvec3 lightVector = gl_LightSource[1].position.xyz;\n"
      "\tvLightVector = lightVector * TBN;\n\t\n"];
    [_fragmentBody appendFormat:@"\tvec3 lightVector = normalize(vLightVector);\n\t\n"];
}

◆ writeNormal

- (void) writeNormal

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeNormalIfNeeded);
    
    if (_constZNormal)
    {
        [_fragmentBody appendString:@"\tconst vec3 normal = vec3(0.0, 0.0, 1.0);\n\t\n"];
    }
}

◆ writeNormalIfNeeded

- (void) writeNormalIfNeeded

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    REQUIRE_STAGE(writeVertexPosition);
    REQUIRE_STAGE(writeVertexTangentBasis);
    
    NSDictionary *normalMap = [_configuration oo_normalMapSpecifier];
    if (normalMap == nil)
    {
        // FIXME: this stuff should be handled in OOMaterialSpecifier.m when synthesizer takes over the world. -- Ahruman 2012-02-08
        normalMap = [_configuration oo_normalAndParallaxMapSpecifier];
    }
    if (normalMap != nil)
    {
        NSString *sample, *swizzle;
        [self getSampleName:&sample andSwizzleOp:&swizzle forTextureSpec:normalMap];
        if (swizzle == nil)  swizzle = @"rgb";
        if ([swizzle length] == 3)
        {
            [_fragmentBody appendFormat:@"\tvec3 normal = normalize(%@.%@ - 0.5);\n\t\n", sample, swizzle];
            _usesNormalMap = YES;
            return;
        }
        else
        {
            OOLogWARN(@"material.synthesis.warning.extractionMismatch", @"The %@ map for material \"%@\" of \"%@\" specifies %lu channels to extract, but only %@ may be used.", @"normal", [self materialKey], [self entityName], [swizzle length], @"3");
        }
    }
    _constZNormal = YES;
}

◆ writeSpecularLighting

- (void) writeSpecularLighting

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    float specularExponent = [_configuration oo_specularExponent];
    if (specularExponent <= 0)  return;
    
    NSDictionary *specularColorMap = [_configuration oo_specularColorMapSpecifier];
    NSDictionary *specularExponentMap = [_configuration oo_specularExponentMapSpecifier];
    float scaleFactor = 1.0f;
    
    if (specularColorMap)
    {
        scaleFactor = [specularColorMap oo_doubleForKey:kOOTextureSpecifierScaleFactorKey defaultValue:1.0f];
    }
    
    OOColor *specularColor = nil;
    if (specularColorMap == nil)
    {
        specularColor = [_configuration oo_specularColor];
    }
    else
    {
        specularColor = [_configuration oo_specularModulateColor];
    }
    
    if ([specularColor isBlack])  return;
    
    BOOL modulateWithDiffuse = [specularColorMap oo_boolForKey:kOOTextureSpecifierSelfColorKey];
    
    REQUIRE_STAGE(writeTotalColor);
    REQUIRE_STAGE(writeNormalIfNeeded);
    REQUIRE_STAGE(writeEyeVector);
    REQUIRE_STAGE(writeLightVector);
    if (modulateWithDiffuse)
    {
        REQUIRE_STAGE(writeDiffuseColorTerm);
    }
    
    [_fragmentBody appendString:@"\t// Specular (Blinn-Phong) lighting\n"];
    
    BOOL haveSpecularColor = NO;
    if (specularColorMap != nil)
    {
        NSString *readInstr = [self readRGBForTextureSpec:specularColorMap mapName:@"specular colour"];
        if (EXPECT_NOT(readInstr == nil))
        {
            [_fragmentBody appendString:@"\t// INVALID EXTRACTION KEY\n\t\n"];
            return;
        }
        
        [_fragmentBody appendFormat:@"\tvec3 specularColor = %@;\n", readInstr];
        haveSpecularColor = YES;
    }
    
    if (!haveSpecularColor || ![specularColor isWhite])
    {
        float rgba[4];
        [specularColor getRed:&rgba[0] green:&rgba[1] blue:&rgba[2] alpha:&rgba[3]];
        
        NSString *comment = (scaleFactor == 1.0f) ? @"Constant colour" : @"Constant colour and scale factor";
        
        // Handle scale factor, colour, and colour alpha scaling as one multiply.
        scaleFactor *= rgba[3];
        rgba[0] *= scaleFactor;
        rgba[1] *= scaleFactor;
        rgba[2] *= scaleFactor;
        
        // Avoid reapplying scaleFactor below.
        scaleFactor = 1.0;
        
        NSString *format = nil;
        if (haveSpecularColor)
        {
            format = @"\tspecularColor *= vec3(%@, %@, %@);  // %@\n";
        }
        else
        {
            format = @"\tvec3 specularColor = vec3(%@, %@, %@);  // %@\n";
            haveSpecularColor = YES;
        }
        [_fragmentBody appendFormat:format, FormatFloat(rgba[0]), FormatFloat(rgba[1]), FormatFloat(rgba[2]), comment];
    }
    
    // Handle scale_factor if no constant colour.
    if (haveSpecularColor && scaleFactor != 1.0f)
    {
        [_fragmentBody appendFormat:@"\tspecularColor *= %@;  // Scale factor\n", FormatFloat(scaleFactor)];
    }
    
    // Handle self_color.
    if (modulateWithDiffuse)
    {
        [_fragmentBody appendString:@"\tspecularColor *= diffuseColor;  // Self-colouring\n"];
    }
    
    // Specular exponent.
    BOOL haveSpecularExponent = NO;
    if (specularExponentMap != nil)
    {
        NSString *readInstr = [self readOneChannelForTextureSpec:specularExponentMap mapName:@"specular exponent"];
        if (EXPECT_NOT(readInstr == nil))
        {
            [_fragmentBody appendString:@"\t// INVALID EXTRACTION KEY\n\t\n"];
            return;
        }
        
        [_fragmentBody appendFormat:@"\tfloat specularExponent = %@ * %.1f;\n", readInstr, specularExponent];
        haveSpecularExponent = YES;
    }
    if (!haveSpecularExponent)
    {
        [_fragmentBody appendFormat:@"\tconst float specularExponent = %.1f;\n", specularExponent];
    }
    
    if (_usesNormalMap)
    {
        [_fragmentBody appendFormat:@"\tvec3 reflection = reflect(lightVector, normal);\n"];
    }
    else
    {
        /*  reflect(I, N) is defined as I - 2 * dot(N, I) * N
            If N is (0,0,1), this becomes (I.x,I.y,-I.z).
        */
        [_fragmentBody appendFormat:@"\tvec3 reflection = vec3(lightVector.x, lightVector.y, -lightVector.z);  // Equivalent to reflect(lightVector, normal) since normal is known to be (0, 0, 1) in tangent space.\n"];
    }
    
    [_fragmentBody appendFormat:
    @"\tfloat specIntensity = dot(reflection, eyeVector);\n"
     "\tspecIntensity = pow(max(0.0, specIntensity), specularExponent);\n"
     "\ttotalColor += specIntensity * specularColor * gl_LightSource[1].specular.rgb;\n\t\n"];
}

◆ writeTextureCoordRead

- (void) writeTextureCoordRead

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    [self addVarying:@"vTexCoords" ofType:@"vec2"];
    [_vertexBody appendString:@"\tvTexCoords = gl_MultiTexCoord0.st;\n\t\n"];
    
    BOOL haveTexCoords = NO;
    NSDictionary *parallaxMap = [_configuration oo_parallaxMapSpecifier];
    
    if (parallaxMap != nil)
    {
        float parallaxScale = [_configuration oo_parallaxScale];
        if (parallaxScale != 0.0f)
        {
            /*
                We can’t call -getSampleName:... here because the standard
                texture loading mechanism has to occur after determining
                texture coordinates (duh).
            */
            NSString *swizzle = GetExtractMode(parallaxMap) ?: (NSString *)@"a";
            NSUInteger channelCount = [swizzle length];
            if (channelCount == 1)
            {
                haveTexCoords = YES;
                
                REQUIRE_STAGE(writeEyeVector);
                
                [_fragmentPreTextures appendString:@"\t// Parallax mapping\n"];
                
                NSUInteger texID = [self assignIDForTexture:parallaxMap];
                [_fragmentPreTextures appendFormat:@"\tfloat parallax = texture2D(uTexture%lu, vTexCoords).%@;\n", texID, swizzle];
                
                if (parallaxScale != 1.0f)
                {
                    [_fragmentPreTextures appendFormat:@"\tparallax *= %@;  // Parallax scale\n", FormatFloat(parallaxScale)];
                }
                
                float parallaxBias = [_configuration oo_parallaxBias];
                if (parallaxBias != 0.0)
                {
                    [_fragmentPreTextures appendFormat:@"\tparallax += %@;  // Parallax bias\n", FormatFloat(parallaxBias)];
                }
                
                [_fragmentPreTextures appendString:@"\tvec2 texCoords = vTexCoords - parallax * eyeVector.xy * vec2(1.0, -1.0);\n"];
            }
            else
            {
                OOLogWARN(@"material.synthesis.warning.extractionMismatch", @"The %@ map for material \"%@\" of \"%@\" specifies %lu channels to extract, but only %@ may be used.", @"parallax", [self materialKey], [self entityName], channelCount, @"1");
            }
        }
    }
    
    if (!haveTexCoords)
    {
        [_fragmentPreTextures appendString:@"\tvec2 texCoords = vTexCoords;\n"];
    }
}

◆ writeTotalColor

- (void) writeTotalColor

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    [_fragmentPreTextures appendString:@"\tvec3 totalColor = vec3(0.0);\n\t\n"];
}

◆ writeVertexPosition

- (void) writeVertexPosition

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    [_vertexBody appendString:
    @"\tvec4 position = gl_ModelViewMatrix * gl_Vertex;\n"
     "\tgl_Position = gl_ProjectionMatrix * position;\n\t\n"];
}

◆ writeVertexTangentBasis

- (void) writeVertexTangentBasis

Definition at line 580 of file OODefaultShaderSynthesizer.m.

{
    [self addAttribute:@"tangent" ofType:@"vec3"];
    
    [_vertexBody appendString:
     @"\t// Build tangent space basis\n"
      "\tvec3 n = gl_NormalMatrix * gl_Normal;\n"
      "\tvec3 t = gl_NormalMatrix * tangent;\n"
      "\tvec3 b = cross(n, t);\n"
      "\tmat3 TBN = mat3(t, b, n);\n\t\n"];
}