abandon all hope ye who enter here
currently glambient is released as source code
only. you'll have to build it from the source if you want to use it,
and you will need to be a hacker to do that. if you get that far,
this will be useful info.
basic notions
- The topology describes which points are connected to
each other, and by which edges. The actual positions of the
points are not included in the topology.
The topology allows a certain number of degrees of freedom,
or dofs for short. If there are more points in the topology,
there are more different ways that it can wiggle, and more degrees of
freedom. The number of dofs is roughly twice the number of points.
- The state gives positions for all the points
in a particular topology. A state allows you to actually
draw the topology on the screen, by giving one particular
value for each degree of freedom in the topology.
- A space is a continuous range of possible states, but
with fewer degrees of freedom than the entire topology.
The space contains constraints that determine which states
are part of the space and which are not: each constraint removes a
degree of freedom from the topology. If the constraints are visually
obvious, then any state within the space will look symmetrical in
some way. A space with zero degrees of freedom contains exactly
one state.
- The sanity force also restricts the current state to
one that makes sense for a tiling - it resists entering states
in which two edges of the tiling would cross each other, for example.
It is a "force" rather than a "constraint" because it doesn't reduce
the number of degrees of freedom in the current space, it just sets
some limits on them.
what you can do
Using the glambient application, you can do a number of things
with topologies, states, and spaces.
- drag a point, which changes the current state. The
application will try to find a state in the current space that
allows the point to follow the user. The current space
may not contain any states that exactly match what the user is
asking for, in which case the point will not follow the user
exactly. The sanity force will also stop the user from
creating self-intersecting tilings.
- wander through the current space. This animates the
current state, moving it through the current space. The state
is also subject to sanity forces.
- split an edge, creating a new point in the topology and
adding two degrees of freedom to the current topology and space.
- delete a point, modifying the topology and removing two
degrees of freedom from the current topology and space.
- create a symmetry, which removes two degrees of freedom
from the current space (the topology is unchanged).
- release a symmetry, which restores two degrees of freedom
to the current space (the topology is unchanged).
- open a tiling file.
- save the current state, space, and topology in a tiling file.
known major bugs
- at this time there is at least one bug
that trashes memory, probably related to freeing constraints.
- freeing / releasing constraints often picks the wrong constraint
to release and may screw things up completely. avoid if possible.
- deleting vertices will probably crash because it takes the
tiling through an inconsistent state.
- memory management is simply not dealt with:
the model for using the program is to save your work and restart the
program every now and then. think of it as a particularly violent
form of copying garbage collection. basically, the situation is
way too complicated for malloc()/free() to work well, and i don't
want to make a garbage collector for the home-grown "object system"
i'm using. at some point, i will be forced to hook it up to a better
object system, this might happen if/when i switch to python.