FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'UniformFactory' into next

Browse Source 
Merging in Stuart's fix for the Effect system
This commit is contained in:
Torsten Dreyer
2014-09-27 21:50:44 +02:00
parent deceee8997 ab956f15c3
commit 2bf79a2fa1
5 changed files with 199 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
simgear/scene/material/Effect.cxx
View File

@@ -30,6 +30,7 @@
#include <functional>
#include <iterator>
#include <map>
#include <queue>
#include <utility>
#include <boost/tr1/unordered_map.hpp>
@@ -77,7 +78,8 @@
#include <simgear/structure/OSGUtils.hxx>
#include <simgear/structure/SGExpression.hxx>
#include <simgear/props/vectorPropTemplates.hxx>
#include <simgear/threads/SGThread.hxx>
#include <simgear/threads/SGGuard.hxx>
namespace simgear
{
@@ -87,6 +89,148 @@ using namespace osgUtil;
using namespace effect;
class UniformFactoryImpl {
public:
ref_ptr<Uniform> getUniform( Effect * effect,
const string & name,
Uniform::Type uniformType,
SGConstPropertyNode_ptr valProp,
const SGReaderWriterOptions* options );
void updateListeners( SGPropertyNode* propRoot );
void addListener(DeferredPropertyListener* listener);
private:
// Default names for vector property components
static const char* vec3Names[];
static const char* vec4Names[];
SGMutex _mutex;
typedef boost::tuple<std::string, Uniform::Type, std::string> UniformCacheKey;
typedef boost::tuple<ref_ptr<Uniform>, SGPropertyChangeListener*> UniformCacheValue;
//std::map<UniformCacheKey,UniformCacheValue > uniformCache;
std::map<UniformCacheKey,ref_ptr<Uniform> > uniformCache;
typedef std::queue<DeferredPropertyListener*> DeferredListenerList;
DeferredListenerList deferredListenerList;
};
const char* UniformFactoryImpl::vec3Names[] = {"x", "y", "z"};
const char* UniformFactoryImpl::vec4Names[] = {"x", "y", "z", "w"};
ref_ptr<Uniform> UniformFactoryImpl::getUniform( Effect * effect,
const string & name,
Uniform::Type uniformType,
SGConstPropertyNode_ptr valProp,
const SGReaderWriterOptions* options )
{
SGGuard<SGMutex> scopeLock(_mutex);
std::string val = "0";
if (valProp->nChildren() == 0) {
// Completely static value
val = valProp->getStringValue();
} else {
// Value references <parameters> section of Effect
const SGPropertyNode* prop = getEffectPropertyNode(effect, valProp);
if (prop) {
if (prop->nChildren() == 0) {
// Static value in parameters section
val = prop->getStringValue();
} else {
// Dynamic property value in parameters section
val = getGlobalProperty(prop, options);
}
} else {
SG_LOG(SG_GL,SG_DEBUG,"Invalid parameter " << valProp->getName() << " for uniform " << name << " in Effect ");
}
}
UniformCacheKey key = boost::make_tuple(name, uniformType, val);
//UniformCacheValue value = uniformCache[key];
//ref_ptr<Uniform> uniform = value.get_head();
ref_ptr<Uniform> uniform = uniformCache[key];
if (uniform.valid()) {
// We've got a hit to cache - simply return it
return uniform;
}
SG_LOG(SG_GL,SG_DEBUG,"new uniform " << name << " value " << uniformCache.size());
uniformCache[key] = uniform = new Uniform;
DeferredPropertyListener* updater = 0;
uniform->setName(name);
uniform->setType(uniformType);
switch (uniformType) {
case Uniform::BOOL:
updater = initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(bool)>(&Uniform::set),
options);
break;
case Uniform::FLOAT:
updater = initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(float)>(&Uniform::set),
options);
break;
case Uniform::FLOAT_VEC3:
updater = initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(const Vec3&)>(&Uniform::set),
vec3Names, options);
break;
case Uniform::FLOAT_VEC4:
updater = initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(const Vec4&)>(&Uniform::set),
vec4Names, options);
break;
case Uniform::INT:
case Uniform::SAMPLER_1D:
case Uniform::SAMPLER_2D:
case Uniform::SAMPLER_3D:
case Uniform::SAMPLER_1D_SHADOW:
case Uniform::SAMPLER_2D_SHADOW:
case Uniform::SAMPLER_CUBE:
updater = initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(int)>(&Uniform::set),
options);
break;
default: // avoid compiler warning
SG_LOG(SG_ALL,SG_ALERT,"UNKNOWN Uniform type '" << uniformType << "'");
break;
}
addListener(updater);
return uniform;
}
void UniformFactoryImpl::addListener(DeferredPropertyListener* listener)
{
if (listener != 0) {
// Uniform requires a property listener. Add it to the list to be
// created when the main thread gets to it.
deferredListenerList.push(listener);
}
}
void UniformFactoryImpl::updateListeners( SGPropertyNode* propRoot )
{
SGGuard<SGMutex> scopeLock(_mutex);
if (deferredListenerList.empty()) return;
SG_LOG(SG_GL,SG_DEBUG,"Adding " << deferredListenerList.size() << " listeners for effects.");
// Instantiate all queued listeners
while (! deferredListenerList.empty()) {
DeferredPropertyListener* listener = deferredListenerList.front();
listener->activate(propRoot);
deferredListenerList.pop();
}
}
typedef Singleton<UniformFactoryImpl> UniformFactory;
Effect::Effect()
: _cache(0), _isRealized(false)
{
@@ -104,6 +248,8 @@ Effect::Effect(const Effect& rhs, const CopyOp& copyop)
techniques.push_back(static_cast<Technique*>(copyop(itr->get())));
generator = rhs.generator;
_name = rhs._name;
_name += " clone";
}
// Assume that the last technique is always valid.
@@ -173,10 +319,6 @@ void buildPass(Effect* effect, Technique* tniq, const SGPropertyNode* prop,
}
}
// Default names for vector property components
const char* vec3Names[] = {"x", "y", "z"};
const char* vec4Names[] = {"x", "y", "z", "w"};
osg::Vec4f getColor(const SGPropertyNode* prop)
{
if (prop->nChildren() == 0) {
@@ -898,10 +1040,10 @@ struct UniformBuilder :public PassAttributeBuilder
}
if (!isAttributeActive(effect, prop))
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");
SGConstPropertyNode_ptr nameProp = prop->getChild("name");
SGConstPropertyNode_ptr typeProp = prop->getChild("type");
SGConstPropertyNode_ptr positionedProp = prop->getChild("positioned");
SGConstPropertyNode_ptr valProp = prop->getChild("value");
string name;
Uniform::Type uniformType = Uniform::FLOAT;
if (nameProp) {
@@ -941,44 +1083,9 @@ struct UniformBuilder :public PassAttributeBuilder
} else {
findAttr(uniformTypes, typeProp, uniformType);
}
ref_ptr<Uniform> uniform = new Uniform;
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),
options);
break;
case Uniform::FLOAT_VEC3:
initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(const Vec3&)>(&Uniform::set),
vec3Names, options);
break;
case Uniform::FLOAT_VEC4:
initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(const Vec4&)>(&Uniform::set),
vec4Names, options);
break;
case Uniform::INT:
case Uniform::SAMPLER_1D:
case Uniform::SAMPLER_2D:
case Uniform::SAMPLER_3D:
case Uniform::SAMPLER_1D_SHADOW:
case Uniform::SAMPLER_2D_SHADOW:
case Uniform::SAMPLER_CUBE:
initFromParameters(effect, valProp, uniform.get(),
static_cast<bool (Uniform::*)(int)>(&Uniform::set),
options);
break;
default: // avoid compiler warning
break;
}
ref_ptr<Uniform> uniform = UniformFactory::instance()->
getUniform( effect, name, uniformType, valProp, options );
// optimize common uniforms
if (uniformType == Uniform::SAMPLER_2D || uniformType == Uniform::INT)
{
@@ -1345,6 +1452,10 @@ void Effect::InitializeCallback::doUpdate(osg::Node* node, osg::NodeVisitor* nv)
if (!effect)
return;
SGPropertyNode* root = getPropertyRoot();
// Initialize all queued listeners
UniformFactory::instance()->updateListeners(root);
for (vector<SGSharedPtr<Updater> >::iterator itr = effect->_extraData.begin(),
end = effect->_extraData.end();
itr != end;
@@ -1356,28 +1467,6 @@ void Effect::InitializeCallback::doUpdate(osg::Node* node, osg::NodeVisitor* nv)
}
}
void Effect::UpdateCallback::operator()(osg::Node* node, osg::NodeVisitor* nv)
{
EffectGeode* eg = dynamic_cast<EffectGeode*>(node);
if (!eg)
return;
Effect* effect = eg->getEffect();
if (!effect)
return;
for (vector<SGSharedPtr<Updater> >::iterator itr = effect->_extraData.begin(),
end = effect->_extraData.end();
itr != end;
++itr) {
PropertyPoller * poller
= dynamic_cast<PropertyPoller*>(itr->ptr());
if (poller)
poller->pollProperties(effect);
}
traverse(node, nv);
}
bool Effect::Key::EqualTo::operator()(const Effect::Key& lhs,
const Effect::Key& rhs) const
{

23
simgear/scene/material/Effect.hxx
View File

@@ -73,17 +73,13 @@ private:
bool _initialized;
};
class PropertyPoller
{
class DeferredPropertyListener {
public:
PropertyPoller() {};
virtual ~PropertyPoller() {};
virtual void pollProperties(Effect* effect)
{
}
private:
virtual void activate(SGPropertyNode* propRoot) {};
virtual ~DeferredPropertyListener() {};
};
class Effect : public osg::Object
{
public:
@@ -132,17 +128,6 @@ public:
{
void doUpdate(osg::Node* node, osg::NodeVisitor* nv);
};
friend struct UpdateCallback;
struct UpdateCallback : public osg::NodeCallback
{
UpdateCallback() {}
UpdateCallback(const UpdateCallback& nc, const osg::CopyOp& copyop)
: osg::NodeCallback(nc, copyop)
{
}
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
};
protected:
std::vector<SGSharedPtr<Updater> > _extraData;
~Effect();

62
simgear/scene/material/EffectBuilder.hxx
View File

@@ -495,44 +495,42 @@ make_OSGFunctor(Obj* obj, void (Obj::*const func)(const OSGParam&))
template<typename OSGParamType, typename ObjType, typename F>
class ScalarChangeListener
: public SGPropertyChangeListener, public InitializeWhenAdded,
public PropertyPoller,
public Effect::Updater
: public SGPropertyChangeListener, public DeferredPropertyListener
{
public:
ScalarChangeListener(ObjType* obj, const F& setter,
const std::string& propName)
: _obj(obj), _setter(setter), _propName(propName)
: _obj(obj), _setter(setter)
{
_propName = new std::string(propName);
SG_LOG(SG_GL,SG_DEBUG,"Creating ScalarChangeListener for " << *_propName );
}
virtual ~ScalarChangeListener()
{
delete _propName;
_propName = 0;
}
void valueChanged(SGPropertyNode* node)
{
_setter(_obj.get(), node->getValue<OSGParamType>());
}
void initOnAddImpl(Effect* effect, SGPropertyNode* propRoot)
void activate(SGPropertyNode* propRoot)
{
_listenProp = makeNode(propRoot, _propName);
// if ( _listenProp.valid() )
// _listenProp->addChangeListener(this, true);
}
void pollProperties(Effect* effect)
{
if( false == _listenProp.valid() ) return;
valueChanged(_listenProp);
SG_LOG(SG_GL,SG_DEBUG,"Adding change listener to " << *_propName );
SGPropertyNode* listenProp = makeNode(propRoot, *_propName);
delete _propName;
_propName = 0;
if (listenProp)
listenProp->addChangeListener(this, true);
}
private:
SGPropertyNode_ptr _listenProp;
osg::ref_ptr<ObjType> _obj;
F _setter;
std::string _propName;
std::string* _propName;
};
template<typename T, typename Func>
class EffectExtendedPropListener : public InitializeWhenAdded,
public Effect::Updater
class EffectExtendedPropListener : public DeferredPropertyListener
{
public:
template<typename Itr>
@@ -551,7 +549,7 @@ public:
delete _propName;
delete _childNames;
}
void initOnAddImpl(Effect* effect, SGPropertyNode* propRoot)
void activate(SGPropertyNode* propRoot)
{
SGPropertyNode* parent = 0;
if (_propName)
@@ -575,7 +573,7 @@ private:
};
template<typename T, typename Func, typename Itr>
Effect::Updater*
DeferredPropertyListener*
new_EEPropListener(const Func& func, const std::string* propName,
const Itr& namesBegin, const Itr& namesEnd)
{
@@ -609,32 +607,33 @@ inline void setDynamicVariance(osg::Object* obj)
* used.
*/
template<typename OSGParamType, typename ObjType, typename F>
void
DeferredPropertyListener*
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
const F& setter, const SGReaderWriterOptions* options)
{
const SGPropertyNode* valProp = getEffectPropertyNode(effect, prop);
ScalarChangeListener<OSGParamType, ObjType, F>* listener = 0;
if (!valProp)
return;
return listener;
if (valProp->nChildren() == 0) {
setter(obj, valProp->getValue<OSGParamType>());
} else {
setDynamicVariance(obj);
std::string propName = getGlobalProperty(valProp, options);
ScalarChangeListener<OSGParamType, ObjType, F>* listener
listener
= new ScalarChangeListener<OSGParamType, ObjType, F>(obj, setter,
propName);
effect->addUpdater(listener);
}
return listener;
}
template<typename OSGParamType, typename ObjType, typename SetterReturn>
inline void
inline DeferredPropertyListener*
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
SetterReturn (ObjType::*setter)(const OSGParamType),
const SGReaderWriterOptions* options)
{
initFromParameters<OSGParamType>(effect, prop, obj,
return initFromParameters<OSGParamType>(effect, prop, obj,
boost::bind(setter, _1, _2), options);
}
@@ -659,16 +658,17 @@ initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
*/
template<typename OSGParamType, typename ObjType, typename NameItrType,
typename F>
void
DeferredPropertyListener*
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
const F& setter,
NameItrType nameItr, const SGReaderWriterOptions* options)
{
typedef typename Bridge<OSGParamType>::sg_type sg_type;
DeferredPropertyListener* listener = 0;
const int numComponents = props::NumComponents<sg_type>::num_components;
const SGPropertyNode* valProp = getEffectPropertyNode(effect, prop);
if (!valProp)
return;
return listener;
if (valProp->nChildren() == 0) { // Has <use>?
setter(obj, Bridge<OSGParamType>::get(valProp->getValue<sg_type>()));
} else {
@@ -678,22 +678,22 @@ initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
if (paramNames.empty())
throw BuilderException();
std::vector<std::string>::const_iterator pitr = paramNames.begin();
Effect::Updater* listener
listener
= new_EEPropListener<sg_type>(make_OSGFunctor<OSGParamType>
(obj, setter),
0, pitr, pitr + numComponents);
effect->addUpdater(listener);
}
return listener;
}
template<typename OSGParamType, typename ObjType, typename NameItrType,
typename SetterReturn>
inline void
inline DeferredPropertyListener*
initFromParameters(Effect* effect, const SGPropertyNode* prop, ObjType* obj,
SetterReturn (ObjType::*setter)(const OSGParamType&),
NameItrType nameItr, const SGReaderWriterOptions* options)
{
initFromParameters<OSGParamType>(effect, prop, obj,
return initFromParameters<OSGParamType>(effect, prop, obj,
boost::bind(setter, _1, _2), nameItr,
options);
}

2
simgear/scene/material/EffectGeode.cxx
View File

@@ -52,9 +52,7 @@ void EffectGeode::setEffect(Effect* effect)
_effect = effect;
if (!_effect)
return;
//TODO: do we leak the callbacks or does the geode own pointer afterwards?
addUpdateCallback(new Effect::InitializeCallback);
addUpdateCallback(new Effect::UpdateCallback);
}
void EffectGeode::resizeGLObjectBuffers(unsigned int maxSize)

8
simgear/scene/material/TextureBuilder.cxx
View File

@@ -858,10 +858,14 @@ TexEnvCombine* buildTexEnvCombine(Effect* effect, const SGPropertyNode* envProp,
}
#endif
const SGPropertyNode* colorNode = envProp->getChild("constant-color");
if (colorNode)
initFromParameters(effect, colorNode, result,
if (colorNode) {
DeferredPropertyListener* listener = initFromParameters(effect, colorNode, result,
&TexEnvCombine::setConstantColor, colorFields,
options);
if (listener != 0) {
SG_LOG(SG_ALL,SG_ALERT,"Texture with property defined parameter");
}
}
return result;
}