Jenna
Cidertank
UX .:. 2001
Background
In 1995 I began working with a freeware ray-tracer POVray, experimenting with ways to produce complex and detailed forms. While exploring the Julia set 4D fractals, I came across a technique used to perform a processing loop during the evaluation of a scene file. This allowed for operations to be performed on a source object, with the resulting object placed in a series. The approach enables any objects within the loop to be positioned within a scene, including manipulation of their parameters within the loop. The result was a procedural method to generate many objects in a scene with varying parametric values.
Tentacular Continuum
Kent Oberheu : 1997
Creating metaball spheres within the loop created an implicit surface as a flowing form. Using sine functions to modify the placement and tolerance parameters of the metaball instances, creates a sinuous object floating in space.
Flight of Brilliance
Kent Oberheu : 1999
Here the evaluation loop technique was used in both the flowing abstract form in the foreground, as well as the grid of box forms hanging in space.
Historical Context
Using this technique as a basis for procedural object placement and generation, I was able to create objects stepped through cycles while rendering the result of each object in a single frame: a novel technique for 4 dimensional expression of form in computing graphics. However, the technique is not new. The exercise of rendering a form as a series of steps within a single frame was explored by Marcel Duchamp in his work “Nude Descending a Staircase No. 2” and was exhibited in 1912. Additionally, Umberto Boccioni explored the concept of dynamism in his work “Dynamism of a Soccer Player” as did Giacomo Balla notably in his work “Dynamism of a Dog on a Leash” and “Flight of the Swallows”.
From Render-time to Real-time
The loop techniques leveraged in POVray were effective at producing a convincing level of complex form and detail. However, the setup of the procedures and tuning them for a satisfactory result, required editing a scene file written in text without the assistance of a real-time render of the scene. To develop the images and procedures required mentally visualizing the transformations and parametric objects; making judgements on any edits in the scene file; rendering a ray-traced image; editing the scene file; rendering the file, repeating as necessary until the result was satisfactory. Using careful versioning of the files made it possible to test many variations before committing to a high-resolution render.
In 2001, my colleague David Farmer asked if I’d like to collaborate with him to build a toolset to make the technique operate in a real-time 3D environment. After months of considerations for structuring the tools, we settled on a useful set of methods for object placement.
The resulting tools were distributed under the name Jenna, as a set of parametric objects and operators to place instances of 3D objects in a scene using a transformation method. The initial set included these parametric objects:
- ITERATOR
- TWEENER
- GRIDARRAY
- MESHARRAY
- ALLIE
ITERATOR
The ITERATOR object takes a child object, creates instances of it, and transforms each instance by an assigned amount. ITERATOR uses the count value as a multiplier for the transformation of each placed instance.
An instance of the source object is placed a specified transformation distance from the previous instance until the total count is reached.
Instance transformation can include scale and rotation. By Setting the value to precise angles geometric patterns can be quickly created.
Using Position, Scale, and Rotation together can produce helical patterns.
The following illustrations show how the object can be rotated and scaled with controls for order and inclusion within the transformation.
The child object can be any single object, a set of grouped objects or hierarchy.
To provide an alternating object sequence, a special “uber null” object may be used which references each of it’s children, in order, when placing a new instance within the ITERATOR transformation function.
An optional variation can be included in the transformation calculation. The variation adds to the primary transformation and contributes to the placement of the object. The variation is driven by a random seed, implemented as a floating point value. Along with the Variation Amount, the Seed Value can be also be manipulated to tune the variation to achieve the desired effect.
ITERATOR was also able to use a spline for placement along a path, using the transformations of rotation and scale for each instance of the object placed on the path.
TWEENER
The TWEENER object uses two versions of an object, and makes multiple steps in between the two objects, progressively changing the parameters of each object across the set of objects in the array.
Using simple objects and transforming one of them produces complex arrays of form. Any object available in Cinema could be used within the TWEENER object. Hierarchies can also be used in TWEENER. When doing so, the entire parameter set of each hierarchy is transmuted across the array. Variation of transformation, can be introduced into the array as well as variation of the tweened parameters of the source objects.
The two objects in this TWEENER example are both box primitives. The transformation of the box, it’s dimensions, and bevel are transmuted from one object to the other.
Duplicate hierarchies can be used within TWEENER. Each object’s parameters and transformation data in the hierarchy is gradually transferred from the parameters of one hierarchy to the other.
Multiple parameters of each object are transmuted from one copy to the other.
Geometry is also transmuted, along with the transformation of the object.