OOMaterial(OOConvenienceCreators) Category Reference

#include <OOMaterialConvenienceCreators.h>

Class Methods
(OOMaterial *)	+ materialWithName:cacheKey:configuration:macros:bindingTarget:forSmoothedMesh:
(OOMaterial *)	+ materialWithName:cacheKey:materialDictionary:shadersDictionary:macros:bindingTarget:forSmoothedMesh:
(NSDictionary *)	+ synthesizeMaterialDictionaryWithName:configuration:macros: [implementation]
(OOMaterial *)	+ defaultShaderMaterialWithName:cacheKey:configuration:macros:bindingTarget: [implementation]

Detailed Description

Definition at line 35 of file OOMaterialConvenienceCreators.h.

Method Documentation

defaultShaderMaterialWithName:cacheKey:configuration:macros:bindingTarget:

+ (OOMaterial *) defaultShaderMaterialWithName: (NSString *) name cacheKey: (NSString *) cacheKey configuration: (NSDictionary *) configuration macros: (NSDictionary *) macros bindingTarget: (id<OOWeakReferenceSupport>) target

implementation

Extends class OOMaterial.

Definition at line 62 of file OOMaterialConvenienceCreators.m.

                                             :(NSString *)name
                                     cacheKey:(NSString *)cacheKey
                                configuration:(NSDictionary *)configuration
                                       macros:(NSDictionary *)macros
                                bindingTarget:(id<OOWeakReferenceSupport>)target
{
    OOCacheManager          *cache = nil;
    NSDictionary            *synthesizedConfig = nil;
    OOMaterial              *result = nil;
    
    // Avoid looping (can happen if shader fails to compile).
    if ([configuration objectForKey:@"_oo_is_synthesized_config"] != nil)
    {
        OOLog(@"material.synthesize.loop", @"Synthesis loop for material %@.", name);
        return nil;
    }
    
    if (cacheKey != nil)
    {
        cache = [OOCacheManager sharedCache];
        // configuration must be in cache key, as otherwise changes in
        // non-diffuse map can end up miscached
        cacheKey = [NSString stringWithFormat:@"%@/%@/%@", cacheKey, name, configuration];
        synthesizedConfig = [cache objectForKey:cacheKey inCache:@"synthesized shader materials"];
    }
    
    if (synthesizedConfig == nil)
    {
        synthesizedConfig = [self synthesizeMaterialDictionaryWithName:name
                                                         configuration:configuration
                                                                macros:macros];
        if (synthesizedConfig != nil && cacheKey != nil)
        {
            [cache setObject:synthesizedConfig
                      forKey:cacheKey
                     inCache:@"synthesized shader materials"];
        }
    }
    
    if (synthesizedConfig != nil)
    {
        result =  [self materialWithName:name
                                cacheKey:cacheKey
                           configuration:synthesizedConfig
                                  macros:[synthesizedConfig objectForKey:@"_oo_synthesized_material_macros"]
                           bindingTarget:target
                         forSmoothedMesh:YES];
    }
    
    return result;
}

materialWithName:cacheKey:configuration:macros:bindingTarget:forSmoothedMesh:

+ (OOMaterial *) materialWithName:		(NSString *)	name
cacheKey:		(NSString *)	cacheKey
configuration:		(NSDictionary *)	configuration
macros:		(NSDictionary *)	macros
bindingTarget:		(id<OOWeakReferenceSupport>)	object
forSmoothedMesh:		(BOOL)	smooth

Extends class OOMaterial.

Definition at line 62 of file OOMaterialConvenienceCreators.m.

                                 :(NSString *)name
                         cacheKey:(NSString *)cacheKey
                    configuration:(NSDictionary *)configuration
                           macros:(NSDictionary *)macros
                    bindingTarget:(id<OOWeakReferenceSupport>)object
                  forSmoothedMesh:(BOOL)smooth  // Internally, this flg really means "force use of shaders".
{
    id result = nil;
    
#if OO_SHADERS
 
    if ([UNIVERSE useShaders])
    {
        if ([OOShaderMaterial configurationDictionarySpecifiesShaderMaterial:configuration])
        {
            result = [OOShaderMaterial shaderMaterialWithName:name
                                                configuration:configuration
                                                       macros:macros
                                                bindingTarget:object];
        }
        
        // Use default shader if smoothing is on, or shader detail is full, DEBUG_NO_SHADER_FALLBACK is set, or material uses an effect map.
        if (result == nil &&
                (smooth ||
                 gDebugFlags & DEBUG_NO_SHADER_FALLBACK ||
                 [UNIVERSE detailLevel] >= DETAIL_LEVEL_SHADERS ||
                 [configuration oo_combinedSpecularMapSpecifier] != nil ||
                 [configuration oo_normalMapSpecifier] != nil ||
                 [configuration oo_parallaxMapSpecifier] != nil ||
                 [configuration oo_normalAndParallaxMapSpecifier] != nil ||
                 [configuration oo_emissionMapSpecifier] != nil ||
                 [configuration oo_illuminationMapSpecifier] != nil ||
                 [configuration oo_emissionAndIlluminationMapSpecifier] != nil
                 ))
        {
            result = [self defaultShaderMaterialWithName:name
                                                cacheKey:cacheKey
                                           configuration:configuration
                                                  macros:macros
                                           bindingTarget:(id<OOWeakReferenceSupport>)object];
        }
    }
#endif
    
#if OO_MULTITEXTURE
    if (result == nil /*&& ![UNIVERSE reducedDetail]*/)
    {
        if ([configuration oo_emissionMapSpecifier] != nil ||
            [configuration oo_illuminationMapSpecifier] ||
            [configuration oo_emissionAndIlluminationMapSpecifier] != nil)
        {
            result = [[OOMultiTextureMaterial alloc] initWithName:name configuration:configuration];
            [result autorelease];
        }
    }
#endif
    
    if (result == nil)
    {
        if ([configuration oo_diffuseMapSpecifierWithDefaultName:name] == nil)
        {
            result = [[OOBasicMaterial alloc] initWithName:name configuration:configuration];
        }
        else
        {
            result = [[OOSingleTextureMaterial alloc] initWithName:name configuration:configuration];
        }
        if (result == nil)
        {
            result = [[OOBasicMaterial alloc] initWithName:name configuration:configuration];
        }
        [result autorelease];
    }
    return result;
}

materialWithName:cacheKey:materialDictionary:shadersDictionary:macros:bindingTarget:forSmoothedMesh:

+ (OOMaterial *) materialWithName:		(NSString *)	name
cacheKey:		(NSString *)	cacheKey
materialDictionary:		(NSDictionary *)	materialDict
shadersDictionary:		(NSDictionary *)	shadersDict
macros:		(NSDictionary *)	macros
bindingTarget:		(id<OOWeakReferenceSupport>)	object
forSmoothedMesh:		(BOOL)	smooth

Extends class OOMaterial.

Definition at line 62 of file OOMaterialConvenienceCreators.m.

                                 :(NSString *)name
                         cacheKey:(NSString *)cacheKey
               materialDictionary:(NSDictionary *)materialDict
                shadersDictionary:(NSDictionary *)shadersDict
                           macros:(NSDictionary *)macros
                    bindingTarget:(id<OOWeakReferenceSupport>)object
                  forSmoothedMesh:(BOOL)smooth
{
    NSDictionary            *configuration = nil;
    
#if OO_SHADERS
 
    if ([UNIVERSE useShaders])
    {
        configuration = [shadersDict oo_dictionaryForKey:name];
    }
#endif
    
    if (configuration == nil)
    {
        configuration = [materialDict oo_dictionaryForKey:name];
    }
    
    if (configuration == nil)
    {
        // Use fallback material for non-existent simple texture.
        // Texture caching means this won't be wasted in the general case.
        OOTexture *texture = [OOTexture textureWithName:name inFolder:@"Textures"];
        if (texture == nil)  return nil;
        
        configuration = [NSDictionary dictionary];
    }
    
    return [self materialWithName:name
                         cacheKey:cacheKey
                    configuration:configuration
                           macros:macros
                    bindingTarget:object
                  forSmoothedMesh:smooth];
}

synthesizeMaterialDictionaryWithName:configuration:macros:

+ (NSDictionary *) synthesizeMaterialDictionaryWithName: (NSString *) name configuration: (NSDictionary *) configuration macros: (NSDictionary *) macros

implementation

Extends class OOMaterial.

Definition at line 62 of file OOMaterialConvenienceCreators.m.

                                                      :(NSString *)name
                                         configuration:(NSDictionary *)configuration
                                                macros:(NSDictionary *)macros
{
    if (configuration == nil)  configuration = [NSDictionary dictionary];
    OOMaterialSynthContext context =
    {
        .inConfig = configuration,
        .outConfig = [NSMutableDictionary dictionary],
        .maxTextures = [[OOOpenGLExtensionManager sharedManager] textureImageUnitCount],
        
        .macros = [NSMutableDictionary dictionaryWithDictionary:macros],
        .textures = [NSMutableArray array],
        .uniforms = [NSMutableDictionary dictionary]
    };
    
    if ([UNIVERSE reducedDetail])
    {
        context.maxTextures = 3;
    }
    
    //  Basic stuff.
    
    /*  Set up the various material attributes.
        Order is significant here, because it determines the order in which
        features will be dropped if we exceed the hardware's texture image
        unit limit.
    */
    SynthDiffuse(&context, name);
    SynthEmissionAndIllumination(&context);
    SynthNormalMap(&context);
    SynthSpecular(&context);
    
    if ([UNIVERSE detailLevel] >= DETAIL_LEVEL_SHADERS)
    {
        //  Add uniforms required for hull heat glow.
        [context.uniforms setObject:@"hullHeatLevel" forKey:@"uHullHeatLevel"];
        [context.uniforms setObject:@"timeElapsedSinceSpawn" forKey:@"uTime"];
        [context.uniforms setObject:@"fogUniform" forKey:@"uFogColor"];
    }
    
    //  Stuff in the general properties.
    [context.outConfig setObject:@"true" forKey:@"_oo_is_synthesized_config"];
    [context.outConfig setObject:@"oolite-tangent-space-vertex.vertex" forKey:@"vertex_shader"];
    [context.outConfig setObject:@"oolite-default-shader.fragment" forKey:@"fragment_shader"];
    
    if ([context.textures count] != 0)  [context.outConfig setObject:context.textures forKey:@"textures"];
    if ([context.uniforms count] != 0)  [context.outConfig setObject:context.uniforms forKey:@"uniforms"];
    if ([context.macros count] != 0)  [context.outConfig setObject:context.macros forKey:@"_oo_synthesized_material_macros"];
    
    return context.outConfig;
}

---

The documentation for this category was generated from the following files:

• src/Core/Materials/OOMaterialConvenienceCreators.h
• src/Core/Materials/OOMaterialConvenienceCreators.m