RelativePath="..\..\simgear\scene\model\SGReaderWriterXML.hxx"\r
>\r
</File>\r
- <File\r
- RelativePath="..\..\simgear\scene\model\SGReaderWriterXMLOptions.hxx"\r
- >\r
- </File>\r
<File\r
RelativePath="..\..\simgear\scene\model\SGRotateTransform.cxx"\r
>\r
RelativePath="..\..\simgear\scene\tgdb\SGReaderWriterBTG.hxx"\r
>\r
</File>\r
- <File\r
- RelativePath="..\..\simgear\scene\tgdb\SGReaderWriterBTGOptions.hxx"\r
- >\r
- </File>\r
<File\r
RelativePath="..\..\simgear\scene\tgdb\SGVasiDrawable.cxx"\r
>\r
#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/SGSceneFeatures.hxx>
#include <simgear/scene/util/StateAttributeFactory.hxx>
}
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;
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;
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");
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;
struct PolygonOffsetBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
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;
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;
{
class Technique;
class Effect;
-class SGReaderWriterXMLOptions;
+class SGReaderWriterOptions;
/**
* Object to be initialized at some point after an effect -- and its
/**
* Build the techniques from the effect properties.
*/
- bool realizeTechniques(const SGReaderWriterXMLOptions* options = 0);
+ bool realizeTechniques(const SGReaderWriterOptions* options = 0);
/**
* Updaters that should be derefed when the effect is
* deleted. Updaters arrange to be run by listening on properties
Cache* _cache;
friend size_t hash_value(const Key& key);
friend Effect* makeEffect(SGPropertyNode* prop, bool realizeTechniques,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
bool _isRealized;
};
// Automatic support for boost hash function
Effect* makeEffect(const std::string& name,
bool realizeTechniques,
- const SGReaderWriterXMLOptions* options = 0);
+ const SGReaderWriterOptions* options = 0);
Effect* makeEffect(SGPropertyNode* prop,
bool realizeTechniques,
- const SGReaderWriterXMLOptions* options = 0);
+ const SGReaderWriterOptions* options = 0);
bool makeParametersFromStateSet(SGPropertyNode* paramRoot,
const osg::StateSet* ss);
# include <simgear_config.h>
#endif
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/tgdb/userdata.hxx>
#include <simgear/math/SGMath.hxx>
}
string getGlobalProperty(const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!prop)
return string();
SGPropertyNode_ptr propRoot;
if (propName[0] == '/') {
return propName;
- } else if ((propRoot = options->getPropRoot())) {
+ } else if ((propRoot = options->getPropertyNode())) {
string result = propRoot->getPath();
result.append("/");
result.append(propName);
#include <simgear/math/SGMath.hxx>
#include <simgear/props/AtomicChangeListener.hxx>
#include <simgear/props/props.hxx>
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/structure/exception.hxx>
#include <simgear/structure/SGSharedPtr.hxx>
#include <simgear/structure/Singleton.hxx>
{
class Effect;
class Pass;
-class SGReaderWriterXMLOptions;
+class SGReaderWriterOptions;
/**
* Builder that returns an object, probably an OSG object.
public:
virtual ~EffectBuilder() {}
virtual T* build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options) = 0;
+ const SGReaderWriterOptions* options) = 0;
static T* buildFromType(Effect* effect, const std::string& type,
const SGPropertyNode*props,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
BuilderMap& builderMap = getMap();
typename BuilderMap::iterator iter = builderMap.find(type);
* mentioned node name.
*/
std::string getGlobalProperty(const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions *);
+ const SGReaderWriterOptions *);
template<typename NameItr>
std::vector<std::string>
getVectorProperties(const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions *options, size_t vecSize,
+ const SGReaderWriterOptions *options, size_t vecSize,
NameItr defaultNames)
{
using namespace std;
if (useProps.size() == 1) {
string parentName = useProps[0]->getStringValue();
if (parentName.size() == 0 || parentName[0] != '/')
- parentName = options->getPropRoot()->getPath() + "/" + parentName;
+ parentName = options->getPropertyNode()->getPath() + "/" + parentName;
if (parentName[parentName.size() - 1] != '/')
parentName.append("/");
NameItr itr = defaultNames;
virtual void buildAttribute(Effect* effect, Pass* pass,
const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
= 0;
static PassAttributeBuilder* find(const std::string& str)
{
template<typename OSGParamType, typename ObjType, typename F>
void
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
- const F& setter, const SGReaderWriterXMLOptions* options)
+ const F& setter, const SGReaderWriterOptions* options)
{
const SGPropertyNode* valProp = getEffectPropertyNode(effect, prop);
if (!valProp)
inline void
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
SetterReturn (ObjType::*setter)(const OSGParamType),
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
initFromParameters<OSGParamType>(effect, prop, obj,
boost::bind(setter, _1, _2), options);
void
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
const F& setter,
- NameItrType nameItr, const SGReaderWriterXMLOptions* options)
+ NameItrType nameItr, const SGReaderWriterOptions* options)
{
typedef typename Bridge<OSGParamType>::sg_type sg_type;
const int numComponents = props::NumComponents<sg_type>::num_components;
inline void
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
SetterReturn (ObjType::*setter)(const OSGParamType&),
- NameItrType nameItr, const SGReaderWriterXMLOptions* options)
+ NameItrType nameItr, const SGReaderWriterOptions* options)
{
initFromParameters<OSGParamType>(effect, prop, obj,
boost::bind(setter, _1, _2), nameItr,
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/util/SGSceneFeatures.hxx>
#include <simgear/scene/util/StateAttributeFactory.hxx>
#include <simgear/math/SGMath.hxx>
TexEnvCombine* buildTexEnvCombine(Effect* effect,
const SGPropertyNode* envProp,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
TexGen* buildTexGen(Effect* Effect, const SGPropertyNode* tgenProp);
// Hack to force inclusion of TextureBuilder.cxx in library
osg::Texture* TextureBuilder::buildFromType(Effect* effect, const string& type,
const SGPropertyNode*props,
- const SGReaderWriterXMLOptions*
+ const SGReaderWriterOptions*
options)
{
return EffectBuilder<Texture>::buildFromType(effect, type, props, options);
void TextureUnitBuilder::buildAttribute(Effect* effect, Pass* pass,
const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, prop))
return;
EffectPropertyMap<Texture::WrapMode> wrapModes(wrapModesInit);
TexTuple makeTexTuple(Effect* effect, const SGPropertyNode* props,
- const SGReaderWriterXMLOptions* options,
+ const SGReaderWriterOptions* options,
const string& texType)
{
Texture::FilterMode minFilter = Texture::LINEAR_MIPMAP_LINEAR;
}
void setAttrs(const TexTuple& attrs, Texture* tex,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const string& imageName = attrs.get<0>();
if (imageName.empty()) {
public:
TexBuilder(const string& texType) : _type(texType) {}
Texture* build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
protected:
typedef map<TexTuple, ref_ptr<T> > TexMap;
TexMap texMap;
template<typename T>
Texture* TexBuilder<T>::build(Effect* effect, const SGPropertyNode* props,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
TexTuple attrs = makeTexTuple(effect, props, options, _type);
typename TexMap::iterator itr = texMap.find(attrs);
{
public:
Texture* build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
Texture* WhiteTextureBuilder::build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
return StateAttributeFactory::instance()->getWhiteTexture();
}
{
public:
Texture* build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
Texture* TransparentTextureBuilder::build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
return StateAttributeFactory::instance()->getTransparentTexture();
}
{
public:
Texture* build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
protected:
typedef map<int, ref_ptr<Texture3D> > NoiseMap;
NoiseMap _noises;
};
Texture* NoiseBuilder::build(Effect* effect, const SGPropertyNode* props,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
int texSize = 64;
const SGPropertyNode* sizeProp = getEffectPropertyChild(effect, props,
{
public:
Texture* build(Effect* effect, const SGPropertyNode*,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
protected:
typedef map<CubeMapTuple, ref_ptr<TextureCubeMap> > CubeMap;
typedef map<string, ref_ptr<TextureCubeMap> > CrossCubeMap;
Texture* CubeMapBuilder::build(Effect* effect, const SGPropertyNode* props,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
// First check that there is a <images> tag
const SGPropertyNode* texturesProp = getEffectPropertyChild(effect, props, "images");
EffectPropertyMap<TexEnvCombine::OperandParam> operandParams(opParamInit);
TexEnvCombine* buildTexEnvCombine(Effect* effect, const SGPropertyNode* envProp,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
if (!isAttributeActive(effect, envProp))
return 0;
// Hack to force inclusion of TextureBuilder.cxx in library
static osg::Texture* buildFromType(Effect* effect, const std::string& type,
const SGPropertyNode*props,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
struct TextureUnitBuilder : public PassAttributeBuilder
{
void buildAttribute(Effect* effect, Pass* pass, const SGPropertyNode* prop,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
};
#include <osgDB/Registry>
#include <simgear/debug/logstream.hxx>
-#include <simgear/scene/model/SGReaderWriterXMLOptions.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>
Effect* makeEffect(const string& name,
bool realizeTechniques,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
{
OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(effectMutex);
Effect* makeEffect(SGPropertyNode* prop,
bool realizeTechniques,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
// Give default names to techniques and passes
vector<SGPropertyNode_ptr> techniques = prop->getChildren("technique");
#include <simgear/debug/logstream.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/misc/sgstream.hxx>
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/props/props_io.hxx>
#include <simgear/scene/model/model.hxx>
#include <simgear/scene/util/RenderConstants.hxx>
////////////////////////////////////////////////////////////////////////
SGMaterial::_internal_state::_internal_state(Effect *e, bool l,
- const SGReaderWriterXMLOptions* o)
+ const SGReaderWriterOptions* o)
: effect(e), effect_realized(l), options(o)
{
}
SGMaterial::_internal_state::_internal_state(Effect *e, const string &t, bool l,
- const SGReaderWriterXMLOptions* o)
+ const SGReaderWriterOptions* o)
: effect(e), effect_realized(l), options(o)
{
texture_paths.push_back(std::make_pair(t,0));
texture_paths.push_back(std::make_pair(t,i));
}
-SGMaterial::SGMaterial( const SGReaderWriterXMLOptions* options,
+SGMaterial::SGMaterial( const SGReaderWriterOptions* options,
const SGPropertyNode *props )
{
init();
SGMaterial::SGMaterial( const osgDB::ReaderWriter::Options* options,
const SGPropertyNode *props )
{
- osg::ref_ptr<const SGReaderWriterXMLOptions> sgOptions;
+ osg::ref_ptr<const SGReaderWriterOptions> sgOptions;
if (options)
- sgOptions = new SGReaderWriterXMLOptions(*options);
+ sgOptions = new SGReaderWriterOptions(*options);
init();
read_properties( sgOptions.get(), props );
buildEffectProperties(sgOptions.get());
////////////////////////////////////////////////////////////////////////
void
-SGMaterial::read_properties(const SGReaderWriterXMLOptions* options,
+SGMaterial::read_properties(const SGReaderWriterOptions* options,
const SGPropertyNode *props)
{
// Gather the path(s) to the texture(s)
return _status[i].effect.get();
}
-void SGMaterial::buildEffectProperties(const SGReaderWriterXMLOptions* options)
+void SGMaterial::buildEffectProperties(const SGReaderWriterOptions* options)
{
using namespace osg;
- ref_ptr<SGReaderWriterXMLOptions> xmlOptions;
+ ref_ptr<SGReaderWriterOptions> xmlOptions;
if (options)
- xmlOptions = new SGReaderWriterXMLOptions(*options);
+ xmlOptions = new SGReaderWriterOptions(*options);
ref_ptr<SGMaterialUserData> user = new SGMaterialUserData(this);
SGPropertyNode_ptr propRoot = new SGPropertyNode();
makeChild(propRoot, "inherits-from")->setStringValue(effect);
class StateSet;
}
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/props/props.hxx>
#include <simgear/structure/SGSharedPtr.hxx>
#include <simgear/scene/util/SGSceneFeatures.hxx>
*/
SGMaterial( const osgDB::ReaderWriter::Options*, const SGPropertyNode *props);
- SGMaterial(const simgear::SGReaderWriterXMLOptions*,
+ SGMaterial(const simgear::SGReaderWriterOptions*,
const SGPropertyNode *props);
/**
* Destructor.
struct _internal_state {
_internal_state(simgear::Effect *e, bool l,
- const simgear::SGReaderWriterXMLOptions *o);
+ const simgear::SGReaderWriterOptions *o);
_internal_state(simgear::Effect *e, const std::string &t, bool l,
- const simgear::SGReaderWriterXMLOptions *o);
+ const simgear::SGReaderWriterOptions *o);
void add_texture(const std::string &t, int i);
osg::ref_ptr<simgear::Effect> effect;
std::vector<std::pair<std::string,int> > texture_paths;
bool effect_realized;
- osg::ref_ptr<const simgear::SGReaderWriterXMLOptions> options;
+ osg::ref_ptr<const simgear::SGReaderWriterOptions> options;
};
private:
// Internal constructors and methods.
////////////////////////////////////////////////////////////////////
- void read_properties(const simgear::SGReaderWriterXMLOptions* options,
+ void read_properties(const simgear::SGReaderWriterOptions* options,
const SGPropertyNode *props);
- void buildEffectProperties(const simgear::SGReaderWriterXMLOptions* options);
+ void buildEffectProperties(const simgear::SGReaderWriterOptions* options);
};
EffectPropertyMap<MipMapFunction> mipmapFunctions(mipmapFunctionsInit);
MipMapTuple makeMipMapTuple(Effect* effect, const SGPropertyNode* props,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
const SGPropertyNode* pMipmapR
= getEffectPropertyChild(effect, props, "function-r");
namespace simgear
{
class Effect;
-class SGReaderWriterXMLOptions;
+class SGReaderWriterOptions;
namespace effect {
enum MipMapFunction {
typedef boost::tuple<MipMapFunction, MipMapFunction, MipMapFunction, MipMapFunction> MipMapTuple;
MipMapTuple makeMipMapTuple(Effect* effect, const SGPropertyNode* props,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
osg::Image* computeMipmap( osg::Image* image, MipMapTuple attrs );
} }
SGMaterialAnimation.hxx
SGOffsetTransform.hxx
SGReaderWriterXML.hxx
- SGReaderWriterXMLOptions.hxx
SGRotateTransform.hxx
SGScaleTransform.hxx
SGText.hxx
#include <simgear/scene/util/SGSceneFeatures.hxx>
#include <simgear/scene/util/SGStateAttributeVisitor.hxx>
#include <simgear/scene/util/SGTextureStateAttributeVisitor.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/util/NodeAndDrawableVisitor.hxx>
#include <simgear/structure/exception.hxx>
#include "BoundingVolumeBuildVisitor.hxx"
#include "model.hxx"
-#include "SGReaderWriterXMLOptions.hxx"
using namespace std;
using namespace osg;
&& group->getNumChildren() == 1)
optimized = static_cast<Node*>(group->getChild(0));
}
- const SGReaderWriterXMLOptions* sgopt
- = dynamic_cast<const SGReaderWriterXMLOptions*>(opt);
+ const SGReaderWriterOptions* sgopt
+ = dynamic_cast<const SGReaderWriterOptions*>(opt);
if (sgopt && sgopt->getInstantiateEffects())
optimized = instantiateEffects(optimized.get(), sgopt);
return optimized.release();
#include <simgear/props/props_io.hxx>
#include <simgear/props/condition.hxx>
#include <simgear/scene/util/SGNodeMasks.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include "modellib.hxx"
#include "SGReaderWriterXML.hxx"
-#include "SGReaderWriterXMLOptions.hxx"
#include "animation.hxx"
#include "particles.hxx"
return NULL;
}
- const SGReaderWriterXMLOptions* xmlOptions;
- xmlOptions = dynamic_cast<const SGReaderWriterXMLOptions*>(options_);
+ const SGReaderWriterOptions* xmlOptions;
+ xmlOptions = dynamic_cast<const SGReaderWriterOptions*>(options_);
SGSharedPtr<SGPropertyNode> prop_root;
osg::Node *(*load_panel)(SGPropertyNode *)=0;
SGPath modelDir(modelpath.dir());
if (xmlOptions) {
- prop_root = xmlOptions->getPropRoot();
+ prop_root = xmlOptions->getPropertyNode();
load_panel = xmlOptions->getLoadPanel();
data = xmlOptions->getModelData();
}
// model without wrapper
}
- osg::ref_ptr<SGReaderWriterXMLOptions> options
- = new SGReaderWriterXMLOptions(*options_);
- options->setPropRoot(prop_root);
+ osg::ref_ptr<SGReaderWriterOptions> options
+ = new SGReaderWriterOptions(*options_);
+ options->setPropertyNode(prop_root);
options->setLoadPanel(load_panel);
// Assume that textures are in
continue;
}
- osg::ref_ptr<SGReaderWriterXMLOptions> options;
- options = new SGReaderWriterXMLOptions(*options_);
- options->setPropRoot(prop_root);
+ osg::ref_ptr<SGReaderWriterOptions> options;
+ options = new SGReaderWriterOptions(*options_);
+ options->setPropertyNode(prop_root);
options->setLoadPanel(load_panel);
try {
+++ /dev/null
-// Copyright (C) 2007 Tim Moore timoore@redhat.com
-// Copyright (C) 2008 Till Busch buti@bux.at
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-//
-#ifndef SGREADERWRITERXMLOPTIONS_HXX
-#define SGREADERWRITERXMLOPTIONS_HXX 1
-
-#include <osgDB/Registry>
-#include <simgear/scene/model/modellib.hxx>
-#include <simgear/props/props.hxx>
-
-class SGPropertyNode;
-
-namespace simgear
-{
-class SGModelData;
-
-class SGReaderWriterXMLOptions : public osgDB::ReaderWriter::Options
-{
-public:
- typedef osg::Node *(*panel_func)(SGPropertyNode *);
- META_Object(simgear, SGReaderWriterXMLOptions);
-
- SGReaderWriterXMLOptions():
- osgDB::ReaderWriter::Options(),
- _prop_root(0),
- _load_panel(0),
- _model_data(0),
- _instantiateEffects(false)
- {}
-
- SGReaderWriterXMLOptions(const std::string& str):
- osgDB::ReaderWriter::Options(str),
- _prop_root(0),
- _load_panel(0),
- _model_data(0),
- _instantiateEffects(false)
- {}
-
- SGReaderWriterXMLOptions(const SGReaderWriterXMLOptions& options,
- const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
- osgDB::ReaderWriter::Options(options, copyop),
- _prop_root(options._prop_root),
- _load_panel(options._load_panel),
- _model_data(options._model_data),
- _instantiateEffects(options._instantiateEffects)
- {}
-
- SGReaderWriterXMLOptions(const osgDB::ReaderWriter::Options& options,
- const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
- osgDB::ReaderWriter::Options(options, copyop),
- _prop_root(0),
- _load_panel(0),
- _model_data(0),
- _instantiateEffects(false)
- {}
-
- SGPropertyNode *getPropRoot() const {
- return _prop_root;
- }
- panel_func getLoadPanel() const {
- return _load_panel;
- }
- SGModelData *getModelData() const {
- return _model_data.get();
- }
- bool getInstantiateEffects() const
- {
- return _instantiateEffects;
- }
-
- void setPropRoot(SGPropertyNode *p) {
- _prop_root=p;
- }
- void setLoadPanel(panel_func pf) {
- _load_panel=pf;
- }
- void setModelData(SGModelData *d) {
- _model_data=d;
- }
- void setInstantiateEffects(bool doit)
- {
- _instantiateEffects = doit;
- }
-
-
-protected:
- virtual ~SGReaderWriterXMLOptions() {}
-
- SGPropertyNode_ptr _prop_root;
- osg::Node *(*_load_panel)(SGPropertyNode *);
- osg::ref_ptr<SGModelData> _model_data;
- bool _instantiateEffects;
-};
-
-}
-#endif
#include <simgear/scene/util/SGSceneUserData.hxx>
#include <simgear/scene/util/CopyOp.hxx>
#include <simgear/scene/util/SplicingVisitor.hxx>
-
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/structure/exception.hxx>
#include <simgear/structure/Singleton.hxx>
#include <simgear/props/props_io.hxx>
#include <simgear/props/condition.hxx>
-#include "SGReaderWriterXMLOptions.hxx"
#include "model.hxx"
using std::vector;
public:
typedef std::map<string, SGPropertyNode_ptr> EffectMap;
using SplicingVisitor::apply;
- MakeEffectVisitor(const SGReaderWriterXMLOptions* options = 0)
+ MakeEffectVisitor(const SGReaderWriterOptions* options = 0)
: _options(options)
{
}
protected:
EffectMap _effectMap;
SGPropertyNode_ptr _currentEffectParent;
- osg::ref_ptr<const SGReaderWriterXMLOptions> _options;
+ osg::ref_ptr<const SGReaderWriterOptions> _options;
};
void MakeEffectVisitor::apply(osg::Group& node)
ref_ptr<Node> instantiateEffects(osg::Node* modelGroup,
PropertyList& effectProps,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
SGPropertyNode_ptr defaultEffectPropRoot;
MakeEffectVisitor visitor(options);
namespace simgear
{
-class SGReaderWriterXMLOptions;
+class SGReaderWriterOptions;
}
osg::Texture2D*
osg::ref_ptr<osg::Node>
instantiateEffects(osg::Node* model,
PropertyList& effectProps,
- const SGReaderWriterXMLOptions* options);
+ const SGReaderWriterOptions* options);
/**
* Transform an OSG subgraph by substituting the Effects and
inline osg::ref_ptr<osg::Node>
instantiateEffects(osg::Node* model,
- const SGReaderWriterXMLOptions* options)
+ const SGReaderWriterOptions* options)
{
PropertyList effectProps;
return instantiateEffects(model, effectProps, options);
#include <simgear/props/props_io.hxx>
#include <simgear/scene/model/model.hxx>
#include <simgear/scene/model/ModelRegistry.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/misc/ResourceManager.hxx>
#include "SGReaderWriterXML.hxx"
-#include "SGReaderWriterXMLOptions.hxx"
#include "modellib.hxx"
namespace
{
-osg::Node* loadFile(const string& path, SGReaderWriterXMLOptions* options)
+osg::Node* loadFile(const string& path, SGReaderWriterOptions* options)
{
using namespace osg;
using namespace osgDB;
SGModelData *data,
bool load2DPanels)
{
- osg::ref_ptr<SGReaderWriterXMLOptions> opt = new SGReaderWriterXMLOptions(*(osgDB::Registry::instance()->getOptions()));
- opt->setPropRoot(prop_root ? prop_root: static_propRoot.get());
+ osg::ref_ptr<SGReaderWriterOptions> opt = new SGReaderWriterOptions(*(osgDB::Registry::instance()->getOptions()));
+ opt->setPropertyNode(prop_root ? prop_root: static_propRoot.get());
opt->setModelData(data);
if (load2DPanels) {
proxyNode->setLoadingExternalReferenceMode(osg::ProxyNode::DEFER_LOADING_TO_DATABASE_PAGER);
proxyNode->setFileName(0, path);
- osg::ref_ptr<SGReaderWriterXMLOptions> opt
- = new SGReaderWriterXMLOptions(*(osgDB::Registry::instance()
+ osg::ref_ptr<SGReaderWriterOptions> opt
+ = new SGReaderWriterOptions(*(osgDB::Registry::instance()
->getOptions()));
- opt->setPropRoot(prop_root ? prop_root: static_propRoot.get());
+ opt->setPropertyNode(prop_root ? prop_root: static_propRoot.get());
opt->setModelData(data);
opt->setLoadPanel(static_panelFunc);
if (SGPath(path).lower_extension() == "ac")
plod->setFileName(0, path);
plod->setRange(0, 0.0, 50.0*SG_NM_TO_METER);
- osg::ref_ptr<SGReaderWriterXMLOptions> opt
- = new SGReaderWriterXMLOptions(*(osgDB::Registry::instance()
+ osg::ref_ptr<SGReaderWriterOptions> opt
+ = new SGReaderWriterOptions(*(osgDB::Registry::instance()
->getOptions()));
- opt->setPropRoot(prop_root ? prop_root: static_propRoot.get());
+ opt->setPropertyNode(prop_root ? prop_root: static_propRoot.get());
opt->setModelData(data);
opt->setLoadPanel(static_panelFunc);
if (SGPath(path).lower_extension() == "ac")
#include <simgear/misc/PathOptions.hxx>
#include <simgear/props/props.hxx>
#include <simgear/scene/model/model.hxx>
-#include <simgear/scene/model/SGReaderWriterXMLOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include <simgear/scene/util/StateAttributeFactory.hxx>
#include <simgear/scene/util/SGUpdateVisitor.hxx>
texture);
ref_ptr<osgDB::ReaderWriter::Options> options
= makeOptionsFromPath(texture_root);
- ref_ptr<SGReaderWriterXMLOptions> sgOptions
- = new SGReaderWriterXMLOptions(*options.get());
+ ref_ptr<SGReaderWriterOptions> sgOptions
+ = new SGReaderWriterOptions(*options.get());
if ((effect = makeEffect(pcloudEffect, true, sgOptions.get())))
effectMap.insert(EffectMap::value_type(texture, effect));
} else {
SGModelBin.hxx
SGOceanTile.hxx
SGReaderWriterBTG.hxx
- SGReaderWriterBTGOptions.hxx
SGTexturedTriangleBin.hxx
SGTriangleBin.hxx
SGVasiDrawable.hxx
#include <osgDB/Registry>
#include <simgear/scene/model/ModelRegistry.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
-#include "SGReaderWriterBTGOptions.hxx"
#include "SGReaderWriterBTG.hxx"
#include "obj.hxx"
SGReaderWriterBTG::SGReaderWriterBTG()
{
supportsExtension("btg", "SimGear btg database format");
+ // supportsExtension("btg.gz", "SimGear btg database format");
}
SGReaderWriterBTG::~SGReaderWriterBTG()
bool
SGReaderWriterBTG::acceptsExtension(const std::string& extension) const
{
- std::string lowercase_ext = osgDB::convertToLowerCase(extension);
- if (lowercase_ext == "gz")
+ // trick the osg extensions match algorithm to accept btg.gz files.
+ if (osgDB::convertToLowerCase(extension) == "gz")
return true;
return osgDB::ReaderWriter::acceptsExtension(extension);
}
const osgDB::ReaderWriter::Options* options) const
{
SGMaterialLib* matlib = 0;
- bool calcLights = false;
bool useRandomObjects = false;
bool useRandomVegetation = false;
- const SGReaderWriterBTGOptions* btgOptions
- = dynamic_cast<const SGReaderWriterBTGOptions*>(options);
- if (btgOptions) {
- matlib = btgOptions->getMatlib();
- calcLights = btgOptions->getCalcLights();
- useRandomObjects = btgOptions->getUseRandomObjects();
- useRandomVegetation = btgOptions->getUseRandomVegetation();
+ const SGReaderWriterOptions* sgOptions;
+ sgOptions = dynamic_cast<const SGReaderWriterOptions*>(options);
+ if (sgOptions) {
+ matlib = sgOptions->getMaterialLib();
+ SGPropertyNode* propertyNode = sgOptions->getPropertyNode().get();
+ if (propertyNode) {
+ useRandomObjects
+ = propertyNode->getBoolValue("/sim/rendering/random-objects",
+ useRandomObjects);
+ useRandomVegetation
+ = propertyNode->getBoolValue("/sim/rendering/random-vegetation",
+ useRandomVegetation);
+ }
}
- osg::Node* result = SGLoadBTG(fileName, matlib, calcLights,
+
+ osg::Node* result = SGLoadBTG(fileName, matlib,
useRandomObjects,
useRandomVegetation);
if (result)
+++ /dev/null
-// Copyright (C) 2007 Tim Moore timoore@redhat.com
-//
-// This program is free software; you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of the
-// License, or (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-//
-#ifndef SGREADERWRITERBTGOPTIONS_HXX
-#define SGREADERWRITERBTGOPTIONS_HXX
-
-#include <osgDB/ReaderWriter>
-#include <simgear/scene/tgdb/obj.hxx>
-class SGReaderWriterBTGOptions : public osgDB::ReaderWriter::Options {
-public:
- META_Object(simgear,SGReaderWriterBTGOptions);
- SGReaderWriterBTGOptions(const std::string& str = std::string()) :
- osgDB::ReaderWriter::Options(str),
- _matlib(0), _calcLights(true),
- _useRandomObjects(false),
- _useRandomVegetation(false)
- {}
-
- SGReaderWriterBTGOptions(const SGReaderWriterBTGOptions& options,
- const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
- osgDB::ReaderWriter::Options(options, copyop),
- _matlib(options._matlib), _calcLights(options._calcLights),
- _useRandomObjects(options._useRandomObjects),
- _useRandomVegetation(options._useRandomVegetation)
- {
- }
- SGMaterialLib* getMatlib() const { return _matlib; }
- void setMatlib (SGMaterialLib* matlib) { _matlib = matlib; }
- bool getCalcLights() const { return _calcLights; }
- void setCalcLights(bool calcLights) { _calcLights = calcLights; }
- bool getUseRandomObjects() const { return _useRandomObjects; }
- bool getUseRandomVegetation() const { return _useRandomVegetation; }
- void setUseRandomObjects(bool useRandomObjects)
- {
- _useRandomObjects = useRandomObjects;
- }
- void setUseRandomVegetation(bool useRandomVegetation)
- {
- _useRandomVegetation = useRandomVegetation;
- }
-
-protected:
- virtual ~SGReaderWriterBTGOptions() {}
- SGMaterialLib* _matlib;
- bool _calcLights;
- bool _useRandomObjects;
- bool _useRandomVegetation;
-};
-#endif
#include <simgear/scene/model/ModelRegistry.hxx>
#include <simgear/scene/tgdb/apt_signs.hxx>
#include <simgear/scene/tgdb/obj.hxx>
-#include <simgear/scene/tgdb/SGReaderWriterBTGOptions.hxx>
+#include <simgear/scene/util/SGReaderWriterOptions.hxx>
#include "ReaderWriterSTG.hxx"
#include "TileEntry.hxx"
}
}
- const SGReaderWriterBTGOptions* btgOpt;
- btgOpt = dynamic_cast<const SGReaderWriterBTGOptions *>(options);
- osg::ref_ptr<SGReaderWriterBTGOptions> opt;
+ const SGReaderWriterOptions* btgOpt;
+ btgOpt = dynamic_cast<const SGReaderWriterOptions*>(options);
+ osg::ref_ptr<SGReaderWriterOptions> opt;
if (btgOpt)
- opt = new SGReaderWriterBTGOptions(*btgOpt);
+ opt = new SGReaderWriterOptions(*btgOpt);
else
- opt = new SGReaderWriterBTGOptions;
+ opt = new SGReaderWriterOptions;
// obj_load() will generate ground lighting for us ...
osg::Group* new_tile = new osg::Group;
if (found_tile_base) {
// load tile if found ...
- opt->setCalcLights(true);
obj_load( object_base.str(), new_tile, true, opt.get());
} else {
// ... or generate an ocean tile on the fly
SG_LOG(SG_TERRAIN, SG_INFO, " Generating ocean tile");
if ( !SGGenTile( path_list[0], tile_bucket,
- opt->getMatlib(), new_tile ) ) {
+ opt->getMaterialLib(), new_tile ) ) {
SG_LOG( SG_TERRAIN, SG_ALERT,
"Warning: failed to generate ocean tile!" );
}
if (obj->type == OBJECT) {
SGPath custom_path = obj->path;
custom_path.append( obj->name );
- opt->setCalcLights(true);
obj_load( custom_path.str(), new_tile, false, opt.get());
} else if (obj->type == OBJECT_SHARED || obj->type == OBJECT_STATIC) {
osg::Node *custom_obj = 0;
if (obj->type == OBJECT_SIGN)
- custom_obj = SGMakeSign(opt->getMatlib(), custom_path.str(), obj->name);
+ custom_obj = SGMakeSign(opt->getMaterialLib(), custom_path.str(), obj->name);
else
- custom_obj = SGMakeRunwaySign(opt->getMatlib(), custom_path.str(), obj->name);
+ custom_obj = SGMakeRunwaySign(opt->getMaterialLib(), custom_path.str(), obj->name);
// wire the pieces together
if ( custom_obj != NULL ) {
GetModelLODCoord> RandomObjectsQuadtree;
osg::Node*
-SGLoadBTG(const std::string& path, SGMaterialLib *matlib, bool calc_lights, bool use_random_objects, bool use_random_vegetation)
+SGLoadBTG(const std::string& path, SGMaterialLib *matlib, bool use_random_objects, bool use_random_vegetation)
{
SGBinObject tile;
if (!tile.read_bin(path))
}
}
- if (calc_lights) {
- // FIXME: ugly, has a side effect
- if (matlib)
- tileGeometryBin.computeRandomSurfaceLights(matlib);
-
- if (tileGeometryBin.tileLights.getNumLights() > 0
- || tileGeometryBin.randomTileLights.getNumLights() > 0) {
- osg::Group* groundLights0 = new osg::Group;
- groundLights0->setStateSet(lightManager->getGroundLightStateSet());
- groundLights0->setNodeMask(GROUNDLIGHTS0_BIT);
- osg::Geode* geode = new osg::Geode;
- geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.tileLights));
- geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 4, -0.3f));
- groundLights0->addChild(geode);
- lightGroup->addChild(groundLights0);
- }
- if (tileGeometryBin.randomTileLights.getNumLights() > 0) {
- osg::Group* groundLights1 = new osg::Group;
- groundLights1->setStateSet(lightManager->getGroundLightStateSet());
- groundLights1->setNodeMask(GROUNDLIGHTS1_BIT);
- osg::Group* groundLights2 = new osg::Group;
- groundLights2->setStateSet(lightManager->getGroundLightStateSet());
- groundLights2->setNodeMask(GROUNDLIGHTS2_BIT);
- osg::Geode* geode = new osg::Geode;
- geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 2, -0.15f));
- groundLights1->addChild(geode);
- lightGroup->addChild(groundLights1);
- geode = new osg::Geode;
- geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights));
- groundLights2->addChild(geode);
- lightGroup->addChild(groundLights2);
- }
+ // FIXME: ugly, has a side effect
+ if (matlib)
+ tileGeometryBin.computeRandomSurfaceLights(matlib);
+
+ if (tileGeometryBin.tileLights.getNumLights() > 0
+ || tileGeometryBin.randomTileLights.getNumLights() > 0) {
+ osg::Group* groundLights0 = new osg::Group;
+ groundLights0->setStateSet(lightManager->getGroundLightStateSet());
+ groundLights0->setNodeMask(GROUNDLIGHTS0_BIT);
+ osg::Geode* geode = new osg::Geode;
+ geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.tileLights));
+ geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 4, -0.3f));
+ groundLights0->addChild(geode);
+ lightGroup->addChild(groundLights0);
+ }
+ if (tileGeometryBin.randomTileLights.getNumLights() > 0) {
+ osg::Group* groundLights1 = new osg::Group;
+ groundLights1->setStateSet(lightManager->getGroundLightStateSet());
+ groundLights1->setNodeMask(GROUNDLIGHTS1_BIT);
+ osg::Group* groundLights2 = new osg::Group;
+ groundLights2->setStateSet(lightManager->getGroundLightStateSet());
+ groundLights2->setNodeMask(GROUNDLIGHTS2_BIT);
+ osg::Geode* geode = new osg::Geode;
+ geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights, 2, -0.15f));
+ groundLights1->addChild(geode);
+ lightGroup->addChild(groundLights1);
+ geode = new osg::Geode;
+ geode->addDrawable(SGLightFactory::getLights(tileGeometryBin.randomTileLights));
+ groundLights2->addChild(geode);
+ lightGroup->addChild(groundLights2);
}
if (!tileGeometryBin.vasiLights.empty()) {
}
osg::Node*
-SGLoadBTG(const std::string& path, SGMaterialLib *matlib, bool calc_lights, bool use_random_objects, bool use_random_vegetation);
+SGLoadBTG(const std::string& path, SGMaterialLib *matlib, bool use_random_objects, bool use_random_vegetation);
#endif // _SG_OBJ_HXX
SGEnlargeBoundingBox.hxx
SGNodeMasks.hxx
SGPickCallback.hxx
+ SGReaderWriterOptions.hxx
SGSceneFeatures.hxx
SGSceneUserData.hxx
SGStateAttributeVisitor.hxx
--- /dev/null
+// Copyright (C) 2007 Tim Moore timoore@redhat.com
+// Copyright (C) 2008 Till Busch buti@bux.at
+// Copyright (C) 2011 Mathias Froehlich
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+
+#ifndef SGREADERWRITEROPTIONS_HXX
+#define SGREADERWRITEROPTIONS_HXX 1
+
+#include <osgDB/Options>
+#include <simgear/scene/model/modellib.hxx>
+#include <simgear/props/props.hxx>
+
+class SGPropertyNode;
+class SGMaterialLib;
+
+namespace simgear
+{
+
+class SGReaderWriterOptions : public osgDB::Options {
+public:
+ SGReaderWriterOptions() :
+ _materialLib(0),
+ _load_panel(0),
+ _model_data(0),
+ _instantiateEffects(false)
+ { }
+ SGReaderWriterOptions(const std::string& str) :
+ osgDB::ReaderWriter::Options(str),
+ _materialLib(0),
+ _load_panel(0),
+ _model_data(0),
+ _instantiateEffects(false)
+ { }
+ SGReaderWriterOptions(const osgDB::Options& options,
+ const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY) :
+ osgDB::ReaderWriter::Options(options, copyop),
+ _materialLib(0),
+ _load_panel(0),
+ _model_data(0),
+ _instantiateEffects(false)
+ { }
+ SGReaderWriterOptions(const SGReaderWriterOptions& options,
+ const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY) :
+ osgDB::ReaderWriter::Options(options, copyop),
+ _propertyNode(options._propertyNode),
+ _materialLib(options._materialLib),
+ _load_panel(options._load_panel),
+ _model_data(options._model_data),
+ _instantiateEffects(options._instantiateEffects)
+ { }
+
+ META_Object(simgear, SGReaderWriterOptions);
+
+ const SGSharedPtr<SGPropertyNode>& getPropertyNode() const
+ { return _propertyNode; }
+ void setPropertyNode(const SGSharedPtr<SGPropertyNode>& propertyNode)
+ { _propertyNode = propertyNode; }
+
+ SGMaterialLib* getMaterialLib() const
+ { return _materialLib; }
+ void setMaterialLib(SGMaterialLib* materialLib)
+ { _materialLib = materialLib; }
+
+ typedef osg::Node *(*panel_func)(SGPropertyNode *);
+
+ panel_func getLoadPanel() const
+ { return _load_panel; }
+ void setLoadPanel(panel_func pf)
+ { _load_panel=pf; }
+
+ SGModelData *getModelData() const
+ { return _model_data.get(); }
+ void setModelData(SGModelData *modelData)
+ { _model_data=modelData; }
+
+ bool getInstantiateEffects() const
+ { return _instantiateEffects; }
+ void setInstantiateEffects(bool instantiateEffects)
+ { _instantiateEffects = instantiateEffects; }
+
+protected:
+ virtual ~SGReaderWriterOptions() {}
+
+private:
+ SGSharedPtr<SGPropertyNode> _propertyNode;
+ SGMaterialLib* _materialLib;
+ osg::Node *(*_load_panel)(SGPropertyNode *);
+ osg::ref_ptr<SGModelData> _model_data;
+ bool _instantiateEffects;
+};
+
+}
+
+#endif
projects / simgear.git / commitdiff