From e7191ed3c6d6e0466dd05d332d770bb7b03bacf2 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Mon, 13 Dec 2010 03:22:11 +0100 Subject: [PATCH] Planning Fixure: Segmentation datastructure (#726) --- src/proc/Makefile.am | 6 +- .../builder/fixture-change-detector.hpp | 81 +++++++++++++ ...entationtool.cpp => segmentation-tool.cpp} | 96 ++++++++------- .../mobject/builder/segmentation-tool.hpp | 78 ++++++++++++ src/proc/mobject/builder/segmentation.cpp | 85 +++++++++++++ src/proc/mobject/builder/segmentation.hpp | 87 ++++++++++++++ src/proc/mobject/builder/segmentationtool.hpp | 80 ------------- src/proc/mobject/builder/toolfactory.hpp | 2 +- tests/44builder.tests | 10 ++ tests/components/Makefile.am | 2 + .../builder/fixture-change-detector-test.cpp | 113 ++++++++++++++++++ .../segmentation-datastructure-test.cpp | 113 ++++++++++++++++++ wiki/renderengine.html | 46 ++++++- 13 files changed, 665 insertions(+), 134 deletions(-) create mode 100644 src/proc/mobject/builder/fixture-change-detector.hpp rename src/proc/mobject/builder/{segmentationtool.cpp => segmentation-tool.cpp} (50%) create mode 100644 src/proc/mobject/builder/segmentation-tool.hpp create mode 100644 src/proc/mobject/builder/segmentation.cpp create mode 100644 src/proc/mobject/builder/segmentation.hpp delete mode 100644 src/proc/mobject/builder/segmentationtool.hpp create mode 100644 tests/components/proc/mobject/builder/fixture-change-detector-test.cpp create mode 100644 tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp diff --git a/src/proc/Makefile.am b/src/proc/Makefile.am index d2a185dbf..d8e58f786 100644 --- a/src/proc/Makefile.am +++ b/src/proc/Makefile.am @@ -109,7 +109,8 @@ liblumiprocmobjectbuilder_la_SOURCES = \ $(liblumiprocmobjectbuilder_la_srcdir)/assembler.cpp \ $(liblumiprocmobjectbuilder_la_srcdir)/conmanager.cpp \ $(liblumiprocmobjectbuilder_la_srcdir)/nodecreatortool.cpp \ - $(liblumiprocmobjectbuilder_la_srcdir)/segmentationtool.cpp \ + $(liblumiprocmobjectbuilder_la_srcdir)/segmentation.cpp \ + $(liblumiprocmobjectbuilder_la_srcdir)/segmentation-tool.cpp \ $(liblumiprocmobjectbuilder_la_srcdir)/toolfactory.cpp @@ -219,7 +220,8 @@ noinst_HEADERS += \ $(liblumiproc_la_srcdir)/mobject/builder/assembler.hpp \ $(liblumiproc_la_srcdir)/mobject/builder/buildertool.hpp \ $(liblumiproc_la_srcdir)/mobject/builder/conmanager.hpp \ - $(liblumiproc_la_srcdir)/mobject/builder/segmentationtool.hpp \ + $(liblumiproc_la_srcdir)/mobject/builder/segmentation.hpp \ + $(liblumiproc_la_srcdir)/mobject/builder/segmentation-tool.hpp \ $(liblumiproc_la_srcdir)/mobject/builder/toolfactory.hpp \ $(liblumiproc_la_srcdir)/mobject/builderfacade.hpp \ $(liblumiproc_la_srcdir)/mobject/explicitplacement.hpp \ diff --git a/src/proc/mobject/builder/fixture-change-detector.hpp b/src/proc/mobject/builder/fixture-change-detector.hpp new file mode 100644 index 000000000..7d25225f3 --- /dev/null +++ b/src/proc/mobject/builder/fixture-change-detector.hpp @@ -0,0 +1,81 @@ +/* + FIXTURE-CHANGE-DETECTOR.hpp - isolating changed segments and tainted processes + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +/** @file fixture-change-detector.hpp + ** Work out the part of the Fixture changed by a build process. + ** This facility helps to deal with ongoing render/playback processes, which might be + ** affected by the results of a build process. It's comprised of two distinct parts: + ** - a comparison tool allowing to spot equal and changed segments when considering + ** the old and the new version of the fixture before/after a build process. + ** - a registration service to establish a relation between play/render processes + ** and specific segments of the fixture. + ** Together, these allow to identify those ongoing processes which need to be cancelled + ** or restarted, because their results might be tainted by the changes induced by the + ** build process. Typically, these detection process runs just before commiting the + ** newly built fixture datastructure. + ** + ** @todo WIP-WIP-WIP as of 12/2010 + ** + ** @see Fixture + ** @see ModelPort + */ + + +#ifndef PROC_MOBJECT_BUILDER_FIXTURE_CHANGE_DETECTOR_H +#define PROC_MOBJECT_BUILDER_FIXTURE_CHANGE_DETECTOR_H + +#include "lib/error.hpp" +//#include "lib/optional-ref.hpp" +#include "proc/asset/pipe.hpp" +//#include "proc/asset/struct.hpp" +//#include "proc/mobject/model-port.hpp" + +//#include + +namespace mobject { +namespace builder { + + using asset::ID; + using asset::Pipe; +//using asset::Struct; + +//LUMIERA_ERROR_DECLARE (DUPLICATE_MODEL_PORT); ///< Attempt to define a new model port with an pipe-ID already denoting an existing port + + + /** + * TODO type comment + */ + class FixtureChangeDetector + : boost::noncopyable + { + + typedef ID PID; +// typedef ID StID; + + public: + + }; + + + +}} // namespace mobject::builder +#endif diff --git a/src/proc/mobject/builder/segmentationtool.cpp b/src/proc/mobject/builder/segmentation-tool.cpp similarity index 50% rename from src/proc/mobject/builder/segmentationtool.cpp rename to src/proc/mobject/builder/segmentation-tool.cpp index d0a18595d..b87109d68 100644 --- a/src/proc/mobject/builder/segmentationtool.cpp +++ b/src/proc/mobject/builder/segmentation-tool.cpp @@ -21,7 +21,7 @@ * *****************************************************/ -#include "proc/mobject/builder/segmentationtool.hpp" +#include "proc/mobject/builder/segmentation-tool.hpp" using mobject::Buildable; @@ -30,52 +30,50 @@ using mobject::session::Effect; namespace mobject { - namespace builder { - - /////////////////////////////////TICKET #414 - +namespace builder { - SegmentationTool::SegmentationTool(mobject::session::Fixture&) - { - UNIMPLEMENTED ("create new SegmentationTool"); - } - - - void - SegmentationTool::treat (Buildable& something) - { - UNIMPLEMENTED ("??? when partitioning timeline"); - } - - - void - SegmentationTool::treat (Clip& clip) - { - UNIMPLEMENTED ("consider clip when partitioning timeline"); - } - - - void - SegmentationTool::treat (Effect& effect) - { - UNIMPLEMENTED ("note applied effect when partitioning timeline"); - } - - - void - SegmentationTool::onUnknown (Buildable& target) - { - UNIMPLEMENTED ("catch-all when partitioning timeline"); - } - - - bool - SegmentationTool::empty() const - { - UNIMPLEMENTED ("detect an empty segmentation"); - } - - - } // namespace mobject::builder - -} // namespace mobject + /////////////////////////////////TICKET #414 + + + SegmentationTool::SegmentationTool(mobject::session::Fixture&) + { + UNIMPLEMENTED ("create new SegmentationTool"); + } + + + void + SegmentationTool::treat (Buildable& something) + { + UNIMPLEMENTED ("??? when partitioning timeline"); + } + + + void + SegmentationTool::treat (Clip& clip) + { + UNIMPLEMENTED ("consider clip when partitioning timeline"); + } + + + void + SegmentationTool::treat (Effect& effect) + { + UNIMPLEMENTED ("note applied effect when partitioning timeline"); + } + + + void + SegmentationTool::onUnknown (Buildable& target) + { + UNIMPLEMENTED ("catch-all when partitioning timeline"); + } + + + bool + SegmentationTool::empty() const + { + UNIMPLEMENTED ("detect an empty segmentation"); + } + + +}} // namespace mobject::builder diff --git a/src/proc/mobject/builder/segmentation-tool.hpp b/src/proc/mobject/builder/segmentation-tool.hpp new file mode 100644 index 000000000..a40f4c8f9 --- /dev/null +++ b/src/proc/mobject/builder/segmentation-tool.hpp @@ -0,0 +1,78 @@ +/* + SEGMENTATION-TOOL.hpp - Tool for creating a partitioning of the current timeline + + Copyright (C) Lumiera.org + 2008, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + + +#ifndef MOBJECT_BUILDER_SEGMENTATION_TOOL_H +#define MOBJECT_BUILDER_SEGMENTATION_TOOL_H + + +#include "proc/mobject/builder/applicable-builder-target-types.hpp" + +#include "proc/mobject/session/segmentation.hpp" +#include "proc/mobject/session/fixture.hpp" //////TODO really on the header?? + + +#include +using std::list; + + + +namespace mobject { +namespace builder { + + + /** + * Tool implementation for deriving a partitioning of the current + * timeline, such that each Segment has a constant configuration. + * "Constant" means here, that any remaining changes over time + * can be represented by automation solely, without the need + * to change the node connections. + */ + class SegmentationTool + : public ApplicableBuilderTargetTypes + { + + public: + SegmentationTool (session::Fixture &) ; + + void treat (mobject::session::Clip& clip) ; + void treat (mobject::session::Effect& effect) ; + + void treat (mobject::Buildable& something) ; + + void onUnknown (Buildable& target) ; /////////TODO why doesn't the treat(Buildable) function shadow this?? + + bool empty() const; + + private: + typedef mobject::session::Segment Segment; + + /** Partitioning of the Timeline to be created by this tool. */ + //session::Segmentation& segments_; + ///////////////////////////////////////////TODO: either put it inline, or use a scopend_ptr!!!!!!!!!! + + }; + + + +}} // namespace mobject::builder +#endif diff --git a/src/proc/mobject/builder/segmentation.cpp b/src/proc/mobject/builder/segmentation.cpp new file mode 100644 index 000000000..7231dfd0a --- /dev/null +++ b/src/proc/mobject/builder/segmentation.cpp @@ -0,0 +1,85 @@ +/* + Segmentation - partitioning the effective timeline + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +/** @file segmentation.cpp + ** Implementation details of fixture data structures. + ** + ** /////TODO file comment necessary? + ** + ** @see mobject::session::Fixture + ** + */ + + +#include "lib/error.hpp" +//#include "include/logging.h" +//#include "lib/sync-classlock.hpp" +//#include "proc/mobject/builderfacade.hpp" +#include "proc/mobject/builder/segmentation.hpp" +#include "proc/mobject/builder/fixture-change-detector.hpp" + +namespace mobject { +namespace builder { + + namespace error = lumiera::error; + + +// typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor; + + + /** storage for the link to the global + Registry instance currently in charge */ +// lib::OptionalRef ModelPortRegistry::theGlobalRegistry; + + + /** access the globally valid registry instance. + * @throw error::State if this global registry is + * already closed or not yet initialised. */ +//ModelPortRegistry& +//ModelPortRegistry::globalInstance() +//{ +// LockRegistry global_lock; +// if (theGlobalRegistry.isValid()) +// return theGlobalRegistry(); +// +// throw error::State ("global model port registry is not accessible" +// , LUMIERA_ERROR_BUILDER_LIFECYCLE); +//} + + + + /** */ +// bool +// ModelPortRegistry::contains (ID key) const +// { +// return bool(key) +// && util::contains (transaction_, key); +// } + + + +//LUMIERA_ERROR_DEFINE (DUPLICATE_MODEL_PORT, "Attempt to define a new model port with an pipe-ID already denoting an existing port"); + + + +}}// namespace mobject::builder diff --git a/src/proc/mobject/builder/segmentation.hpp b/src/proc/mobject/builder/segmentation.hpp new file mode 100644 index 000000000..c3c73249c --- /dev/null +++ b/src/proc/mobject/builder/segmentation.hpp @@ -0,0 +1,87 @@ +/* + SEGMENTATION.hpp - partitioning the effective timeline + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +/** @file segmentation.hpp + ** Part of the Fixture datastructure to manage time segments of constant structure. + ** The Fixture is result of the build process and separation between high-level and + ** low-level model. It's kind of an effective resulting timeline, and split into segments + ** of constant wiring structure: whenever the processing nodes need to be wired differently + ** for some timespan, we start a new segment of the timeline. This might be for the duration + ** of a clip, or just for the duration of a transition, when the pipes of both clips need to + ** be wired up in parallel. + ** + ** @see Fixture + ** @see ModelPort + */ + + +#ifndef PROC_MOBJECT_BUILDER_SEGMENTATION_H +#define PROC_MOBJECT_BUILDER_SEGMENTATION_H + +#include "lib/error.hpp" +//#include "lib/optional-ref.hpp" +#include "proc/asset/pipe.hpp" +//#include "proc/asset/struct.hpp" +//#include "proc/mobject/model-port.hpp" + +//#include + +namespace mobject { +namespace builder { + + using asset::ID; + using asset::Pipe; +//using asset::Struct; + +//LUMIERA_ERROR_DECLARE (DUPLICATE_MODEL_PORT); ///< Attempt to define a new model port with an pipe-ID already denoting an existing port + + + /** + * TODO type comment + */ + class Segment + : boost::noncopyable + { + + typedef ID PID; +// typedef ID StID; + + public: + + }; + + + + + /** + * TODO type comment + */ + class Segmentation + { + + public: + }; + + + +}} // namespace mobject::builder +#endif diff --git a/src/proc/mobject/builder/segmentationtool.hpp b/src/proc/mobject/builder/segmentationtool.hpp deleted file mode 100644 index 2b88f572a..000000000 --- a/src/proc/mobject/builder/segmentationtool.hpp +++ /dev/null @@ -1,80 +0,0 @@ -/* - SEGMENTATIONTOOL.hpp - Tool for creating a partitioning of the current timeline - - Copyright (C) Lumiera.org - 2008, Hermann Vosseler - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - -*/ - - -#ifndef MOBJECT_BUILDER_SEGMENTATIONTOOL_H -#define MOBJECT_BUILDER_SEGMENTATIONTOOL_H - - -#include "proc/mobject/builder/applicable-builder-target-types.hpp" - -#include "proc/mobject/session/segmentation.hpp" -#include "proc/mobject/session/fixture.hpp" //////TODO really on the header?? - - -#include -using std::list; - - - -namespace mobject { - namespace builder { - - - /** - * Tool implementation for deriving a partitioning of the current - * timeline, such that each Segment has a constant configuration. - * "Constant" means here, that any remaining changes over time - * can be represented by automation solely, without the need - * to change the node connections. - */ - class SegmentationTool - : public ApplicableBuilderTargetTypes - { - - public: - SegmentationTool (session::Fixture &) ; - - void treat (mobject::session::Clip& clip) ; - void treat (mobject::session::Effect& effect) ; - - void treat (mobject::Buildable& something) ; - - void onUnknown (Buildable& target) ; /////////TODO why doesn't the treat(Buildable) function shadow this?? - - bool empty() const; - - private: - typedef mobject::session::Segment Segment; - - /** Partitioning of the Timeline to be created by this tool. */ - //session::Segmentation& segments_; - ///////////////////////////////////////////TODO: either put it inline, or use a scopend_ptr!!!!!!!!!! - - }; - - - - } // namespace mobject::builder - -} // namespace mobject -#endif diff --git a/src/proc/mobject/builder/toolfactory.hpp b/src/proc/mobject/builder/toolfactory.hpp index b283bea60..e17687ad4 100644 --- a/src/proc/mobject/builder/toolfactory.hpp +++ b/src/proc/mobject/builder/toolfactory.hpp @@ -25,7 +25,7 @@ #define MOBJECT_BUILDER_TOOLFACTORY_H #include "proc/mobject/session/fixture.hpp" -#include "proc/mobject/builder/segmentationtool.hpp" +#include "proc/mobject/builder/segmentation-tool.hpp" #include "proc/mobject/builder/nodecreatortool.hpp" #include "proc/mobject/builder/mould.hpp" #include "proc/engine/rendergraph.hpp" diff --git a/tests/44builder.tests b/tests/44builder.tests index f54364132..c5d20d870 100644 --- a/tests/44builder.tests +++ b/tests/44builder.tests @@ -15,6 +15,11 @@ PLANNED "BuildSegment_test" BuildSegment_test < + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +#include "lib/test/run.hpp" +#include "lib/test/test-helper.hpp" +#include "proc/mobject/builder/fixture-change-detector.hpp" +#include "proc/asset/timeline.hpp" +#include "proc/asset/pipe.hpp" +#include "lib/query.hpp" +#include "lib/util.hpp" + + +namespace mobject { +namespace builder { +namespace test { + +// using util::isSameObject; +// using util::isnil; +// + using asset::Pipe; + using asset::PPipe; + using asset::Struct; + using asset::Timeline; + using asset::PTimeline; + using lumiera::Query; +// + typedef asset::ID PID; + typedef asset::ID TID; +// +// typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor; + + + namespace { // test environment + + inline PID + getPipe (string id) + { + return Pipe::query("id("+id+")"); + } + + inline TID + getTimeline (string id) + { + return asset::Struct::retrieve (Query ("id("+id+")"))->getID(); + } + + struct TestContext + { + + /** setup */ + TestContext() + { } + + /** tear-down */ + ~TestContext() + { + } + }; + } + + + + + /********************************************************************************* + * @test TODO blubb + * + * @see mobject::builder::FixtureChangeDetector + */ + class FixtureChangeDetector_test : public Test + { + + virtual void + run (Arg) + { + TestContext ctx; + } + + + void + fabricating_ModelPorts () + { + } + + + }; + + + /** Register this test class... */ + LAUNCHER (FixtureChangeDetector_test, "unit builder"); + + + +}}} // namespace mobject::builder::test diff --git a/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp b/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp new file mode 100644 index 000000000..ac6c66d30 --- /dev/null +++ b/tests/components/proc/mobject/builder/segmentation-datastructure-test.cpp @@ -0,0 +1,113 @@ +/* + SegmentationDatastructure(Test) - verify basic properties of the Segmentation + + Copyright (C) Lumiera.org + 2010, Hermann Vosseler + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +* *****************************************************/ + + +#include "lib/test/run.hpp" +#include "lib/test/test-helper.hpp" +#include "proc/mobject/builder/fixture-change-detector.hpp" +#include "proc/asset/timeline.hpp" +#include "proc/asset/pipe.hpp" +#include "lib/query.hpp" +#include "lib/util.hpp" + + +namespace mobject { +namespace builder { +namespace test { + +// using util::isSameObject; +// using util::isnil; +// + using asset::Pipe; + using asset::PPipe; + using asset::Struct; + using asset::Timeline; + using asset::PTimeline; + using lumiera::Query; +// + typedef asset::ID PID; + typedef asset::ID TID; +// +// typedef ModelPortRegistry::ModelPortDescriptor const& MPDescriptor; + + + namespace { // test environment + + inline PID + getPipe (string id) + { + return Pipe::query("id("+id+")"); + } + + inline TID + getTimeline (string id) + { + return asset::Struct::retrieve (Query ("id("+id+")"))->getID(); + } + + struct TestContext + { + + /** setup */ + TestContext() + { } + + /** tear-down */ + ~TestContext() + { + } + }; + } + + + + + /********************************************************************************* + * @test TODO blubb + * + * @see mobject::builder::FixtureChangeDetector + */ + class SegmentationDatastructure_test : public Test + { + + virtual void + run (Arg) + { + TestContext ctx; + } + + + void + fabricating_ModelPorts () + { + } + + + }; + + + /** Register this test class... */ + LAUNCHER (SegmentationDatastructure_test, "unit builder"); + + + +}}} // namespace mobject::builder::test diff --git a/wiki/renderengine.html b/wiki/renderengine.html index 6d8c87fce..5837913f4 100644 --- a/wiki/renderengine.html +++ b/wiki/renderengine.html @@ -1728,8 +1728,12 @@ To make the intended use of the classes more clear, consider the following two e 
a special ProcNode which is used to pull the finished output of one Render Pipeline (Tree or Graph). This term is already used in the Cinelerra2 codebase. I am unsure at the moment if it is a distinct subclass or rahter a specially configured ProcNode (a general design rule tells us to err in favour of the latter if in doubt).
-
-
A special kind (subclass) of [[Placement]]. As such it is always linked to a //Subject//, i.e. a MObject. But contrary to the (standard) placements, which may exhibit all kinds of fancy dynamic and scope dependent behaviour, within an explicit placement all properties are resolved and materialised. While the (standard) placement may contain an arbitrary list of LocatingPin objects, the resolution into an explicit placement performs a kind of »orthogonalisation«: each remaining LocatingPin defines exactly one degree of freedom independent of all others. Most notably, the explicit placement always specifies a absolute time and [[output designation|OutputDesignation]] for for locating the Subject.
+

+
A special kind (subclass) of [[Placement]]. As such it is always linked to a //Subject//, i.e. a MObject. But contrary to the (standard) placements, which may exhibit all kinds of fancy dynamic and scope dependent behaviour, within an explicit placement all properties are resolved and materialised. While the (standard) placement may contain an arbitrary list of LocatingPin objects, the resolution into an explicit placement performs a kind of »orthogonalisation«: each remaining LocatingPin defines exactly one degree of freedom independent of all others. Most notably, the explicit placement always specifies a absolute time and [[output designation|OutputDesignation]] for for locating the Subject. Explicit placements are ''immutable''.
+
+!!Implementation considerations
+Explicit placements are just created and never mutated, but copying and storage might become a problem.
+It would thus be desirable to have a fixed-sized allocation, able to hold the placement body as well as the (fixed) locating pins inline.
 

 

 

@@ -4675,6 +4679,44 @@ We need to detect attaching and detaching of
 * root &harr; [[Track]]
+
+
//Segmentation of timeline// denotes a data structure and a step in the BuildProcess.
+When [[building the fixture|BuildFixture]], ~MObjects -- as handled by their Placements -- are grouped below each timeline using them; Placements are then to be resolved into [[explicit Placements|ExplicitPlacement]], resulting in a single well defined time interval for each object. This allows to cut this effective timeline into slices of constant wiring structure, which are represented through the ''Segmentation Datastructure'', a time axis with segments holding object placements and [[exit nodes|ExitNode]]. &nbsp;&rarr; see [[structure of the Fixture|Fixture]]
+* for each Timeline we get a Segmentation
+** which in turn is a list of non-overlapping segments
+*** each holding
+**** an ExplicitPlacement for each covered object
+**** an ExitNode for each ModelPort of the corresponding timeline
+
+!Storage considerations
+;(1) build process
+:&rarr; a tree walk yields the placements per timeline, which then get //resolved//
+:&rarr; after //sorting,// the segmentation can be established, thereby copying placements spanning multiple segments
+:&rarr; only //after running the complete build process for each segment,// the list of model ports and exit nodes can be established
+;(2) commit stage
+: -- after the build process(es) are completed, the new fixture gets ''committed'', thus becoming the officially valid state to be rendered. As render processes might be going on in parallel, some kind of locking or barrier is required. It seems advisable to make the change into a single atomic hot-swap. Meaning we'd get a single access point to be protected. But there is another twist: We need to find out which render processes to cancel an restart, to pick up the changes introduced by this build process, which might include adding and deleting of timelines as a whole, and any changes to the segmentation grid. Because of the highly dynamic nature of the placements, on the other hand it isn't viable to expect the high-level model to provide this information. Thus we need to find out about a ''change coverage'' at this point. We might expand on that idea to //prune any new segments which aren't changed.// This way, only a write barrier would be necessary on switching the actually changed segments, and any render processes touching these would be //tainted.// Old allocations could be released after all tainted processes are known to be terminated.
+;(3) rendering use
+:Each play/render process employs a ''frame dispatch step'' to get the right exit node for pulling a given frame. From there on, the process proceeds into the [[processing nodes|ProcNodes]], interleaved with backend/scheduler actions due to splitting into individually scheduled jobs. The storage of these processing nodes and accompanying wiring descriptors is hooked up behind the individual segments, by sharing a common {{{AllocationCluster}}}. Yet the calculation of individual frames also depends on ''parameters'' and especially ''automation'' connected with objects in the high-level model. It is likely that there might be some sharing, as the intention was to allow ''live changes'' to automated values. <br/>{{red{WIP 12/2010}}} details need to be worked out. &rarr; [[parameter wiring concept|Wiring]]
+!!!observations
+* Storage and initialisation for explicit placements is an issue. We should strive at making that inline as much as possible.
+* the overall segmentation emerges from a sorting of time points, which are start points of explicit placements
+* after the segmentation has been built, the usage pattern changes entirely into a lookup of segment by time
+* the individual segments act as umbrella for a lot of further objects hooked up behind.
+* we need the ability to exchange or swap-in whole segments
+* each segment controls an AllocationCluster
+* we need to track processes for tainting
+* access happens per ModelPort
+
+!!!conclusions
+The Fixture is mostly comprised of the Segementation datastructure, but some other facilities are involved too
+# at top level, we need somehow to organise access per groups of model ports, actually grouped by timeline
+# during the build process, there is a collection of placements; this can be discarded afterwards
+# the backbone of the segmentation is closely linked to an ordering by time. Initially it should support sorting, access by time interval search later on.
+# discarding a segment (or failing to do so) has an high impact on the whole application. We should employ a reliable mechanism for that.
+# the frame dispatch and the tracking of processes can be combined; data duplication is a virtue when it comes to parallel processes
+# the process of comparing and tainting is broken out into a separate data structure to be used just once
+
+
A sequence is a collection of media objects, arranged onto a track tree. Sequences are the building blocks within the session. To be visible and editable, a session needs to be bound into a top-level [[Timeline]]. Alternatively, it may be used as a VirtualClip nested within another sequence.