+
+#ifdef HAVE_CONFIG_H
+# include <simgear_config.h>
+#endif
+
#include "Technique.hxx"
#include "Pass.hxx"
#include <boost/bind.hpp>
#include <boost/foreach.hpp>
+#include <iterator>
#include <vector>
#include <string>
#include <osgDB/Input>
#include <osgDB/ParameterOutput>
+#include <simgear/props/props.hxx>
#include <simgear/structure/OSGUtils.hxx>
namespace simgear
using namespace std;
using namespace boost;
transform(rhs.passes.begin(), rhs.passes.end(),
- backRefInsertIterator(passes),
+ back_inserter(passes),
bind(simgear::clone_ref<Pass>, _1, copyop));
}
pass->releaseGLObjects(state);
}
if (state == 0) {
- for (int i = 0; i < _contextMap.size(); ++i) {
+ for (int i = 0; i < (int)_contextMap.size(); ++i) {
ContextInfo& info = _contextMap[i];
Status oldVal = info.valid();
info.valid.compareAndSwap(oldVal, UNKNOWN);
public:
void eval(float& value, const expression::Binding*) const
{
+#ifdef TECHNIQUE_TEST_EXTENSIONS
+ value = 1.1;
+#else
value = getGLVersionNumber();
+#endif
}
};
+Expression* glVersionParser(const SGPropertyNode* exp,
+ expression::Parser* parser)
+{
+ return new GLVersionExpression();
+}
+
+expression::ExpParserRegistrar glVersionRegistrar("glversion", glVersionParser);
+
class ExtensionSupportedExpression
: public GeneralNaryExpression<bool, int>
{
string _extString;
};
+Expression* extensionSupportedParser(const SGPropertyNode* exp,
+ expression::Parser* parser)
+{
+ if (exp->getType() == props::STRING
+ || exp->getType() == props::UNSPECIFIED) {
+ ExtensionSupportedExpression* esp
+ = new ExtensionSupportedExpression(exp->getStringValue());
+ int location = parser->getBindingLayout().addBinding("__contextId",
+ expression::INT);
+ VariableExpression<int>* contextExp
+ = new VariableExpression<int>(location);
+ esp->addOperand(contextExp);
+ return esp;
+ }
+ throw expression::ParseError("extension-supported expression has wrong type");
+}
+
+expression::ExpParserRegistrar
+extensionSupportedRegistrar("extension-supported", extensionSupportedParser);
+
void Technique::setGLExtensionsPred(float glVersion,
const std::vector<std::string>& extensions)
{
int contextLoc = layout.addBinding("__contextId", INT);
VariableExpression<int>* contextExp
= new VariableExpression<int>(contextLoc);
- LessEqualExpression<float>* versionTest
- = new LessEqualExpression<float>(new SGConstExpression<float>(glVersion),
- new GLVersionExpression);
+ SGExpression<bool>* versionTest
+ = makePredicate<std::less_equal>(new SGConstExpression<float>(glVersion),
+ new GLVersionExpression);
AndExpression* extensionsExp = 0;
for (vector<string>::const_iterator itr = extensions.begin(),
e = extensions.end();
setValidExpression(predicate, layout);
}
+void Technique::refreshValidity()
+{
+ for (int i = 0; i < (int)_contextMap.size(); ++i) {
+ ContextInfo& info = _contextMap[i];
+ Status oldVal = info.valid();
+ // What happens if we lose the race here?
+ info.valid.compareAndSwap(oldVal, UNKNOWN);
+ }
+}
+
bool Technique_writeLocalData(const Object& obj, osgDB::Output& fw)
{
const Technique& tniq = static_cast<const Technique&>(obj);
fw.indent() << "shadowingStateSet\n";
fw.writeObject(*tniq.getShadowingStateSet());
}
- fw.indent() << "passes\n";
+ fw.indent() << "num_passes " << tniq.passes.size() << "\n";
BOOST_FOREACH(const ref_ptr<Pass>& pass, tniq.passes) {
fw.writeObject(*pass);
}