get value at time for a path created by spline-path-new.
returns a zero vector for gaps and before or after the path

uses spline-path-fast

add one or more spline-paths as a path segment to the end of path a

return a new path that is a combination of the given paths.
each point of path is combined by f for each dimension.
example that sums three paths: (spline-path-combine + path1 path2 path3)

convert a spline-path-new config to the internally used more generic config where points
and arguments are at predictable places

convert the first point values which are point-relative distances to path-relative offsets

convert the first point values which are path-relative offets to point-relative distances

create a path that always returns the same values. the first time dimension is still updated.
equivalent to (sp-path-new* (constant (0 a ...)))

true if path uses a single constant segment and the path never changes

bypasses all mappers and only works if time is on path.
about 10% faster

true if the path has infinite length

return :: generic-config mapper-config -> spline-path
create a new path with parameters mapped by f.
example: (spline-path-map-config path (lambda (config mapper c) (c config mapper)))

return a new path with specified modifications.
# keys
randomise: boolean/random-state
repeat: boolean/number (experimental)
reverse: boolean
scale: false/number:factor
shift: false/number:amount
stretch: false/number:to-end
deep: with reverse or randomise: apply to paths as segments as well
mapper-add: ((symbol:id false/procedure:input false/procedure:output custom-info ...) ...)
mapper-remove: id/(id ...)
# example
(spline-path-modify path #:reverse #t #:randomise (random-state-from-platform)
#:scale 0.2 #:stretch (* 2 (spline-path-end path)))

the returned object is to be passed to spline-path to get points on a path between
given points interpolated by selected functions. similar to the path element of svg vector graphics.
points in the given segment configuration are relative to the start of the path.
point: (number:dimension ...)
# dimensions
* the number of dimensions must be equal between all segments
* all interpolators support an unlimited number of dimensions except for arc, which is 2d only
# segments
* the given segments describe the endpoints as in \"line to\" or \"move to\"
* at least one segment must be given
# segment types
## syntax
* (move point)
* (line point point ...)
* (bezier point ...)
* (catmull-rom point point ...)
* (catmull-rom-tension tension point point ...)
* (arc (x y):point radius-x [radius-y rotation large-arc sweep])
* (custom-simple point:end/(point ...) f custom-arguments ...)
* (custom point/(point ...) f custom-arguments ...)
* (path spline-path ...)
## move
* move can be given as the first element to start the path at this point
* move can also be used to create gaps
## constant
* describes a flat line to t(infinity)
* infinitely repeats the values of all dimensions except the first time dimension
* the optional point argument is a move
* not useful inbetween segments as the next segment is never reached
## path
* segments can be paths
* this can be used to append multiple paths
## custom
* calls a procedure that should return segments
* additional config arguments are passed on
* segment: #(point:start point:end procedure:{t -> point})
* f :: preceeding-segments following-config points custom-argument ... -> (segment ...)
* f :: (vector ...) (list ...) (point ...) any ... -> (vector ...)
# mapping
* an arbitrary number of procedures can be installed that are called either for the input to spline-path or the output
* this allows for interesting transformations like dynamic time stretches, value scaling or path combination
* the mapper support allows paths to be sampled using spline-path
* the mapper argument is a list with mapper config elements
* mapper config elements are (symbol:key false/procedure:{t -> t}:input false/procedure:{point -> point}:output any:custom-info ...)
* key is a custom symbol except \"repeat\", which is used internally.
* input and output mapper procedures are optional
* the collection of all active mappers will be accessible in the path object with spline-path-mapper-config.
* the active mapper list will be created from the mapper config
# other
* the catmull-rom interpolation is always centripetal
* custom-simple takes a procedure (t points any:custom ... -> point)
* for \"arc\" see how arcs are created with svg
# example
(spline-path-new* (move (20 0)) (line (20 0.25) (10 0.4)))

new spline path object from generic-config.
spline-path always gives a point with the time value to output mapper that was originally passed to spline-path,
so that input mapper can change it and the output will have the users requested time.
having mappers in a separate config makes internally used mappers easier to replace and subsequently added user mappers manageable