Description

Test:

basic render node structure and building blocks. This test documents and verifies some fundamental Render Node structures, looking at intricate technical details, which are usually hidden below the NodeBuidler.

verify_NodeStructure is a demonstration example to show fundamentals of node construction and invocation, using a dummy implementation.
the following cases cover extremely technical details of the FeedManifold, which serves as junction point between Render Node and external library functions.
in a similar style, NodeFeed_test covers the various parameter- and data connections of Nodes in a »clean-room« setting
much more high-level is NodeLink_test, covering the construction of a Render Node network
NodeBuilder_test focuses on aspects of node generation, as packaged into the NodeBuilder.

Definition at line 67 of file node-base-test.cpp.

Private Member Functions
virtual void	run (Arg)

void	verify_TurnoutSystem ()

void	verify_NodeStructure ()

void	verify_FeedManifold ()

void	verify_FeedPrototype ()

Member Function Documentation

◆ run()

virtual void run ( Arg )

inlineprivatevirtual

Definition at line 70 of file node-base-test.cpp.

References NodeBase_test::verify_FeedManifold(), NodeBase_test::verify_FeedPrototype(), NodeBase_test::verify_NodeStructure(), and NodeBase_test::verify_TurnoutSystem().

Here is the call graph for this function:

◆ verify_TurnoutSystem()

void verify_TurnoutSystem ( )

inlineprivate

Test:

the TurnoutSystem as transient connection hub for node invocation

for most invocations, just the nominal timeline time and an arbitrary process indentification-key is placed into fixed «slots« within the TurnoutSystem, from where these parameters can be retrieved by actual processing functions;
for some special cases however, additional storage blocks can be chained up, to allow accessing arbitrary parameters through the TurnoutSystem as front-end.

Definition at line 90 of file node-base-test.cpp.

References steam::engine::buildParamSpec(), and RandomSequencer< GEN >::uni().

Referenced by NodeBase_test::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_NodeStructure()

void verify_NodeStructure ( )

inlineprivate

Test:

very basic structure of a Render Node.

All render processing happens in Port implementations
here we use a dummy port, which just picks up a parameter from the TurnoutSystem and writes it into the output buffer; no further recursive call happens — so this is a source node.
To incorporate this Port implementation into a Render Node, the connectivity of the node network must be defined:
- each node has a list of »Leads« (predecessor nodes)
- and an array of port implementation (here just one port)
note that data placement relies on lib::Several, which can be configured to use a custom allocator to manage storage
furthermore, a node gets some ID descriptors, which are used to generate processing metadata (notably a hash key for caching)
for the actual invocation, foremost we need a buffer provider
and we need to supply the most basic parameters, like the nominal timeline time and a proccess-Key. These will be embedded into the TurnoutSystem, to be accessible throughout the complete recursive node-pull invocation.
This test verifies that the actual invocation indeed happened and placed a random parameter-value into the output buffer.

Remarks: In reality, processing operations are delegated to a media-processing library, which requires elaborate buffer handling and typically entails recursive calls to predecessor nodes. This intricate logic is handled by the typical Port implementation known as MediaWeavingPattern; notably the processing will rely on a transient data structure called FeedManifold, which is verified in much more detail below

Entrance point to the next recursive step of media processing.

Definition at line 151 of file node-base-test.cpp.

References BuffHandle::accessAs(), DiagnosticBufferProvider::build(), ProcID::describe(), TurnoutSystem::getProcKey(), BufferProvider::lockBufferFor(), BuffHandle::release(), steam::engine::watch(), and Time::ZERO.

Referenced by NodeBase_test::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_FeedManifold()

void verify_FeedManifold ( )

inlineprivate

Test:

the FeedManifold as adapter between Engine and processing library...

bind local λ with various admissible signatures
construct specifically tailored FeedManifold types
use the DiagnosticBufferProvider for test buffers
create FeedManifold instance, passing the λ and additional parameters
connect BuffHandle for these buffers into the FeedManifold instance
trigger invocation of the function
look into the buffers and verify effect

Remarks: within each Render Node, a FeedManifold is used as junction to tap into processing functionality provided by external libraries. Those will be adapted by a Plug-in, to be loaded by the Lumiera core application. The signature of a functor linked to the FeedManifold is used as kind of a low-level-specification how to invoke external processing functions. Obviously this must be complemented by a more high-level descriptor, which is interpreted by the Builder to connect a suitable structure of Render Nodes.