void CanvasProcessor::propagateEvent(Event* event, Outport* source) {
if (event->hasVisitedProcessor(this)) return;
event->markAsVisited(this);
invokeEvent(event);
if (event->hasBeenUsed()) return;
if (event->hash() == ResizeEvent::chash()) {
auto resizeEvent = static_cast<ResizeEvent*>(event);
// Avoid continues evaluation when port dimensions changes
NetworkLock lock(this);
dimensions_.set(resizeEvent->size());
if (enableCustomInputDimensions_) {
sizeChanged();
} else {
inport_.propagateEvent(resizeEvent, nullptr);
// Make sure this processor is invalidated.
invalidate(InvalidationLevel::InvalidOutput);
}
} else {
bool used = event->hasBeenUsed();
for (auto inport : getInports()) {
if (event->shouldPropagateTo(inport, this, source)) {
inport->propagateEvent(event);
used |= event->hasBeenUsed();
event->markAsUnused();
}
}
if (used) event->markAsUsed();
}
}
void Processor::propagateEvent(Event* event) {
invokeEvent(event);
if (event->hasBeenUsed()) return;
for (auto inport : getInports()) {
inport->propagateEvent(event);
if (event->hasBeenUsed()) return;
}
}
QList<Port*> PortOwnerGraphicsItem::getPorts() const {
QList<Port*> result = getInports();
result += getOutports();
foreach (CoProcessorPort* p, getCoProcessorInports() + getCoProcessorOutports())
result.append(p);
return result;
}
void RenderProcessor::adjustRenderOutportSizes() {
// detect dimension of first connected render inport
tgt::ivec2 inputDim(-1);
const std::vector<Port*> inports = getInports();
for (size_t i=0; i<inports.size() && inputDim == tgt::ivec2(-1); ++i) {
RenderPort* rp = dynamic_cast<RenderPort*>(inports[i]);
if (rp && rp->hasRenderTarget()){
inputDim = rp->getSize();
break;
}
}
// - assign inport dimension to all connected render outports, which are not size receivers
// - if a outport is a size receiver, assign its received rendering size to it
tgt::ivec2 resizeDim = tgt::ivec2(-1);
const std::vector<Port*> outports = getOutports();
for (size_t i=0; i<outports.size(); ++i) {
RenderPort* rp = dynamic_cast<RenderPort*>(outports[i]);
if (!rp || !rp->hasRenderTarget())
continue;
if (rp->getRenderSizePropagation() == RenderPort::RENDERSIZE_DEFAULT) {
if (inputDim != rp->getSize() && inputDim != tgt::ivec2(-1)) {
rp->resize(inputDim);
if (resizeDim == tgt::ivec2(-1))
resizeDim = inputDim;
}
}
else if (rp->getRenderSizePropagation() == RenderPort::RENDERSIZE_RECEIVER) {
RenderSizeReceiveProperty* receiveProp = rp->getSizeReceiveProperty();
tgtAssert(receiveProp, "Render outport is size receiver, but has no SizeReceiveProperty");
if (receiveProp->get() != rp->getSize()) {
rp->resize(receiveProp->get());
if (resizeDim == tgt::ivec2(-1))
resizeDim = receiveProp->get();
}
}
else if (rp->getRenderSizePropagation() == RenderPort::RENDERSIZE_STATIC) {
// nothing to do
}
else {
LERROR("Render outport has invalid render size propgation mode: " << rp->getQualifiedName());
}
}
// resize private render ports to resizeDim
if (resizeDim != tgt::ivec2(-1)) {
for (size_t i=0; i<privateRenderPorts_.size(); i++)
privateRenderPorts_.at(i)->resize(resizeDim);
}
}
std::vector<Port*> Processor::getPorts() const {
std::vector<Port*> result;
const std::vector<Port*> inports = getInports();
result.insert(result.begin(), inports.begin(), inports.end());
const std::vector<Port*> outports = getOutports();
result.insert(result.end(), outports.begin(), outports.end());
const std::vector<CoProcessorPort*> coProcessorInports = getCoProcessorInports();
result.insert(result.begin(), coProcessorInports.begin(), coProcessorInports.end());
const std::vector<CoProcessorPort*> coProcessorOutports = getCoProcessorOutports();
result.insert(result.end(), coProcessorOutports.begin(), coProcessorOutports.end());
return result;
}
