Quick Intro

Introduction

Purple runs as a normal Verse client. It implements a node database to mirror the contents of its host. It loads the plug-ins, which reside in libraries, from local disk as DLLs or shared objects depending on the platform.

Purple exports information about available plug-ins as XML text data in a Verse text node, relying on user interface clients to pick up the information.

Interfaces (or anyone) can use Verse object node methods to control the Purple client.

Graphs

Methods are defined to make the Purple engine create, destroy and edit graphs. Graphs are simply "workspaces" in which plug-ins can be instantiated. Think of them as "projects" or "documents"; graphs are what you edit when working with Purple.

A graph may contain any number of plug-in instances, and each plug-in might be instantiated any number of times.

Sample Purple graph. Underlined words link to plug-in code in CVS.

The above image is an example of a Purple graph. It features four plug-in instances (called "modules" when the distinction is important) connected together. Computation goes from the left, triggered by non-shown parameter inputs to the "cube" plug-in, and results flow to the right. The "node-output" plug-in that terminates the graph causes results to be sent back to the Verse server, where they can be accessed by any Verse client as usual.

The words that are underlined in blue are clickable, and will take you to a CVS page for the plug-in in question.

The image here shows what the result of the above graph can look like. Note that this is rendered by a stand-alone rendering client, connecting to a Verse host and downloading its contents. The renderer is not "Purple-aware" in any way, nor does it have to be.

By tweaking parameters to the plug-ins in Purple, things such as the cube's basic size and tesselation, and the twist angle, can be changed. As they change, Purple re-computes the entire graph, and the changes are seen immediately by the rendering client.

This adds a layer of "construction history" to Verse; you can work with objects that know where they came from, and that can be parameterized in ways Verse's pure, dumb, meshes cannot.