weaving-pattern.hpp File Reference

Go to the source code of this file.

Description

Construction set to assemble and operate a data processing scheme within a Render Node.

This header defines part of the "glue" which holds together the render node network and enables to pull result frames from the nodes. Doing so requires some invocation local state to be maintained, especially a table of buffers used to carry out the calculations. Further, getting the input buffers filled requires to issue recursive pull() calls, which on the whole creates a stack-like assembly of local invocation state. The actual steps to be carried out for a pull() call are dependent on the configuration of the node to pull. Each node has been preconfigured by the builder with a Connectivity descriptor and a concrete type of a StateAdapter. The actual sequence of steps is defined in the header nodeoperation.hpp out of a set of basic operation steps. These steps all use the passed in Invocation object (a sub-interface of StateAdapter) to access the various aspects of the invocation state.

composition of the Invocation State

For each individual ProcNode::pull() call, the WiringAdapter::callDown() builds an StateAdapter instance directly on the stack, managing the actual buffer pointers and state references. Using this StateAdapter, the predecessor nodes are pulled. The way these operations are carried out is encoded in the actual StateAdapter type known to the NodeWiring (WiringAdapter) instance. All of these actual StateAdapter types are built as implementing the engine::StateClosure interface.

Todo:

relies still on an obsoleted implementation draft

See also

engine::ProcNode

engine::StateProxy

engine::FeedManifold

nodewiring.hpp interface for building/wiring the nodes

Warning

as of 12/2024 first complete integration round of the Render engine ////////////////////////////TICKET #1367

Definition in file weaving-pattern.hpp.

#include "steam/common.hpp"
#include "steam/engine/proc-node.hpp"
#include "steam/engine/turnout-system.hpp"
#include "steam/engine/feed-manifold.hpp"
#include "lib/several.hpp"
#include "lib/meta/function.hpp"
#include <utility>
#include <array>

Classes
struct	SimpleWeavingPattern< INVO >
	Standard implementation for a Weaving Pattern to connect the input and output data feeds (buffers) into a processing function. More...
class	Turnout< PAT >
	Processing structure to activate a Render Node and produce result data. More...

Namespaces
	steam
	Steam-Layer implementation namespace root.
	steam::engine
	Lumiera's render engine core and operational control.