Method overlayObject

OgreMain/src/OgreScriptCompiler.cpp:652–839

    }

    void ScriptCompiler::overlayObject( const AbstractNodePtr &source, ObjectAbstractNode *dest )
    {
        if( source->type == ANT_OBJECT )
        {
            ObjectAbstractNode *src = static_cast<ObjectAbstractNode *>( source.get() );

            // Overlay the environment of one on top the other first
            for( map<String, String>::type::const_iterator i = src->getVariables().begin();
                 i != src->getVariables().end(); ++i )
            {
                std::pair<bool, String> var = dest->getVariable( i->first );
                if( !var.first )
                    dest->setVariable( i->first, i->second );
            }

            // Create a vector storing each pairing of override between source and destination
            vector<std::pair<AbstractNodePtr, AbstractNodeList::iterator> >::type overrides;
            // A list of indices for each destination node tracks the minimum
            // source node they can index-match against
            map<ObjectAbstractNode *, size_t>::type indices;
            // A map storing which nodes have overridden from the destination node
            map<ObjectAbstractNode *, bool>::type overridden;

            // Fill the vector with objects from the source node (base)
            // And insert non-objects into the overrides list of the destination
            AbstractNodeList::iterator insertPos = dest->children.begin();
            for( AbstractNodeList::const_iterator i = src->children.begin(); i != src->children.end();
                 ++i )
            {
                if( ( *i )->type == ANT_OBJECT )
                {
                    overrides.push_back( std::make_pair( *i, dest->children.end() ) );
                }
                else
                {
                    AbstractNodePtr newNode( ( *i )->clone() );
                    newNode->parent = dest;
                    dest->overrides.push_back( newNode );
                }
            }

            // Track the running maximum override index in the name-matching phase
            size_t maxOverrideIndex = 0;

            // Loop through destination children searching for name-matching overrides
            for( AbstractNodeList::iterator i = dest->children.begin(); i != dest->children.end(); )
            {
                if( ( *i )->type == ANT_OBJECT )
                {
                    // Start tracking the override index position for this object
                    size_t overrideIndex = 0;

                    ObjectAbstractNode *node = static_cast<ObjectAbstractNode *>( ( *i ).get() );
                    indices[node] = maxOverrideIndex;
                    overridden[node] = false;

                    // special treatment for materials with * in their name
                    bool nodeHasWildcard = node->name.find( '*' ) != String::npos;