This is the flare Reference Manual, version 1.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Jul 13 20:24:23 2025 GMT+0.
flare/flare.asdflare/package.lispflare/toolkit.lispflare/queue.lispflare/indexed-set.lispflare/easings.lispflare/clock.lispflare/container.lispflare/paintable.lispflare/animation.lispflare/change.lispflare/parser.lispflare/scene.lispflare/forms.lispflare/documentation.lispThe main system appears first, followed by any subsystem dependency.
flareEasy particle systems with fine grained control.
Yukari Hafner <shinmera@tymoon.eu>
(GIT https://github.com/Shinmera/flare.git)
zlib
1.1.0
lambda-fiddle (system).
array-utils (system).
trivial-garbage (system).
3d-vectors (system).
documentation-utils (system).
for (system).
package.lisp (file).
toolkit.lisp (file).
queue.lisp (file).
indexed-set.lisp (file).
easings.lisp (file).
clock.lisp (file).
container.lisp (file).
paintable.lisp (file).
animation.lisp (file).
change.lisp (file).
parser.lisp (file).
scene.lisp (file).
forms.lisp (file).
documentation.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
flare/flare.asdflare/package.lispflare/toolkit.lispflare/queue.lispflare/indexed-set.lispflare/easings.lispflare/clock.lispflare/container.lispflare/paintable.lispflare/animation.lispflare/change.lispflare/parser.lispflare/scene.lispflare/forms.lispflare/documentation.lispflare/toolkit.lisppackage.lisp (file).
flare (system).
define-self-returning-method (macro).
ensure-sorted (function).
flare/queue.lisptoolkit.lisp (file).
flare (system).
cell (structure).
cell-insert-after (function).
cell-insert-before (function).
cell-remove (function).
cell-tie (function).
clear-queue (function).
coerce-queue (function).
(setf current) (method).
dequeue (function).
do-queue (macro).
enqueue (function).
has-more (method).
in-queue-p (function).
initialize-instance (method).
left (reader).
(setf left) (writer).
make-cell (function).
make-iterator (method).
make-queue (function).
map-queue (function).
next (method).
print-object (method).
print-object (method).
queue (class).
queue-first (function).
queue-index-of (function).
queue-last (function).
queue-remove (function).
queue-size (function).
queue-value-at (function).
(setf queue-value-at) (function).
remove-cells (function).
right (reader).
(setf right) (writer).
step-functions (method).
value (reader).
(setf value) (writer).
head (reader method).
(setf head) (writer method).
queue-iterator (class).
set-size (writer method).
size (reader method).
tail (reader method).
tail (reader method).
(setf tail) (writer method).
(setf tail) (writer method).
flare/indexed-set.lispqueue.lisp (file).
flare (system).
coerce-set (function).
in-set-p (function).
indexed-set (class).
make-indexed-set (function).
set-add (function).
set-add-after (function).
set-add-before (function).
set-remove (function).
set (reader method).
(setf set) (writer method).
flare/easings.lispindexed-set.lisp (file).
flare (system).
define-easing (macro).
ease (compiler macro).
ease (function).
ease-object (generic function).
easing (function).
(setf easing) (function).
remove-easing (function).
*ease-docs* (special variable).
*easings* (special variable).
flare/clock.lispeasings.lisp (file).
flare (system).
clock (generic reader).
(setf clock) (writer method).
clock (class).
describe-object (method).
print-object (method).
reset (generic function).
running (generic reader).
(setf running) (writer method).
start (generic function).
stop (generic function).
synchronize (generic function).
timescale (generic function).
update (generic function).
flare/container.lispclock.lisp (file).
flare (system).
clear (generic function).
container (class).
container-unit (class).
deregister (generic function).
describe-object (method).
do-container-tree (macro).
enter (generic function).
initialize-instance (method).
initialize-instance (method).
leave (generic function).
make-iterator (method).
map-container-tree (function).
name (generic reader).
name-map (generic reader).
(setf name-map) (writer method).
objects (generic reader).
(setf objects) (writer method).
paint (method).
print-container-tree (function).
print-object (method).
print-object (method).
print-object (method).
register (generic function).
scene-graph (generic reader).
(setf scene-graph) (writer method).
(setf scene-graph) (method).
(setf scene-graph) (method).
scene-graph (class).
unit (generic function).
(setf unit) (method).
unit (class).
units (generic function).
update (method).
flare/paintable.lispcontainer.lisp (file).
flare (system).
call-with-translation (generic function).
paint (generic function).
paintable (class).
target (class).
visibility (generic reader).
(setf visibility) (writer method).
with-translation (macro).
flare/animation.lisppaintable.lisp (file).
flare (system).
add-progression (generic function).
animatable (reader method).
(setf animatable) (writer method).
animatable (class).
animation (class).
animations (generic reader).
(setf animations) (method).
(setf animations) (writer method).
(setf animations) (method).
beginning (generic reader).
(setf beginning) (writer method).
changes (generic reader).
(setf changes) (writer method).
(setf clock) (method).
duration (generic reader).
(setf duration) (writer method).
enter (method).
enter (method).
future-animations (generic reader).
(setf future-animations) (writer method).
initialize-instance (method).
initialize-instance (method).
instances (generic reader).
(setf instances) (writer method).
leave (method).
past-animations (generic reader).
(setf past-animations) (writer method).
present-animations (generic reader).
(setf present-animations) (writer method).
print-object (method).
print-object (method).
progression (generic function).
progression (class).
progression-definition (class).
progression-instance (generic function).
progressions (generic reader).
(setf progressions) (writer method).
remove-progression (generic function).
reset (method).
reset (method).
reset (method).
selector (generic reader).
(setf selector) (writer method).
tick (generic function).
update (method).
update (method).
*resetting* (special variable).
animation< (function).
animation> (function).
copy (generic function).
copy-animations (function).
defindex (reader method).
(setf defindex) (writer method).
definition (reader method).
(setf definition) (writer method).
format-progression (function).
shift-array-elements (function).
simulate-progression (function).
flare/change.lispanimation.lisp (file).
flare (system).
call-accessor-tween (class).
call-change (class).
call-slot-tween (class).
change (class).
constant-tween (class).
creator (reader method).
(setf creator) (writer method).
define-change-parser (macro).
enter-operation (class).
increase-slot-tween (class).
leave-operation (class).
objects (reader method).
objects (reader method).
(setf objects) (writer method).
(setf objects) (writer method).
operation (class).
original-value (generic function).
originals (reader method).
originals (reader method).
(setf originals) (writer method).
(setf originals) (writer method).
print-change (class).
range-slot-tween (class).
range-tween (class).
reset (method).
reset (method).
reset (method).
reset (method).
reset (method).
reset (method).
slot (reader method).
(setf slot) (writer method).
slot-tween (class).
start (reader method).
(setf start) (writer method).
tick (method).
tick (method).
tick (method).
tick (method).
tick (method).
tick (method).
tween (class).
accessor (reader method).
(setf accessor) (writer method).
accessor-tween (class).
by (reader method).
(setf by) (writer method).
copy (method).
copy (method).
copy (method).
copy (method).
copy (method).
copy (method).
copy (method).
ease-func (reader method).
(setf ease-func) (writer method).
for (reader method).
(setf for) (writer method).
from (reader method).
(setf from) (writer method).
func (reader method).
(setf func) (writer method).
increase-accessor-tween (class).
parse-change (generic function).
range-accessor-tween (class).
to (reader method).
(setf to) (writer method).
tween-value (generic function).
flare/parser.lispchange.lisp (file).
flare (system).
define-progression (macro).
progression-definition (function).
(setf progression-definition) (function).
progression-instance (method).
remove-progression-definition (function).
*animation-defindex* (special variable).
*i* (special variable).
*mapper* (special variable).
*progressions* (special variable).
compile-animations (macro).
compile-change (macro).
compile-constraint (function).
compile-selector (function).
designator-p (function).
interval-designator (type).
parse-animation (function).
parse-intervals (function).
flare/scene.lispparser.lisp (file).
flare (system).
entity (class).
location (generic reader).
(setf location) (writer method).
scene (class).
flare/forms.lispscene.lisp (file).
flare (system).
angle (generic reader).
(setf angle) (writer method).
(setf angle) (method).
arc (class).
formation (class).
initialize-instance (method).
(setf location) (method).
orientation (generic reader).
(setf orientation) (method).
(setf orientation) (writer method).
oriented-entity (class).
particle (class).
print-object (method).
ring (class).
size (generic reader).
(setf size) (method).
(setf size) (writer method).
sized-entity (class).
spacing (generic reader).
(setf spacing) (writer method).
(setf spacing) (method).
up (generic reader).
(setf up) (writer method).
(setf up) (method).
insert (method).
reposition (generic function).
tangent (reader method).
(setf tangent) (writer method).
withdraw (method).
flare/documentation.lispforms.lisp (file).
flare (system).
Packages are listed by definition order.
flareorg.shirakumo.flare
3d-vectors.
common-lisp.
flare-indexed-set.
flare-queue.
add-progression (generic function).
angle (generic reader).
(setf angle) (generic function).
animatable (generic reader).
(setf animatable) (generic writer).
animatable (class).
animation (class).
animations (generic reader).
(setf animations) (generic function).
arc (class).
beginning (generic reader).
(setf beginning) (generic writer).
call-accessor-tween (class).
call-change (class).
call-slot-tween (class).
call-with-translation (generic function).
change (class).
changes (generic reader).
(setf changes) (generic writer).
clear (generic function).
clock (generic reader).
(setf clock) (generic function).
clock (class).
constant-tween (class).
container (class).
container-unit (class).
creator (generic reader).
(setf creator) (generic writer).
define-change-parser (macro).
define-easing (macro).
define-progression (macro).
deregister (generic function).
do-container-tree (macro).
duration (generic reader).
(setf duration) (generic writer).
ease (compiler macro).
ease (function).
ease-object (generic function).
easing (function).
(setf easing) (function).
enter (generic function).
enter-operation (class).
entity (class).
formation (class).
future-animations (generic reader).
(setf future-animations) (generic writer).
increase-slot-tween (class).
instances (generic reader).
(setf instances) (generic writer).
leave (generic function).
leave-operation (class).
location (generic reader).
(setf location) (generic function).
map-container-tree (function).
name (generic reader).
name-map (generic reader).
(setf name-map) (generic writer).
objects (generic reader).
(setf objects) (generic writer).
operation (class).
orientation (generic reader).
(setf orientation) (generic function).
oriented-entity (class).
original-value (generic function).
originals (generic reader).
(setf originals) (generic writer).
paint (generic function).
paintable (class).
particle (class).
past-animations (generic reader).
(setf past-animations) (generic writer).
present-animations (generic reader).
(setf present-animations) (generic writer).
print-change (class).
print-container-tree (function).
progression (generic function).
progression (class).
progression-definition (function).
(setf progression-definition) (function).
progression-definition (class).
progression-instance (generic function).
progressions (generic reader).
(setf progressions) (generic writer).
range-slot-tween (class).
range-tween (class).
register (generic function).
remove-easing (function).
remove-progression (generic function).
remove-progression-definition (function).
reset (generic function).
ring (class).
running (generic reader).
(setf running) (generic writer).
scene (class).
scene-graph (generic reader).
(setf scene-graph) (generic function).
scene-graph (class).
selector (generic reader).
(setf selector) (generic writer).
size (generic reader).
(setf size) (generic function).
sized-entity (class).
slot (generic reader).
(setf slot) (generic writer).
slot-tween (class).
spacing (generic reader).
(setf spacing) (generic function).
start (generic function).
(setf start) (generic writer).
stop (generic function).
synchronize (generic function).
target (class).
tick (generic function).
timescale (generic function).
tween (class).
unit (generic function).
(setf unit) (generic function).
unit (class).
units (generic function).
up (generic reader).
(setf up) (generic function).
update (generic function).
visibility (generic reader).
(setf visibility) (generic writer).
with-translation (macro).
*animation-defindex* (special variable).
*ease-docs* (special variable).
*easings* (special variable).
*i* (special variable).
*mapper* (special variable).
*progressions* (special variable).
*resetting* (special variable).
accessor (generic reader).
(setf accessor) (generic writer).
accessor-tween (class).
animation< (function).
animation> (function).
by (generic reader).
(setf by) (generic writer).
compile-animations (macro).
compile-change (macro).
compile-constraint (function).
compile-selector (function).
copy (generic function).
copy-animations (function).
defindex (generic reader).
(setf defindex) (generic writer).
define-self-returning-method (macro).
definition (generic reader).
(setf definition) (generic writer).
designator-p (function).
ease-func (generic reader).
(setf ease-func) (generic writer).
ensure-sorted (function).
for (generic reader).
(setf for) (generic writer).
format-progression (function).
from (generic reader).
(setf from) (generic writer).
func (generic reader).
(setf func) (generic writer).
increase-accessor-tween (class).
insert (generic function).
interval-designator (type).
parse-animation (function).
parse-change (generic function).
parse-intervals (function).
range-accessor-tween (class).
reposition (generic function).
shift-array-elements (function).
simulate-progression (function).
tangent (generic reader).
(setf tangent) (generic writer).
to (generic reader).
(setf to) (generic writer).
tween-value (generic function).
withdraw (generic function).
flare-indexed-setorg.shirakumo.flare.indexed-set
common-lisp.
flare-queue.
clear-set (function).
coerce-set (function).
do-set (macro).
in-set-p (function).
indexed-set (class).
make-indexed-set (function).
map-set (function).
set-add (function).
set-add-after (function).
set-add-before (function).
set-first (function).
set-index-of (function).
set-last (function).
set-remove (function).
set-size (function).
set-value-at (function).
(setf set-value-at) (function).
set (generic reader).
(setf set) (generic writer).
flare-queueorg.shirakumo.flare.queue
common-lisp.
for.
cell (structure).
cell-insert-after (function).
cell-insert-before (function).
cell-remove (function).
cell-tie (function).
clear-queue (function).
coerce-queue (function).
dequeue (function).
do-queue (macro).
enqueue (function).
in-queue-p (function).
left (reader).
(setf left) (writer).
make-cell (function).
make-queue (function).
map-queue (function).
queue (class).
queue-first (function).
queue-index-of (function).
queue-last (function).
queue-remove (function).
queue-size (function).
queue-value-at (function).
(setf queue-value-at) (function).
remove-cells (function).
right (reader).
(setf right) (writer).
value (reader).
(setf value) (writer).
head (generic reader).
(setf head) (generic writer).
queue-iterator (class).
set-size (generic writer).
size (generic reader).
tail (generic reader).
(setf tail) (generic writer).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Define a parser for the given type of change.
Shorthand macro to define an easing function.
See EASING
Convenience macro to define a global progression.
Returns the progression name.
The formal specification of the body intervals is as follows:
body ::= interval*
interval ::= start [end] animation*
animation ::= (selector change*)
change ::= (change-type argument*)
start — A real (in seconds) that represents the starting time
of the animations
end — A leal (or T, indicating infinity) that represents the
ending time of the animations
selector — A valid selector as per COMPILE-SELECTOR
change — A valid change as per COMPILE-CHANGE
If the END is not specified for a given interval, then the next START
is taken as the end. If no next start exists, then the end is T. In order
to allow brevity, multiple animations can be specified between two time
codes. This is then normalised into the strict form of
(START DURATION ANIMATION) as per PARSE-INTERVALS.
An example definition follows:
(define-progression foo
0 (T (enter ring :name :ring :contents (bullet :size 2 :count 20)))
0 8 (:ring (increase size :by 2))
0 20 (:ring (set angle :to 1000 :ease ’quad-in-out))
((:ring >) (set size :to 50))
20 (:ring (leave)))
At time 0, a ring is created with name :ring and 20 bullets of size 2 as
its children. It is entered into the scene-graph. Then from time 0 to 8,
the ring’s size is increased by 2 every second. Simultaneously from time
0 to 20 the ring’s angle is increased to 1000, eased by the quad-in-out
interpolation and the ring’s children (the 20 bullets) increase in size
to 50. At time 20, the ring is removed from the scene-graph again.
See PROGRESSION-DEFINITION
See COMPILE-ANIMATIONS
Iterates over all descendants of CONTAINER
See MAP-CONTAINER-TREE
Iterates over each value in the queue in order.
See QUEUE
Iterates over all elements of the set in order.
See INDEXED-SET
Shorthand macro for translation.
See CALL-WITH-TRANSLATION
Inserts the cell after its neighbour, making sure to keep all links updated.
See CELL
Inserts the cell before its neighbour, making sure to keep all links updated.
See CELL
Removes the cell out of the link chain, making sure to keep all links updated.
Unless the cell is the only item in the link chain, its left/right slots are not
modified.
See CELL
Tie the two cells together so that they become adjacent.
See CELL
Removes all elements from the queue.
See QUEUE
Removes all values from the set.
See INDEXED-SET
Allows coercing the queue to:
queue, list, vector, or sequence.
See QUEUE
Allows coercing the set to:
indexed-set, hash-table, queue, list, vector, or sequence.
See INDEXED-SET
See COERCE-QUEUE
Pops the next value off the front of the queue.
The second value indicates whether there was any element in the queue at all.
See QUEUE
Shorthand function to perform an easing interpolation.
X must be a float between 0 and 1
BY must name an easing function
FROM and TO must be REALs specifying the boundaries of the easing.
Accessor to the easing function associated with the given name, if any.
See *EASINGS*
Inserts the given value at the end of the queue.
See QUEUE
Returns T if the given value is found in the queue.
See QUEUE
Returns T if the value is contained in the set.
See INDEXED-SET
Accesses the cell left to the current cell.
See CELL
left.
Constructs a new queue cell.
See CELL
Creates a new indexed set.
See INDEXED-SET
Creates a new queue instance.
See QUEUE
Recursively maps FUNCTION over all descendants of CONTAINER.
See CONTAINER
Maps the function over all values in the queue in order.
See QUEUE
Maps the function over all elements of the set in order.
See INDEXED-SET
Prints the entire CONTAINER tree hierarchy nicely to the given STREAM.
See CONTAINER
Accessor to the global progression definition by name.
See *PROGRESSIONS*
Returns the first (front) value in the queue if there is any.
The second value indicates whether there was any element in the queue at all.
See QUEUE
Returns the index of the value in the queue.
If the value could not be found, NIL is returned instead.
This is potentially very costly as it might have to scan the entire queue.
See QUEUE
Returns the last (end) value in the queue if there is any.
The second value indicates whether there was any element in the queue at all.
See QUEUE
Removes the given value from the queue.
This is potentially very costly as it might have to scan the entire queue.
See QUEUE
Returns the number of elements in the queue.
See QUEUE
Returns the value at the given position in the queue.
The second value is NIL if the position is out of range.
This is potentially very costly as it might have to scan the entire queue.
See QUEUE
Removes all cells between and including the given left and right cells.
Note that the consequences are undefined if the given left cell is actually to the
right of the right cell, or if they are from different queues entirely.
See CELL
Removes the easing function associated with the given name.
See *EASINGS*
Remove the global progression definition by name
See *PROGRESSIONS*
Accesses the cell right to the current cell.
See CELL
Add a new value to the set.
Returns two values, the value that was added, and whether it was added
as a new element to the set. If it already existed, the second value is
NIL.
See INDEXED-SET
Returns the first item in the set.
See INDEXED-SET
Returns the index of the value in the set.
See INDEXED-SET
Returns the last item in the set.
See INDEXED-SET
Remove a value from the set.
Returns two values, the set that was modified, and whether the value
existed in the set to begin with. If it did not, the second value is
NIL.
See INDEXED-SET
Returns the number of items in the set.
See INDEXED-SET
Returns the value at the given index in the set.
See INDEXED-SET
Accesses the value contained in a queue cell.
See CELL
Attach a new progression onto the animatable.
See PROGRESSION
See ANIMATABLE
progression-definition) (animatable animatable)) ¶progression) (animatable animatable)) ¶Accessor to the angle.
See ARC
Accessor to the animatable the progression is acting upon.
See PROGRESSION
progression)) ¶automatically generated reader method
progression)) ¶automatically generated writer method
Accessor to the vector of animations that the progression holds.
progression-definition)) ¶automatically generated reader method
progression)) ¶progression-definition)) ¶progression-definition)) ¶Accessor to the beginning (in seconds) at which the animation should start.
See ANIMATION
Call FUNC after having performed a translation on TARGET by VEC.
Accessor to the list of changes that the animation executes.
See ANIMATION
Removes all objects from the CONTAINER.
Returns the object given.
See CONTAINER
Accessor to the current time in the clock.
Note that the current time in the clock must not necessarily be 100% accurate.
In order to get perfectly accurate current time of the clock, you must call UPDATE
on it before retrieving its current time value with CLOCK.
See CLOCK
progression)) ¶Accessor to the function that upon calling instantiates one or more objects.
See ENTER-OPERATION
enter-operation)) ¶automatically generated reader method
enter-operation)) ¶automatically generated writer method
Deregisters the unit with the scene-graph, making it accessible by its name.
Any unit that leaves from any part of the scene-graph must be deregistered by this
function. This should happen automatically provided you use the CONTAINER-UNIT class
for containers inside the scene-graph. Thus you need not call this function unless
you implement your own container.
See UNIT
See SCENE-GRAPH
container-unit) (scene-graph scene-graph)) ¶unit) (scene-graph scene-graph)) ¶Accessor to the duration (in seconds) that the animation should be active for.
Can also be T, in which case the animation should go on forever.
See ANIMATION
Shorthand function to ease a range.
FROM and TO must be matching objects
By default works on REALs and VECs.
See EASE
Adds the given UNIT into the CONTAINER.
Returns the unit given.
See UNIT
See CONTAINER
progression-definition) (animatable animatable)) ¶progression) (animatable animatable)) ¶unit) (container container-unit)) ¶container-unit) (scene-graph scene-graph)) ¶unit) (scene-graph scene-graph)) ¶Accessor to the vector of animations that have yet to become activated after the current clock time.
See PROGRESSION
progression)) ¶automatically generated reader method
progression)) ¶automatically generated writer method
Accessor to all progression instances that were created from this definition.
See PROGRESSION-DEFINITION
progression-definition)) ¶automatically generated reader method
progression-definition)) ¶automatically generated writer method
Removes the given UNIT from the CONTAINER.
Returns the unit given.
See UNIT
See CONTAINER
progression) (animatable animatable)) ¶unit) (container container-unit)) ¶container-unit) (scene-graph scene-graph)) ¶unit) (scene-graph scene-graph)) ¶Accessor to the location of the entity.
See ENTITY
Reader to the name of the unit.
The name may be NIL.
See UNIT
Accessor to the name table of the scene-graph.
See SCENE-GRAPH
scene-graph)) ¶automatically generated reader method
scene-graph)) ¶automatically generated writer method
Accessor to a value that stores which objects are being managed.
leave-operation)) ¶automatically generated reader method
enter-operation)) ¶automatically generated reader method
leave-operation)) ¶automatically generated writer method
enter-operation)) ¶automatically generated writer method
Accessor to the vector that defines the orientation of the entity.
See ORIENTED-ENTITY
oriented-entity)) ¶automatically generated reader method
oriented-entity)) ¶automatically generated writer method
Returns the original value this object might have had before the given tween changed anything.
See TWEEN
accessor-tween)) ¶slot-tween)) ¶A hash table to store the original values of objects before they were changed.
accessor-tween)) ¶automatically generated reader method
slot-tween)) ¶automatically generated reader method
accessor-tween)) ¶automatically generated writer method
slot-tween)) ¶automatically generated writer method
Performs the necessary painting operations to draw PAINTABLE onto TARGET.
See TARGET
See PAINTABLE
Accessor to the vector of animations that have ended before the current clock time.
See PROGRESSION
progression)) ¶automatically generated reader method
progression)) ¶automatically generated writer method
Accessor to the vector of currently active animations within the clock time.
See PROGRESSION
progression)) ¶automatically generated reader method
progression)) ¶automatically generated writer method
Return the first progression instance that matches the denominator within the container.
symbol) animatable) ¶progression-definition) (animatable animatable)) ¶Constructs a new progression instance using the given definition.
See PROGRESSION
See PROGRESSION-DEFINITION
symbol)) ¶progression-definition)) ¶Accessor to the list of progressions that act upon this.
See ANIMATABLE
animatable)) ¶automatically generated reader method
animatable)) ¶automatically generated writer method
Registers the unit with the scene-graph, making it accessible by its name.
Any unit that is entered into any part of the scene-graph must be registered by this
function. This should happen automatically provided you use the CONTAINER-UNIT class
for containers inside the scene-graph. Thus you need not call this function unless
you implement your own container.
See UNIT
See SCENE-GRAPH
container-unit) (scene-graph scene-graph)) ¶unit) (scene-graph scene-graph)) ¶unit) (scene-graph scene-graph)) ¶Remove an existing progression from animatable.
See PROGRESSION
See ANIMATABLE
progression) (animatable animatable)) ¶Resets the given clock to its initial state.
Returns the object given.
See CLOCK
constant-tween)) ¶accessor-tween)) ¶slot-tween)) ¶leave-operation)) ¶enter-operation)) ¶progression)) ¶animatable)) ¶Accessor to whether the clock is currently running or not.
See CLOCK
Accessor to the scene-graph the container-unit is in.
See CONTAINER-UNIT
container-unit)) ¶automatically generated reader method
container-unit)) ¶container-unit)) ¶container-unit)) ¶automatically generated writer method
Accessor to the selector that describes which elements to affect.
See ANIMATION
See COMPILE-SELECTOR
Accessor to the size of the entity.
See SIZED-ENTITY
sized-entity)) ¶automatically generated reader method
size.
sized-entity)) ¶automatically generated writer method
size.
Accessor to the slot that should be modified.
slot-tween)) ¶automatically generated reader method
slot.
slot-tween)) ¶automatically generated writer method
slot.
Accessor to the spacing between items.
See ARC
Starts the given clock.
Returns the object given.
See CLOCK
constant-tween)) ¶automatically generated reader method
constant-tween)) ¶automatically generated writer method
Stops the given clock.
Returns the object given.
See CLOCK
Synchronize the clock to the new time.
Time should be another clock or seconds.
Returns the object given.
See CLOCK
Performs a single update tick, moving along the animation on the animatable at the given clock for the given step amount of time.
See ANIMATION
See ANIMATABLE
See CLOCK
accessor-tween) object clock step) ¶slot-tween) object clock step) ¶leave-operation) object clock step) ¶enter-operation) target clock step) ¶call-change) object clock step) ¶print-change) object clock step) ¶animation) (animatable animatable) clock step) ¶Accessor to the timescale of the clock to allow slowing or speeding up the progression of time.
See CLOCK
Accessor to a given, named unit in the scene-graph.
See UNIT
See SCENE-GRAPH
symbol) (scene-graph scene-graph)) ¶Returns a fresh list of all units in the scene-graph tree.
See UNIT
See SCENE-GRAPH
scene-graph)) ¶Accessor to the UP vector.
See ARC
Updates the given object, causing its internal representation to be adapted for the current time.
Returns the object given.
progression) dt) ¶animatable) dt) ¶Accessor to how opaque the paintable is.
Has to be a float between 0 and 1.
See PAINTABLE
queue-iterator)) ¶for-iterator.
queue-iterator)) ¶for-iterator.
container-unit) &key scene-graph) ¶progression) &key) ¶queue-iterator)) ¶for-iterator.
container-unit) stream) ¶scene-graph) stream) ¶progression) stream) ¶queue-iterator)) ¶for-iterator.
Struct to contain a queue cell with VALUE, LEFT, and RIGHT slots.
See VALUE
See LEFT
See RIGHT
Superclass container for anything that is animatable through progressions.
See PROGRESSIONS
A representation for a single set of changes in a progression.
When an animation is ticked, the following happens:
1. The selector is called with the given animatable and a function
2. Once the selector calls its function with a matching object,
each change in the animation is ticked with the matching object
as argument.
When an animation is reset, each change in the animation is also
reset. This should cause whatever effect it might have had to be
restored on the scene. This is particularly tricky for operations
as they need to ensure the scene stays consistent.
See START
See DURATION
See SELECTOR
See CHANGES
| Initarg | Value |
|---|---|
:defindex | 0 |
:beginning | (error beginning needed.) |
:duration | (error duration needed.) |
:selector | t |
:changes | nil |
:defindex
:beginning
:duration
:selector
:changes
Formation to represent an equidistant distribution of entities along an arc.
See FORMATION
See ORIENTED-ENTITY
See SIZED-ENTITY
See UP
See TANGENT
See ANGLE
See SPACING
Combination of a call-change and an accessor-tween.
Creation: (calc accessor :to form)
The FORM may use the implicit variables OBJECT, CLOCK, and STEP.
Implements TWEEN-VALUE.
See CALL-CHANGE
See SLOT-TWEEN
See TWEEN-VALUE
A change that calls a specified function on every tick.
The function is called with the OBJECT, CLOCK, and STEP received from TICK.
Creation: (call :func tick-function)
See CHANGE
See FUNC
See TICK
Combination of a call-change and a slot-tween.
Implements TWEEN-VALUE.
See CALL-CHANGE
See SLOT-TWEEN
See TWEEN-VALUE
Container for a single change or tween within an animation.
A representation for an item that changes its state over time.
Keeps its own time information in seconds.
See START
See STOP
See RESET
See RUNNING
See UPDATE
See SNYCHRONIZE
See CLOCK
See PREVIOUS-TIME
A tween mixin that simply increases a value every tick.
Implements TWEEN-VALUE
Default BY and FOR are 1.
See TWEEN
See BY
See FOR
See START
(setf by).
by.
copy.
(setf for).
for.
reset.
(setf start).
start.
tween-value.
| Initarg | Value |
|---|---|
:by | 1 |
:for | 1 |
A simple class that can hold a set of objects.
See CLEAR
See OBJECTS
See ENTER
See LEAVE
See MAP-CONTAINER-TREE
See DO-CONTAINER-TREE
See PRINT-CONTAINER-TREE
(flare-indexed-set:make-indexed-set)
A container unit is a unit that can contain further objects.
See CONTAINER
See UNIT
Represents an operation that introduces new objects into the scene graph.
Creation: (enter class :n number-of-copies :children child-forms :parent parent init-args..)
Child-forms being a list of enter forms, excluding the ENTER symbol at the start.
init-args being further initialisation arguments to be passed to the class that’s being instantiated.
Upon TICK, the CREATOR function is executed and each resulting object is ENTERed into the
given target animatable.
See OPERATION
See OBJECTS
See CREATOR
A paintable and animatable entity within a scene.
See CONTAINER-UNIT
See PAINTABLE
See ANIMATABLE
See LOCATION
| Initarg | Value |
|---|---|
:location | (vec 0 0 0) |
:location
Entity superclass for all formations.
Formations only handle the positioning of child entities, but do not display by themselves.
See ENTITY
arc.
Combination of a constant-tween and a slot-tween.
See CONSTANT-TWEEN
See SLOT-TWEEN
A set in which each element also has an index.
Aside from MAP-SET and DO-SET you can also use ITERATE to go through the set by FOR .. ON-SET or FOR .. IN-SET.
See QUEUE
See SET
See MAKE-INDEXED-SET
See MAP-SET
See DO-SET
See SET-ADD
See SET-REMOVE
See SET-SIZE
See SET-FIRST
See SET-LAST
See SET-VALUE-AT
See SET-INDEX-OF
See CLEAR-SET
See IN-SET-P
See COERCE-SET
Represents an operation that removes objects from the scene graph.
Creation: (leave)
Upon TICK, the given animatable is removed from its parents by LEAVE.
See OPERATION
See OBJECTS
(make-hash-table :test (quote eq))
Superclass for changes that modify the scene graph by adding, removing, or moving elements within it.
See CHANGE
An entity that can be oriented by a vector.
See ENTITY
See ORIENTATION
Superclass for anything that may be painted onto a target.
See PAINT
See TARGET
| Initarg | Value |
|---|---|
:visibility | 1.0 |
:visibility
Entity superclass for all particles.
Particles should not move by themselves and only handle the displaying.
See ENTITY
A NO-OP change that simply prints its TICK arguments when called.
Useful for debugging.
Creation: (print)
See CHANGE
See TICK
tick.
The controller to animate an animatable with.
Contains an entire sequence of animations and controls their behaviour
and effects on the animatable.
When animations on the progression are set, the following happens:
1. The current clock is saved.
2. The progression is reset.
3. The new animations are set to the future set and sorted, the other
sets are cleared and reinitialised to match the appropriate length.
4. The clock is set to the previously saved time.
5. All applicable animations are put into effect in fast-forwarding by
calling UPDATE on the progression.
When a progression is reset, the following happens:
1. All past animations are pushed onto the present set.
2. The active animations are re-sorted to ensure consistency.
3. All the animations in the present set are reset in order.
4. All animations are pushed onto the future set.
5. The clock is fixed.
When a progression is updated, the following happens:
1. New animations that are now active during the current clock are
shifted from the future set to the present set.
2. When the progression has an animatable, each animation is ticked.
For this, the tick step must be calculated. If the duration of the
animation is infinite, the tick is T. If the animation exceeded its
duration, it is 1.0. Otherwise it is the linear interpolation
between the current clock time, the beginning of the animation, and
its duration.
3. Animations that have exceeded their duration are shifted from the
present set onto the past set.
4. If no present or future animations remain, the progression stops
itself.
See CLOCK
See DEFINITION
See ANIMATABLE
See ACTIVE
See ENDED
See FUTURE
add-progression.
(setf animatable).
animatable.
(setf animations).
(setf clock).
(setf definition).
definition.
enter.
(setf future-animations).
future-animations.
initialize-instance.
leave.
(setf past-animations).
past-animations.
(setf present-animations).
present-animations.
print-object.
remove-progression.
reset.
update.
| Initarg | Value |
|---|---|
:animatable | nil |
:definition | (error definition required.) |
:definition
:animatable
#()
#()
#()
Container class to instantiate a progression from.
The definition should at all time keep track of the existing instances
and update them in case the definition gets updated with new animations.
When the animations of the definition are set, the animations are also
set for each of the known instances of the definition.
See ANIMATIONS
See INSTANCES
Implements an ordered queue.
Aside from MAP-QUEUE and DO-QUEUE you can also use ITERATE to go through the set by FOR .. ON-QUEUE or FOR .. IN-QUEUE.
See HEAD
See TAIL
See SIZE
See MAP-QUEUE
See DO-QUEUE
See ENQUEUE
See DEQUEUE
See QUEUE-REMOVE
See QUEUE-SIZE
See QUEUE-FIRST
See QUEUE-LAST
See QUEUE-VALUE-AT
See QUEUE-INDEX-OF
See CLEAR-QUEUE
See IN-QUEUE-P
See COERCE-QUEUE
Combination of a range-tween and a slot-tween.
See RANGE-TWEEN
See SLOT-TWEEN
A tween mixin that interpolates a given range of values using an easing function.
Implements TWEEN-VALUE
Default FROM is 0, TO is 1, and EASE is LINEAR.
See TWEEN
See FROM
See TO
See EASE-FUNC
See *EASINGS*
Formation to represent an equidistant distribution of entities along a ring.
See ARC
arc.
Container class to represent the top-level scene that should be drawn and managed.
See SCENE-GRAPH
See CLOCK
See PAINTABLE
See ANIMATABLE
A scene-graph is a container that also has a name-map to easily reach objects.
This includes all objects in the container tree that have a non-NIL name.
See CONTAINER
(make-hash-table :test (quote eq))
An entity that has a given size or extent.
See ENTITY
See SIZE
A tween mixin that modifies a slot on the object.
Upon TICK the slot-value is set with the result of TWEEN-VALUE.
See TWEEN
See SLOT
See ORIGINALS
See TWEEN-VALUE
Superclass for a painting device onto which things can be drawn.
See PAINT
See CALL-WITH-TRANSLATION
Superclass for changes that modify the given animatable, but do not change the scene graph.
See CHANGE
A unit is an object with a name.
A hash table associating names to easing function docstrings.
A hash table associating names to easing functions.
Each easing function takes a single float value between 0 and 1 that should be eased according to a curve.
A counter variable used to determine the current index in constraints.
A placeholder variable used to hold the final mapping function upon selector evaluation.
Hash table to contain global progression definitions.
A kludge variable used to prevent recursion upon a progression reset.
Compiles INTERVAL definition expressions into a list of animation definition forms.
First normalises the intervals per PARSE-INTERVALS then creates a form for each
per PARSE-ANIMATION and outputs each into a LIST form.
See DEFINE-PROGRESSION
Simply calls PARSE-CHANGE
Shorthand to define an :around method that will ensure the first argument is always returned.
Compile a selector constraint into a function.
constraint ::= name | nth | this | children | everything | function | list
name — A symbol naming a unit in the scene-graph
nth — An integer specifying the nth unit in the scene-graph
this — The symbol T meaning the current object
children — A symbol with name ">" specifying all children of the current object
everything — A symbol with name "*" specifying all descendants as per DO-CONTAINER-TREE
function — A predicate function that is passed the current object
list — A quoted literal, function reference, or function form to use
Resulting from a compile-constraint call should be a function
that takes a single argument, the current object to constrain on.
The NEXT argument is the function to call next if the constraint
passes its test. A single constraint may call this next function
as many times as it wants.
Compiles a selector into a function.
selector ::= constraint | (constraint*)
Returned is a function of two arguments, a scene-graph and a function.
The scene-graph is the root of the scene graph that is selected on and
each unit within it that the selector is matching on results in a call
to function with that unit as its argument.
See COMPILE-CONSTRAINT
Create a copy of the given sequence of animations.
Calls COPY on each animation.
Returns T if the given THING is an interval-designator.
See INTERVAL-DESIGNATOR
Ensures that the VEC is sorted stably in-place.
This means that if STABLE-SORT returns a new vector instead of re-using the given one,
the elements from the new vector are copied back into the old one so that it appears
as if it had been modified in-place. Always returns VEC.
See STBLE-SORT
Print the progression in a usable manner to inspect its current state.
Useful for debugging
See PROGRESSION
Compiles BEGINNING, DURATION, and the definition EXPRESSION into an actual FORM.
expression ::= (selector change*)
See COMPILE-CHANGE
See DEFINE-PROGRESSION
Normalises the lenient interval FORMS into strict expressions.
result ::= (expression*)
expression ::= (start duration animation-expression)
See DEFINE-PROGRESSION
Moves elements from FROM to TO if they pass TEST.
Elements are actively removed from FROM and inserted into TO
See ARRAY-UTILS:VECTOR-POP-POSITION
See CL:VECTOR-PUSH
Simulates running the progression-definition.
Creates a new scene instance and progression instance,
starts both of those and then updates the scene, printing
the progression each 0.7 seconds.
See SCENE
See PROGRESSION-INSTANCE
See UPDATE
See FORMAT-PROGRESSION
Accessor to the accessor that should be used to modify an object.
accessor-tween)) ¶automatically generated reader method
accessor-tween)) ¶automatically generated writer method
The step by which to increase each unit.
See CONSTANT-TWEEN
constant-tween)) ¶automatically generated reader method
by.
constant-tween)) ¶automatically generated writer method
by.
Create a copy of the given item in a way that is deemed appropriate for it. Mostly used for copying changes.
constant-tween)) ¶range-tween)) ¶accessor-tween)) ¶slot-tween)) ¶enter-operation)) ¶call-change)) ¶Accessor to the progression’s progression-definition
See PROGRESSION
progression)) ¶automatically generated reader method
progression)) ¶automatically generated writer method
Accessor to the easing function to be used to interpolate the value range.
See RANGE-TWEEN
range-tween)) ¶automatically generated reader method
range-tween)) ¶automatically generated writer method
The time step (in seconds) in which the value is increased by a single BY unit.
See CONSTANT-TWEEN
constant-tween)) ¶automatically generated reader method
for.
constant-tween)) ¶automatically generated writer method
for.
Accessor to the beginning value.
See RANGE-TWEEN
range-tween)) ¶automatically generated reader method
from.
range-tween)) ¶automatically generated writer method
from.
Accessor to the function container slot.
call-change)) ¶automatically generated reader method
func.
call-change)) ¶automatically generated writer method
func.
Accesses the head cell of the queue
See CELL
See QUEUE
Parse a change definition form that gives the TYPE and ARGS into an evaluatable form.
(eql flare:calc)) form0) ¶(eql flare:increase)) form0) ¶(eql set)) form0) ¶(eql flare:leave)) form0) ¶(eql flare:enter)) form0) ¶(eql flare:create)) form0) ¶(eql flare:call)) form0) ¶(eql print)) form0) ¶Recalculate the positioning of child entities.
Accessor to the set table of the indexed-set.
See INDEXED-SET
indexed-set)) ¶automatically generated reader method
set.
indexed-set)) ¶automatically generated writer method
set.
Accesses the size counter of the queue.
See QUEUE
Accesses the tail cell of the queue
See CELL
See QUEUE
The tangent vector between the UP and ORIENTATION.
See ARC
Accessor to the ending value.
See RANGE-TWEEN
range-tween)) ¶automatically generated reader method
to.
range-tween)) ¶automatically generated writer method
to.
Computes the currently applicable value for the given tween, object, clock, and stepping time.
See TWEEN
call-accessor-tween) object clock step) ¶call-slot-tween) object clock step) ¶constant-tween) object clock step) ¶range-tween) object clock step) ¶A tween mixin that modifies an object through an accessor.
Upon TICK the corresponding setf function is called with the result of TWEEN-VALUE.
See TWEEN
See ACCESSOR
See ORIGINALS
See TWEEN-VALUE
Combination of a constant-tween and an accessor-tween.
Creation: (increase accessor :by by :for for)
See CONSTANT-TWEEN
See ACCESSOR-TWEEN
Combination of a range-tween and an accessor-tween.
Creation: (set accessor :ease easing-func :from from :to to)
See RANGE-TWEEN
See ACCESSOR-TWEEN
An interval-designator can be either a real, T, or NIL.
| Jump to: | (
A B C D E F G H I L M N O P Q R S T U V W |
|---|
| Jump to: | (
A B C D E F G H I L M N O P Q R S T U V W |
|---|
| Jump to: | *
A B C D E F H I L N O P R S T U V |
|---|
| Jump to: | *
A B C D E F H I L N O P R S T U V |
|---|
| Jump to: | A C D E F I L O P Q R S T U |
|---|
| Jump to: | A C D E F I L O P Q R S T U |
|---|