polyzygy: the making of a time-based generative artwork
written by fraguada
introduction
description
polyzygy is a time-based generative artwork about periodicity: cycles, phases, periods. It is based on simple manifold polyhedral forms and their degeneration into more complex and non-manifold forms, and back, periodically.
The title is a conjunction of two words: polyhedra and syzygy. Polyhedra means “many faces”. Polyhedra, specifically the five platonic solids, are the base forms used in the project. They come with a lot of conceptual baggage, but are easy to work with, are manifold, and generally recognizable. A syzygy is the nearly straight-line configuration of three celestial bodies. Syzygy is a word I recently learned about and was selected for its connection to moments in cycles.
conceptual framework
As mentioned in the description, the project is one concerned with time and cycles. The project evolves and devloves over time from the manifold state of the polyhedra to non-manifold, and back over a specific period of time.
Geometrically, the manifold - non-manifold transition and cycle represents the state when the polyzygy has the potential to exist physically (manifold) to where the form no longer has a physical potential and can only be experienced digitally (non-manifold). Through this cycle, the project attempts to provide evidence that there is a continuum between what is represented as real or virtual, analog or digital; a reality continuum where our experience can exist in the domain bounded by smooth to discretized moments.
This cycle varies with each iteration, from 7 hours to 27 days. This is a project that evolves over time, and asks the viewer to do the same.
technical framework
Technically, the project is the first js port and application of an algorithm I have used in previous projects. The algorithm is inspired by previous research into the far from origin phenomenon manifested by discrete digital numeric systems used in computers. This algorithm exploits the discrete nature of digital number systems and their ability to represent a limited set of real numbers. Depending on which number you are trying to represent, the system might have to round up or down to find the nearest representable number, resulting in the loss of precision. This loss of precision can be controlled, to a certain extent, and applied to any set of values, for example, the vertex coordinates of a polygonal mesh.
The work has a generation date hard coded and each iteration has a specific period which determines where it will be along its cycle. There is a timeline which shows where in the cycle the polyzygy is at the time of viewing, and the peaks of each cycle.
polyzygy
the far from origin problem
floating-point precision
If you’ve worked with 3d software for some time, you start to recognize certain phenomena endemic to most commercially available software packages. For example, 3d animators will recognize the gimbal lock problem, where two rotational axises are oriented to the same plane and thus leave an object unable to further rotate about those axises. 3d modelers will recognize z-fighting, when more than one polygonal mesh face occupies the same 3d space and thus the graphics card has to decide which to show, resulting in graphics artifacts. Another common issue is called the far from origin problem, where geometry starts to break down and look corrupted as it is moved farther and farther away from the origin of the 3d scene. polyzygy is based on this last phenomena.
Working in architecture, I would often have 3d models which would represent areas of many kilometers square. This is where I usually would see these broken down and corrupted 3d models. I was curious to find out what was behind this phenomenon, especially since some of these models, while corrupted, were actually quite beautiful.
The far from origin problem is a direct result from the discrete digital numeric system upon which the software is based. Numeric systems based on floating-point numbers are developed with fast calculations in mind. They are represented by an integer multiplied by a fixed base integer with an exponent. Due to this representation, they are discrete, meaning, they approximate real numbers. As the real number gets larger or smaller, away from 0, the approximation gets more severe.
Here is a wonderful image from the wikipedia article on floating-point arithmetic which does an excellent job at visualizing how the approximation grows as the real number goes towards positive or negative infinity.
It is in this approximation where we find how a 3d model might be corrupted as it moves farther from the origin.
prior art
Most of my projects in the last two years have explored this phenomenon. Here are some selected examples.
a sphere floating in precision (2021)
While I had played around provoking this phenomenon in different ways, I thought I would start with a perfect sphere. For this project I created an animation that progressively moved the sphere farther and farther away. I also thought that it could be an opportunity to apply this same process to some audio to see how it could sound after undergoing the same transformation in 3d space. I chose a 440 Hz audio tone, imported the waveform into the 3d software, applied the progressive transformations, and was fascinated by the resulting sound. It is definitely an acquired taste! Conceptually, I was really happy with this result. I packaged the animation and audio in an interactive video player that scrubs the video according to the x mouse position.
interactive version: https://teia.art/objkt/587141
⚠️: turn down volume
a tree floating in precision (2022)
In this piece (which was minted to celebrate the Teia marketplace contract), I was experimenting with color, organic forms, and isometric projection, and found that the process yielded more than a compelling geometric deconstruction. In the degeneration of the geometry, mesh faces collapse upon each other and the colors associated with those faces will mix and generate other artifacts.
a cliff floating in precision (2021)
This piece combines the previous techniques and attempts to further force the generation of serendipitous artifacts through provoking z-fighting.
the ff0 algorithm
Good news for most 3d artists, bad news for me, is that 3d software developers have many ways to mitigate the far from origin problem. Often these workarounds will be different for different systems. I typically develop my work in Rhinoceros 3d by Robert McNeel & Associates. For fxhash I would be working in JavaScript and three.js. These are two very different environments and the far from origin phenomenon in both systems was mitigated. Luckily, they both still rely on floating-point arithmetic, so I can exploit that and have a portable algorithm to go between 3d software. The original algorithm was written in C# for Rhinoceros 3d in the Grasshopper visual programming editor. For fxhash I would need to port this to JavaScript.
...
geometry
manifold vs. non-manifold
todo
platonic solids and subdivision
todo
color
todo
time
todo
related projects
Proxima by mrkswcz and ismahelio
todo
toccata by andreasrau and msoriaro
todo
interaction
audio
console
iterations
live minting and public release
summary
todo
acknowledgements
licenses
errata
The URL parameter for enabling or disabling the rotation is incorrectly demonstrated in the project description. It should be:
rotate [ bool ] ( true, false) - toggle animation. example: /?rotate=false