Processor* CompositeProperty::getProcessor() {
PropertyOwner* owner = getOwner();
if (owner) {
return owner->getProcessor();
} else {
return nullptr;
}
}
std::string Property::fullyQualifiedIdentifier() const {
std::string identifier = _identifier;
PropertyOwner* currentOwner = owner();
while (currentOwner) {
std::string ownerId = currentOwner->name();
if (!ownerId.empty()) {
identifier = ownerId + "." + identifier;
}
currentOwner = currentOwner->owner();
}
return identifier;
}
void TemplatePropertyTimeline<Camera>::deserialize(XmlDeserializer& s) {
s.deserialize("activeOnRendering", activeOnRendering_);
PropertyOwner* propertyOwner = 0;
s.deserialize("propertyOwner", propertyOwner);
std::string propertyId;
s.deserialize("propertyId", propertyId);
if (propertyOwner)
property_ = dynamic_cast<CameraProperty*>(propertyOwner->getProperty(propertyId));
else
LERRORC("TemplatePropertyTimeline<Camera>", "deserialize(): no property owner");
s.deserialize("duration", duration_);
s.deserialize("timeline", timeline_);
}
// TODO force user to pass camprop pointer instead of blindly searching for it
CameraProperty* LightSourceProperty::getCamera() {
if(camProp_)
return camProp_;
else {
PropertyOwner* propOwner = getOwner();
if(!propOwner)
return 0;
std::vector<Property*> props = propOwner->getProperties();
std::vector<Property*>::iterator it = props.begin();
while (it != props.end()) {
if(CameraProperty* camProp = dynamic_cast<CameraProperty*>(*it)) {
setCamera(camProp);
break;
}
++it;
}
return camProp_;
}
}
void Property::propertyModified() {
NetworkLock lock(this);
onChangeCallback_.invokeAll();
setPropertyModified(true);
PropertyOwner* owner = getOwner();
if (owner) {
// Evaluate property links
if (Processor* processor = owner->getProcessor()) {
processor->notifyObserversAboutPropertyChange(this);
}
// Invalidate Owner
if (getInvalidationLevel() > InvalidationLevel::Valid) {
owner->invalidate(getInvalidationLevel(), this);
}
}
updateWidgets();
}
Property* PropertyOwner::property(const std::string& id) const {
assert(std::is_sorted(_properties.begin(), _properties.end(), propertyLess));
// As the _properties list is sorted, just finding the lower bound is sufficient
std::vector<Property*>::const_iterator it
= std::lower_bound(_properties.begin(), _properties.end(), id,
[](Property* prop, const std::string& str) {
return prop->identifier() < str;
});
if (it == _properties.end() || (*it)->identifier() != id) {
// if we do not own the searched property, it must consist of a concatenated
// name and we can delegate it to a subowner
const size_t ownerSeparator = id.find(URISeparator);
if (ownerSeparator == std::string::npos) {
// if we do not own the property and there is no separator, it does not exist
return nullptr;
}
else {
const std::string ownerName = id.substr(0, ownerSeparator);
const std::string propertyName = id.substr(ownerSeparator + 1);
PropertyOwner* owner = propertySubOwner(ownerName);
if (owner == nullptr) {
return nullptr;
}
else {
// Recurse into the subOwner
return owner->property(propertyName);
}
}
}
else {
return *it;
}
}
/**
* Constrain the local properties of the PropertyOwner.
* @param propertyOwner to constrain
* @param updateBufferIndex buffer index to use
* @return The number of constraints that are still being applied
*/
unsigned int ConstrainPropertyOwner( PropertyOwner& propertyOwner, BufferIndex updateBufferIndex )
{
unsigned int activeCount = 0;
ConstraintOwnerContainer& constraints = propertyOwner.GetConstraints();
const ConstraintIter endIter = constraints.End();
for( ConstraintIter iter = constraints.Begin(); iter != endIter; ++iter )
{
ConstraintBase& constraint = **iter;
constraint.Apply( updateBufferIndex );
if( constraint.mWeight[updateBufferIndex] < 1.0f )
{
// this constraint is still being applied
++activeCount;
}
}
return activeCount;
}
