Platform Application Workflow

This document is not meant to cover every single detail of an application's workflow, and it is certainly possible to create application workflows that deviate significantly from our designs. It's meant to provide a basic understanding of workflow if you are interested in building applications that follow our general design principles.

Fundamentally, Scenome application workflow is designed to facilitate craftsmanship, or iterative design. We understand that the first version of something is rarely perfect. So instead of designing a tool that emphasizes the "creation" process, we designed a tool that emphasizes the "revision" process. This makes sense to us because most of the developers with whom we speak tend to spend a lot more time refining their work than actually creating objects. You won't find very many dialog-based object creation functions in Scenome applications.

Core Workflow

Interface layout should suggest core workflow and workflow design criteria. We recommend using the left and right side of the menu bar to store application level menu options, with create and modify options in the center. Adherence to these principles has two effects: 1.) all revisions are implemented in the same manner, making it easier to use Scenome applications, and 2.) the process is very consistent.

Revision-Oriented Production

Now it's one thing to talk about emphasizing the revision process, but what have we actually done about it? Quite a lot actually. Scenome's mesh modeling is parameterized; basically it uses a mesh construction history, along with a lot of abstraction, to make it easy to engage and implement many kinds of major and minor revisions. The drawback here is that Scenome's scene graph structure and mesh modeling are somewhat complex in their implementation. The benefit, of course, is fast revisions that can be almost effortless.

Object / Action Metaphor

Scenome also has a simple workflow that relies heavily on the object-action metaphor. This software development metaphor requires the user to select an object before he or she can engage an action. In Scenome applications, actions are performed by script-based or C++ commands.

Highly Granular Command Architecture

Another key concept in Scenome applications is their highly granular command architecture. This concept is simple. Rather than emphasizing the create process, Scenome applications have very few create commands and many, many commands that instantly modify objects. Scenome applications are extensible via scripting and this makes it very easy to write most, if not quite all, of the commands that implement revisions.

The granular command architecture tends to require the user to invoke a series of commands to complete a complex operation, rather than trying to make a complex, dialog-based command that handles lots of permutations, but cannot be revised iteratively.

There is a small price to pay for this flexibility; you have to implement a lot of commands, although this does tend to keep C++ and script functions smaller. We think it's well worth it. Would you rather have your work interrupted for a few minutes while you write a script or have your work interrupted countless times daily while you deal with dialog boxes and constant, complex iterations?

Immediate Command Termination

User level commands that implement revisions should terminate immediately whenever possible. Sometimes immediate termination is not advantageous; in those cases, a specific mode-based tool can be implemented. For example, when you wish to draw a curve, you enter a modal context called Draw. The software remains in this mode until you tell the software you are finished drawing the curve. Select is another modal context and Scenome tends to spend most of its operation time in this mode while the user to applies commands. Select mode separates into numerous revision contexts, depending on the current selection.

Revision Context

A revision context is entered when the user makes a selection. If you select a group or group-set, the software can apply commands designed to modify groups. Similarly, if you select a face-set, the software can apply commands designed to modify faces.

Error Feedback

Scenome application nodes should provide instant visual feedback if there is an error such as a missing file property or an improperly configured parameter. Scenome's C++ API has a feature called node presentation that makes it easy to implement a variety of icons that reflect the state of the node.

Keep this in mind as you build your own applications.