V3 Prototype Project

contains:

• OpenTime math library
  • Topologies
  • Curve library
    • Bezier Curves
    • Linear curves
• Visualizer apps
  • Wrinkles app for visualizing frequency domain "plaid" charts
  • otvis, pyguitest for looking at curves/curve projections
• OpenTimelineIO prototype library
  • parse .otio files and project through them
  • treecode library (path through a binary tree)

• Find the two or three point projection approximation

• Add the graph to the ui

• thread the duals through findU

• todo:

  • derivative with dual at u = 0
  • using the derivative in the projection
  • testing the 2 point approximation using computed derivatives
  • show derivatives on linearized curves
  • show derivatives on projected curves / projected curve imagine settings

• hododromes

  • 0 finding over cubic bezier
  • non-linearizing bezier projection
  • non-linearizing bezier.affine projection
  • non-linearizing affine.bezier projection
  • non-linearizing bezier inversion
  • arbitrary (splitting) inversion

• add back in linear and bezier curve topologies
  • with linearizing
  • add hododrome decomposition to bezier/bezier projection
• project_topology in the projection operator (whoops)
• replacing f32 with opentime.Ordinate
  • struct/union with add/mul/div/sub
  • rational object as an entry in the union (i32/i32)
• sampling
• domains (how do you handle that you want to evaluate the timeline at 30fps?)
• transitions

• schema design
• graphviz viewer for otio files
  • plain format (dot -Tplain) produces a parsable output
  • visualize graph transformations over a topology with different targets
• redesign the opentimelineio layer
  • clean up mess of Item and ItemPtr
  • Allocators should be exposed as parameters, not through allocator.ALLOCATOR
  • project_curve and so on should be !TimeCurve, not use catch unreachable everywhere
• move to zig v0.11 and bump deps
• topology->[]topology projection (for handling inversions)
• time-varying parameters
• time-varying metadata

• Zig Lang: The language homepage
• Zig Learn: Good starting place for a language overview
• Language Reference: Full Language Reference
• Stdlib Reference
• Stdlib Source: I hate to admit it but often times its faster to just look at the source of the standard lib rather than going through the docs

• support arbitrary path lengths

  • use an array list of u128 to encode arbitrarily long paths

• arbitrary TopologicalPathHash lengths

• fix the simple_cut

• JSON OTIO parsing

  • can parse small OTIO files (but because of path length constraints, can't build maps for large files)

• Right now the topology has bounds, transform and curves. This is inconsistent because the curves inside the topology also represent a transformation, and implicitly define bounds (in that they're finite lists of segments, which are bounded). The math reflects this - the way that transform and boundary are applied is pretty inconsistent.

• Part of the reason why this is the case is that there are several special cases of topology in play:

  • infinite identity (could have a transform but no bounds)
  • finite segments (do they have bounds?)
  • empty

Two options:

• do what we did for the graph and define a set of operators that bundle up a topology and work through the cases, providing clean constructors for those useful special types

• break these features up into things that the topology can contain and localize the math, push the matrix into handling combinations of those child types

• Stacks

• Timeline

• Gap (fully)

• how hard would parsing OTIO JSON be? Would be cool to read in real timeilines and do transformations there

• need to add inversion functions to the topologies
• add error when a function isn't trivially invertible
• if we do something with the mappings, when things aren't trivially invertible, we still know how to invert them and how the mapping functions. Can we exploit this? Or is the juice not worth the squeeze for this project

• MxN track related time stuff - the map should cache those kinds of intermediates
• Can the map also cache optimizations like linearizing curves?

const Ordinate = union(enum) {
    f32: f32,
    rational: rational,

    // math
    pub fn add() Ordinate {}
    pub fn addWithOverflow() Ordinate {}
    pub fn sub() Ordinate {}
    pub fn subWithOverflow() Ordinate {}
    pub fn mul() Ordinate {}
    pub fn mulWithOverflow() Ordinate {}
    pub fn divExact() Ordinate {}
    pub fn divFloor() Ordinate {}
    pub fn divTrunc() Ordinate {}

    pub fn to_float() f32 {}
};