Random buildings - initial commit.

[simgear.git] / simgear / scene / material / makeEffect.cxx

diff --git a/simgear/scene/material/makeEffect.cxx b/simgear/scene/material/makeEffect.cxx
index 59d3b2d9b4c5e3e2f5c2943cc5953c821383287c..06bf47b229b1d8d118816f85a3c60a2f63e41e53 100644 (file)
--- a/simgear/scene/material/makeEffect.cxx
+++ b/simgear/scene/material/makeEffect.cxx
@@ -4,6 +4,7 @@
 #endif
 
 #include "Effect.hxx"
+#include "EffectBuilder.hxx"
 #include "Technique.hxx"
 #include "Pass.hxx"
 
@@ -30,6 +31,7 @@
 #include <osgDB/Registry>
 
 #include <simgear/debug/logstream.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
 #include <simgear/props/props_io.hxx>
 #include <simgear/scene/util/SGSceneFeatures.hxx>
 #include <simgear/scene/util/SplicingVisitor.hxx>
@@ -115,32 +117,51 @@ void mergePropertyTrees(SGPropertyNode* resultNode,
 
 Effect* makeEffect(const string& name,
                    bool realizeTechniques,
-                   const osgDB::ReaderWriter::Options* options)
+                   const SGReaderWriterOptions* options)
 {
-    OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(effectMutex);
-    EffectMap::iterator itr = effectMap.find(name);
-    if (itr != effectMap.end())
-        return itr->second.get();
+    {
+        OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(effectMutex);
+        EffectMap::iterator itr = effectMap.find(name);
+        if ((itr != effectMap.end())&&
+            itr->second.valid())
+            return itr->second.get();
+    }
     string effectFileName(name);
     effectFileName += ".eff";
     string absFileName
-        = osgDB::findDataFile(effectFileName, options);
+        = SGModelLib::findDataFile(effectFileName, options);
     if (absFileName.empty()) {
-        SG_LOG(SG_INPUT, SG_WARN, "can't find \"" << effectFileName << "\"");
+        SG_LOG(SG_INPUT, SG_ALERT, "can't find \"" << effectFileName << "\"");
         return 0;
     }
     SGPropertyNode_ptr effectProps = new SGPropertyNode();
-    readProperties(absFileName, effectProps.ptr(), 0, true);
-    Effect* result = makeEffect(effectProps.ptr(), realizeTechniques, options);
-    if (result)
-        effectMap.insert(make_pair(name, result));
-    return result;
+    try {
+        readProperties(absFileName, effectProps.ptr(), 0, true);
+    }
+    catch (sg_io_exception& e) {
+        SG_LOG(SG_INPUT, SG_ALERT, "error reading \"" << absFileName << "\": "
+               << e.getFormattedMessage());
+        return 0;
+    }
+    ref_ptr<Effect> result = makeEffect(effectProps.ptr(), realizeTechniques,
+                                        options);
+    if (result.valid()) {
+        OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(effectMutex);
+        pair<EffectMap::iterator, bool> irslt
+            = effectMap.insert(make_pair(name, result));
+        if (!irslt.second) {
+            // Another thread beat us to it!. Discard our newly
+            // constructed Effect and use the one in the cache.
+            result = irslt.first->second;
+        }
+    }
+    return result.release();
 }
 
 
 Effect* makeEffect(SGPropertyNode* prop,
                    bool realizeTechniques,
-                   const osgDB::ReaderWriter::Options* options)
+                   const SGReaderWriterOptions* options)
 {
     // Give default names to techniques and passes
     vector<SGPropertyNode_ptr> techniques = prop->getChildren("technique");
@@ -165,29 +186,88 @@ Effect* makeEffect(SGPropertyNode* prop,
             }
         }
     }
-    Effect* effect = new Effect;
+    ref_ptr<Effect> effect;
     // Merge with the parent effect, if any
-    const SGPropertyNode* inheritProp = prop->getChild("inherits-from");
+    SGPropertyNode_ptr inheritProp = prop->getChild("inherits-from");
     Effect* parent = 0;
     if (inheritProp) {
-        parent = makeEffect(inheritProp->getStringValue(), false,
-                            options);
-        if(parent)
-        {
-            effect->root = new SGPropertyNode;
-            mergePropertyTrees(effect->root, prop, parent->root);
-            effect->root->removeChild("inherits-from");
+        //prop->removeChild("inherits-from");
+        parent = makeEffect(inheritProp->getStringValue(), false, options);
+        if (parent) {
+            Effect::Key key;
+            key.unmerged = prop;
+            if (options) {
+                key.paths = options->getDatabasePathList();
+            }
+            Effect::Cache* cache = 0;
+            Effect::Cache::iterator itr;
+            {
+                OpenThreads::ScopedLock<OpenThreads::ReentrantMutex>
+                    lock(effectMutex);
+                cache = parent->getCache();
+                itr = cache->find(key);
+                if ((itr != cache->end())&&
+                    itr->second.lock(effect))
+                {
+                    effect->generator = parent->generator;  // Copy the generators
+                }
+            }
+            if (!effect.valid()) {
+                effect = new Effect;
+                effect->root = new SGPropertyNode;
+                mergePropertyTrees(effect->root, prop, parent->root);
+                effect->parametersProp = effect->root->getChild("parameters");
+                OpenThreads::ScopedLock<OpenThreads::ReentrantMutex>
+                    lock(effectMutex);
+                pair<Effect::Cache::iterator, bool> irslt
+                    = cache->insert(make_pair(key, effect));
+                if (!irslt.second) {
+                    ref_ptr<Effect> old;
+                    if (irslt.first->second.lock(old))
+                        effect = old; // Another thread beat us in creating it! Discard our own...
+                    else
+                        irslt.first->second = effect; // update existing, but empty observer
+                }
+                effect->generator = parent->generator;  // Copy the generators
+            }
         } else {
-            effect->root = prop;
-            effect->root->removeChild("inherits-from");
+            SG_LOG(SG_INPUT, SG_ALERT, "can't find base effect " <<
+                   inheritProp->getStringValue());
+            return 0;
         }
     } else {
+        effect = new Effect;
         effect->root = prop;
+        effect->parametersProp = effect->root->getChild("parameters");
+    }
+    const SGPropertyNode *generateProp = prop->getChild("generate");
+    if(generateProp)
+    {
+        effect->generator.clear();
+
+        // Effect needs some generated properties, like tangent vectors
+        const SGPropertyNode *parameter = generateProp->getChild("normal");
+        if(parameter) effect->setGenerator(Effect::NORMAL, parameter->getIntValue());
+
+        parameter = generateProp->getChild("tangent");
+        if(parameter) effect->setGenerator(Effect::TANGENT, parameter->getIntValue());
+
+        parameter = generateProp->getChild("binormal");
+        if(parameter) effect->setGenerator(Effect::BINORMAL, parameter->getIntValue());
+    }
+    if (realizeTechniques) {
+        try {
+            OpenThreads::ScopedLock<OpenThreads::ReentrantMutex>
+                lock(effectMutex);
+            effect->realizeTechniques(options);
+        }
+        catch (BuilderException& e) {
+            SG_LOG(SG_INPUT, SG_ALERT, "Error building technique: "
+                   << e.getFormattedMessage());
+            return 0;
+        }
     }
-    effect->parametersProp = effect->root->getChild("parameters");
-    if (realizeTechniques)
-        effect->realizeTechniques(options);
-    return effect;
+    return effect.release();
 }
 
 }