#include <osg/Material>
#include <osg/Math>
#include <osg/PolygonMode>
+#include <osg/PolygonOffset>
#include <osg/Program>
#include <osg/Referenced>
#include <osg/RenderInfo>
#include <osgDB/ReadFile>
#include <osgDB/Registry>
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/tgdb/userdata.hxx>
+#include <simgear/scene/util/OsgMath.hxx>
#include <simgear/scene/util/SGSceneFeatures.hxx>
#include <simgear/scene/util/StateAttributeFactory.hxx>
#include <simgear/structure/OSGUtils.hxx>
#include <simgear/structure/SGExpression.hxx>
-
+#include <simgear/props/vectorPropTemplates.hxx>
namespace simgear
}
Effect::Effect(const Effect& rhs, const CopyOp& copyop)
- : root(rhs.root), parametersProp(rhs.parametersProp), _cache(0),
+ : osg::Object(rhs,copyop), root(rhs.root), parametersProp(rhs.parametersProp), _cache(0),
_isRealized(rhs._isRealized)
{
typedef vector<ref_ptr<Technique> > TechniqueList;
}
void buildPass(Effect* effect, Technique* tniq, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
Pass* pass = new Pass;
tniq->passes.push_back(pass);
struct LightingBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
void LightingBuilder::buildAttribute(Effect* effect, Pass* pass,
const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp)
struct ShadeModelBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp)
struct CullFaceBuilder : PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp) {
struct ColorMaskBuilder : PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp)
struct HintBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp)
struct RenderBinBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
struct MaterialBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
EffectNameValue<Material::ColorMode> colorModeInit[] =
void MaterialBuilder::buildAttribute(Effect* effect, Pass* pass,
const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
struct BlendBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
struct StencilBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
struct AlphaTestBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
InstallAttributeBuilder<TextureUnitBuilder> textureUnitBuilder("texture-unit");
// Shader key, used both for shaders with relative and absolute names
-typedef pair<string, Shader::Type> ShaderKey;
+typedef pair<string, int> ShaderKey;
-inline ShaderKey makeShaderKey(SGPropertyNode_ptr& ptr, Shader::Type shaderType)
+inline ShaderKey makeShaderKey(SGPropertyNode_ptr& ptr, int shaderType)
{
return ShaderKey(ptr->getStringValue(), shaderType);
}
struct ShaderProgramBuilder : PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
void ShaderProgramBuilder::buildAttribute(Effect* effect, Pass* pass,
const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions*
+ const SGReaderWriterOptions*
options)
{
using namespace boost;
BOOST_FOREACH(const ShaderKey& shaderKey, prgKey.shaders)
{
const string& shaderName = shaderKey.first;
- Shader::Type stype = shaderKey.second;
+ Shader::Type stype = (Shader::Type)shaderKey.second;
string fileName = SGModelLib::findDataFile(shaderName, options);
if (fileName.empty())
throw BuilderException(string("couldn't find shader ") +
BOOST_FOREACH(const ShaderKey& skey, resolvedKey.shaders)
{
const string& fileName = skey.first;
- Shader::Type stype = skey.second;
+ Shader::Type stype = (Shader::Type)skey.second;
ShaderMap::iterator sitr = shaderMap.find(skey);
if (sitr != shaderMap.end()) {
program->addShader(sitr->second.get());
} else {
ref_ptr<Shader> shader = new Shader(stype);
+ shader->setName(fileName);
if (shader->loadShaderSourceFromFile(fileName)) {
program->addShader(shader.get());
shaderMap.insert(ShaderMap::value_type(skey, shader));
struct UniformBuilder :public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!texture0.valid()) {
texture0 = new Uniform(Uniform::SAMPLER_2D, "texture");
return;
const SGPropertyNode* nameProp = prop->getChild("name");
const SGPropertyNode* typeProp = prop->getChild("type");
+ const SGPropertyNode* positionedProp = prop->getChild("positioned");
const SGPropertyNode* valProp = prop->getChild("value");
string name;
Uniform::Type uniformType = Uniform::FLOAT;
uniform->setName(name);
uniform->setType(uniformType);
switch (uniformType) {
+ case Uniform::BOOL:
+ initFromParameters(effect, valProp, uniform.get(),
+ static_cast<bool (Uniform::*)(bool)>(&Uniform::set),
+ options);
+ break;
case Uniform::FLOAT:
initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(float)>(&Uniform::set),
// optimize common uniforms
if (uniformType == Uniform::SAMPLER_2D || uniformType == Uniform::INT)
{
- int val;
- uniform->get(val);
+ int val = 0;
+ uniform->get(val); // 'val' remains unchanged in case of error (Uniform is a non-scalar)
if (uniformType == Uniform::SAMPLER_2D && val == 0
&& name == "texture") {
uniform = texture0;
}
}
pass->addUniform(uniform.get());
+ if (positionedProp && positionedProp->getBoolValue() && uniformType == Uniform::FLOAT_VEC4) {
+ osg::Vec4 offset;
+ uniform->get(offset);
+ pass->addPositionedUniform( name, offset );
+ }
}
};
struct NameBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
// name can't use <use>
string name = prop->getStringValue();
struct PolygonModeBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
InstallAttributeBuilder<PolygonModeBuilder> installPolygonMode("polygon-mode");
+struct PolygonOffsetBuilder : public PassAttributeBuilder
+{
+ void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
+ const SGReaderWriterOptions* options)
+ {
+ if (!isAttributeActive(effect, prop))
+ return;
+
+ const SGPropertyNode* factor
+ = getEffectPropertyChild(effect, prop, "factor");
+ const SGPropertyNode* units
+ = getEffectPropertyChild(effect, prop, "units");
+
+ ref_ptr<PolygonOffset> polyoffset = new PolygonOffset;
+
+ polyoffset->setFactor(factor->getFloatValue());
+ polyoffset->setUnits(units->getFloatValue());
+
+ SG_LOG(SG_INPUT, SG_BULK,
+ "Set PolygonOffset to " << polyoffset->getFactor() << polyoffset->getUnits() );
+
+ pass->setAttributeAndModes(polyoffset.get(),
+ StateAttribute::OVERRIDE|StateAttribute::ON);
+ }
+};
+
+InstallAttributeBuilder<PolygonOffsetBuilder> installPolygonOffset("polygon-offset");
+
struct VertexProgramTwoSideBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp)
struct VertexProgramPointSizeBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* realProp = getEffectPropertyNode(effect, prop);
if (!realProp)
struct DepthBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
const SGPropertyNode* pfar
= getEffectPropertyChild(effect, prop, "far");
if (pfar)
- depth->setZFar(pnear->getValue<double>());
+ depth->setZFar(pfar->getValue<double>());
const SGPropertyNode* pmask
= getEffectPropertyChild(effect, prop, "write-mask");
if (pmask)
depth->setWriteMask(pmask->getValue<bool>());
- pass->setAttribute(depth.get());
+ const SGPropertyNode* penabled
+ = getEffectPropertyChild(effect, prop, "enabled");
+ bool enabled = ( penabled == 0 || penabled->getBoolValue() );
+ pass->setAttributeAndModes(depth.get(), enabled ? osg::StateAttribute::ON : osg::StateAttribute::OFF);
}
};
InstallAttributeBuilder<DepthBuilder> installDepth("depth");
void buildTechnique(Effect* effect, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
Technique* tniq = new Technique;
effect->techniques.push_back(tniq);
// Walk the techniques property tree, building techniques and
// passes.
-bool Effect::realizeTechniques(const SGReaderWriterXMLOptions* options)
+bool Effect::realizeTechniques(const SGReaderWriterOptions* options)
{
if (_isRealized)
return true;
void valueChanged(SGPropertyNode* node)
{
- _tniq->refreshValidity();
+ if (_tniq.valid())
+ _tniq->refreshValidity();
}
protected:
- osg::ref_ptr<Technique> _tniq;
+ osg::observer_ptr<Technique> _tniq;
};
template<typename T>