OOMaterialConvenienceCreators.m File Reference

import "OOMaterialConvenienceCreators.h"
import "OOMaterialSpecifier.h"
import "OOOpenGLExtensionManager.h"
import "OOShaderMaterial.h"
import "OOSingleTextureMaterial.h"
import "OOMultiTextureMaterial.h"
import "OOCollectionExtractors.h"
import "Universe.h"
import "OOCacheManager.h"
import "OOTexture.h"
import "OODebugFlags.h"

Include dependency graph for OOMaterialConvenienceCreators.m:

Go to the source code of this file.

Classes
struct	OOMaterialSynthContext

Macros
#define	USE_NEW_SHADER_SYNTHESIZER   0

Functions
static void	SetUniform (NSMutableDictionary *uniforms, NSString *key, NSString *type, id value)
static void	SetUniformFloat (OOMaterialSynthContext *context, NSString *key, float value)
static void	AddTexture (OOMaterialSynthContext *context, NSString *uniformName, NSString *nonShaderKey, NSString *macroName, NSDictionary *specifier)
static void	AddColorIfAppropriate (OOMaterialSynthContext *context, SEL selector, NSString *key, NSString *macroName)
static void	AddMacroColorIfAppropriate (OOMaterialSynthContext *context, SEL selector, NSString *macroName)
static void	SynthDiffuse (OOMaterialSynthContext *context, NSString *name)
static void	SynthEmissionAndIllumination (OOMaterialSynthContext *context)
static void	SynthNormalMap (OOMaterialSynthContext *context)
static void	SynthSpecular (OOMaterialSynthContext *context)

Macro Definition Documentation

USE_NEW_SHADER_SYNTHESIZER

#define USE_NEW_SHADER_SYNTHESIZER   0

Definition at line 29 of file OOMaterialConvenienceCreators.m.

Function Documentation

AddColorIfAppropriate()

void AddColorIfAppropriate ( OOMaterialSynthContext * context, SEL selector, NSString * key, NSString * macroName )

static

Definition at line 420 of file OOMaterialConvenienceCreators.m.

{
    OOColor *color = [context->inConfig performSelector:selector];
    
    if (color != nil)
    {
        [context->outConfig setObject:[color normalizedArray] forKey:key];
        if (macroName != nil)  [context->macros setObject:@"1" forKey:macroName];
    }
}

References nil, and OOColor::normalizedArray.

Referenced by SynthDiffuse(), and SynthEmissionAndIllumination().

Here is the call graph for this function:

Here is the caller graph for this function:

AddMacroColorIfAppropriate()

void AddMacroColorIfAppropriate ( OOMaterialSynthContext * context, SEL selector, NSString * macroName )

static

Definition at line 432 of file OOMaterialConvenienceCreators.m.

{
    OOColor *color = [context->inConfig performSelector:selector];
    
    if (color != nil)
    {
        NSString *macroText = [NSString stringWithFormat:@"vec4(%g, %g, %g, %g)",
                               [color redComponent],
                               [color greenComponent],
                               [color blueComponent],
                               [color alphaComponent]];
        [context->macros setObject:macroText forKey:macroName];
    }
}

References OOColor::alphaComponent, OOColor::blueComponent, OOColor::greenComponent, nil, and OOColor::redComponent.

Referenced by SynthEmissionAndIllumination().

Here is the call graph for this function:

Here is the caller graph for this function:

AddTexture()

void AddTexture ( OOMaterialSynthContext * context, NSString * uniformName, NSString * nonShaderKey, NSString * macroName, NSDictionary * specifier )

static

Definition at line 402 of file OOMaterialConvenienceCreators.m.

{
    NSCParameterAssert(context->texturesUsed < context->maxTextures);
    
    context->texturesUsed++;
    SetUniform(context->uniforms, uniformName, @"texture", [NSNumber numberWithUnsignedInteger:[context->textures count]]);
    [context->textures addObject:specifier];
    if (nonShaderKey != nil)
    {
        [context->outConfig setObject:specifier forKey:kOOMaterialDiffuseMapName];
    }
    if (macroName != nil)
    {
        [context->macros setObject:@"1" forKey:macroName];
    }
}

References count, OOMaterialSynthContext::maxTextures, nil, SetUniform(), OOMaterialSynthContext::textures, OOMaterialSynthContext::texturesUsed, and OOMaterialSynthContext::uniforms.

Referenced by SynthDiffuse(), SynthEmissionAndIllumination(), SynthNormalMap(), and SynthSpecular().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUniform()

void SetUniform ( NSMutableDictionary * uniforms, NSString * key, NSString * type, id value )

static

Definition at line 390 of file OOMaterialConvenienceCreators.m.

{
    [uniforms setObject:[NSDictionary dictionaryWithObjectsAndKeys:type, @"type", value, @"value", nil] forKey:key];
}

Referenced by AddTexture(), and SetUniformFloat().

Here is the caller graph for this function:

SetUniformFloat()

void SetUniformFloat ( OOMaterialSynthContext * context, NSString * key, float value )

static

Definition at line 396 of file OOMaterialConvenienceCreators.m.

{
    SetUniform(context->uniforms, key, @"float", [NSNumber numberWithFloat:value]);
}

References SetUniform(), and OOMaterialSynthContext::uniforms.

Referenced by SynthNormalMap(), and SynthSpecular().

Here is the call graph for this function:

Here is the caller graph for this function:

SynthDiffuse()

void SynthDiffuse ( OOMaterialSynthContext * context, NSString * name )

static

Definition at line 448 of file OOMaterialConvenienceCreators.m.

{
    // Set up diffuse map if appropriate.
    NSDictionary *diffuseMapSpec = [context->inConfig oo_diffuseMapSpecifierWithDefaultName:name];
    if (diffuseMapSpec != nil && context->texturesUsed < context->maxTextures)
    {
        AddTexture(context, @"uDiffuseMap", kOOMaterialDiffuseMapName, @"OOSTD_DIFFUSE_MAP", diffuseMapSpec);
        
        if ([diffuseMapSpec oo_boolForKey:@"cube_map"])
        {
            [context->macros setObject:@"1" forKey:@"OOSTD_DIFFUSE_MAP_IS_CUBE_MAP"];
        }
    }
    else
    {
        // No diffuse map must be specified explicitly.
        [context->outConfig setObject:@"" forKey:kOOMaterialDiffuseMapName];
    }
    
    // Set up diffuse colour if any.
    AddColorIfAppropriate(context, @selector(oo_diffuseColor), kOOMaterialDiffuseColorName, nil);
}

References AddColorIfAppropriate(), AddTexture(), kOOMaterialDiffuseColorName, kOOMaterialDiffuseMapName, OOMaterialSynthContext::maxTextures, nil, and OOMaterialSynthContext::texturesUsed.

Referenced by OOMaterial(OOConvenienceCreators)::synthesizeMaterialDictionaryWithName:configuration:macros:.

Here is the call graph for this function:

Here is the caller graph for this function:

SynthEmissionAndIllumination()

void SynthEmissionAndIllumination ( OOMaterialSynthContext * context )

static

Definition at line 472 of file OOMaterialConvenienceCreators.m.

{
    // Read the various emission and illumination textures, and decide what to do with them.
    NSDictionary *emissionMapSpec = [context->inConfig oo_emissionMapSpecifier];
    NSDictionary *illuminationMapSpec = [context->inConfig oo_illuminationMapSpecifier];
    NSDictionary *emissionAndIlluminationSpec = [context->inConfig oo_emissionAndIlluminationMapSpecifier];
    BOOL isCombinedSpec = NO;
    BOOL haveIlluminationMap = NO;
    
    if (emissionMapSpec == nil && emissionAndIlluminationSpec != nil)
    {
        emissionMapSpec = emissionAndIlluminationSpec;
        if (illuminationMapSpec == nil)  isCombinedSpec = YES;  // Else use only emission part of emission_and_illumination_map, combined with full illumination_map.
    }
    
    if (emissionMapSpec != nil && context->texturesUsed < context->maxTextures)
    {
        /*  FIXME: at this point, if there is an illumination map, we should
            consider merging it into the emission map using
            OOCombinedEmissionMapGenerator if the total number of texture
            specifiers is greater than context->maxTextures. This will
            require adding a new type of texture specifier - not a big deal.
            -- Ahruman 2010-05-21
        */
        AddTexture(context, @"uEmissionMap", nil, isCombinedSpec ? @"OOSTD_EMISSION_AND_ILLUMINATION_MAP" : @"OOSTD_EMISSION_MAP", emissionMapSpec);
        /*  Note that this sets emission_color, not emission_modulate_color.
            This is because the emission colour value is sent through the
            standard OpenGL emission colour attribute by OOBasicMaterial.
        */
        AddColorIfAppropriate(context, @selector(oo_emissionModulateColor), kOOMaterialEmissionColorName, @"OOSTD_EMISSION");
        
        haveIlluminationMap = isCombinedSpec;
    }
    else
    {
        //  No emission map, use overall emission colour if specified.
        AddColorIfAppropriate(context, @selector(oo_emissionColor), kOOMaterialEmissionColorName, @"OOSTD_EMISSION");
    }
    
    if (illuminationMapSpec != nil && context->texturesUsed < context->maxTextures)
    {
        AddTexture(context, @"uIlluminationMap", nil, @"OOSTD_ILLUMINATION_MAP", illuminationMapSpec);
        haveIlluminationMap = YES;
    }
    
    if (haveIlluminationMap)
    {
        AddMacroColorIfAppropriate(context, @selector(oo_illuminationModulateColor), @"OOSTD_ILLUMINATION_COLOR");
    }
}

References AddColorIfAppropriate(), AddMacroColorIfAppropriate(), AddTexture(), kOOMaterialEmissionColorName, OOMaterialSynthContext::maxTextures, nil, and OOMaterialSynthContext::texturesUsed.

Referenced by OOMaterial(OOConvenienceCreators)::synthesizeMaterialDictionaryWithName:configuration:macros:.

Here is the call graph for this function:

Here is the caller graph for this function:

SynthNormalMap()

void SynthNormalMap ( OOMaterialSynthContext * context )

static

Definition at line 524 of file OOMaterialConvenienceCreators.m.

{
    if (context->texturesUsed < context->maxTextures)
    {
        BOOL hasParallax = YES;
        NSDictionary *normalMapSpec = [context->inConfig oo_normalAndParallaxMapSpecifier];
        if (normalMapSpec == nil)
        {
            hasParallax = NO;
            normalMapSpec = [context->inConfig oo_normalMapSpecifier];
        }
        
        if (normalMapSpec != nil)
        {
            AddTexture(context, @"uNormalMap", nil, @"OOSTD_NORMAL_MAP", normalMapSpec);
            
            if (hasParallax)
            {
                [context->macros setObject:@"1" forKey:@"OOSTD_NORMAL_AND_PARALLAX_MAP"];
                SetUniformFloat(context, @"uParallaxScale", [context->inConfig oo_parallaxScale]);
                SetUniformFloat(context, @"uParallaxBias", [context->inConfig oo_parallaxBias]);
            }
        }
    }
}

References AddTexture(), OOMaterialSynthContext::inConfig, OOMaterialSynthContext::maxTextures, nil, SetUniformFloat(), and OOMaterialSynthContext::texturesUsed.

Referenced by OOMaterial(OOConvenienceCreators)::synthesizeMaterialDictionaryWithName:configuration:macros:.

Here is the call graph for this function:

Here is the caller graph for this function:

SynthSpecular()

void SynthSpecular ( OOMaterialSynthContext * context )

static

Definition at line 551 of file OOMaterialConvenienceCreators.m.

{
    GLint shininess = [context->inConfig oo_specularExponent];
    if (shininess <= 0)  return;
    
    GLfloat gloss = [context->inConfig oo_gloss];
    if (gloss < 0.0f || gloss > 1.0f)  return;
    
    BOOL gammaCorrect = [context->inConfig oo_gammaCorrect];
    
    NSDictionary *specularMapSpec = nil;
    OOColor *specularColor = nil;
    
    if (context->texturesUsed < context->maxTextures)
    {
        specularMapSpec = [context->inConfig oo_combinedSpecularMapSpecifier];
    }
    
    if (specularMapSpec != nil)  specularColor = [context->inConfig oo_specularModulateColor];
    else  specularColor = [context->inConfig oo_specularColor];
    if ([specularColor isBlack])  return;
    
    SetUniformFloat(context, @"uGloss", gloss);
    
    [context->outConfig setObject:[NSNumber numberWithUnsignedInt:shininess] forKey:kOOMaterialSpecularExponentLegacyName];
    
    if (specularMapSpec != nil)
    {
        AddTexture(context, @"uSpecularMap", kOOMaterialDiffuseMapName, @"OOSTD_SPECULAR_MAP", specularMapSpec);
    }
    
    if (specularColor != nil)
    {
        /*  As with emission colour, specular_modulate_color is transformed to
         specular_color here because the shader reads it from the standard
         material specular colour property set by OOBasicMaterial.
         */
        [context->outConfig setObject:[specularColor normalizedArray] forKey:kOOMaterialSpecularColorName];
    }
    [context->macros setObject:@"1" forKey:@"OOSTD_SPECULAR"];
    
    // setting a bool as a float uniform, to be used in the shader as a bool again
    // this is how hackish I can get... maybe a better way exists, but this is quick
    // and can be used also for the shader materials in a not too different way
    // - Nikos 20181001
    SetUniformFloat(context, @"uGammaCorrect", (float)gammaCorrect);
}

References AddTexture(), kOOMaterialDiffuseMapName, OOMaterialSynthContext::maxTextures, nil, OOColor::normalizedArray, SetUniformFloat(), and OOMaterialSynthContext::texturesUsed.

Referenced by OOMaterial(OOConvenienceCreators)::synthesizeMaterialDictionaryWithName:configuration:macros:.

Here is the call graph for this function:

Here is the caller graph for this function: