You can download an alpha version of the PEPTIG editor here.
PEPTIG is a system for the creation of procedurally generated images. "Procedural" means that some, most or all creational steps are recorded and played back later and these steps are single steps in a larger computational model. "Procedural" does not necessarily mean "programming" even though PEPTIG will allow some support of a programming model, the main creational steps can be specified via an easily understandable flow based model.
Flow based model
A data flow based model is easily understandable and has many advantages like replayability, resolution independence for purely procedural generated content. PEPTIG also supports quite a few image operations normally seen in image processing and photo/image editor applications like image resizing, alpha blending, channel de-/multiplexing, distortion and dynamic range operations.
A flow is specified by a set of simple operations provided by PEPTIG. A flow is represented as a graph of nodes -- which represent these operations -- and connections between the nodes -- which represent data flow. By providing a certain set of these operations PEPTIG allows an artist to combine these operations in unique ways.
There are two general types of nodes: generators and operators. Generators don't have image inputs and generate images, most operators have image inputs, but not all of them, as some are dedicated to scalar values and color values. Generators can be customized through data flows in form of scalar values and color values as are operators, but the primary means of using the generators with image outputs is to configure them with a fixed set of parameter values. This is the default usage scenario for generation of still images, if one doesn't want to create an animation.
As already alluded to, the connections between nodes represent flowing data between them. Each connection has a data type associated with it and a connection can only be made if the type of a node output matches the type of another node's input. The types currently supported are:
- scalar (single floating point value)
- gresystream (2D array of grey values plus an alpha value)
- rgbstream (2D array of RGBA values)
- RGB color (single RGB color)
All data flows are unidirectional, i.e. everything flows in a downstream direction.
The engine is the heart of PEPTIG. It carries out all calculations in 32 Bit floating point format, so HDR image calculations are possible. The dynamic range is reduced on export according to the support of the export file format chosen.
The engine supports embedded and linked assets (images) directly in its projects. It is possible to import an image, do all the processings specified by the graph(s) and export a final image or set thereof in form of a batch rendering.
The engine is quite fast. For small output images and relatively low processing, a batch render reaches up to 30 images per second including the storage of the output images on the hard disk. This figure has been measured on an old machine from 2008.
The following file formats are currently supported (Import and Export):
- JPEG XR
The following file format support is planned for the future:
- Radiance HDR
Possible Application Areas
- Games and other Visualization Applications: generate textures and other image content for games in a procedural way, change a small set of parameters to create unique variants
- Websites: create backgrounds and other images for your websites
- Application Developers: Create unique visual assets for your applications including multiple state images for your controls and animations
An image (or set of images) to be computed is specified by the user who uses the editor to specify the computational steps to be executed in a node based flow model.
Most used commands are mapped to keyboard shortcuts for fast workflow.
The current plan is to provide the final product in three editions:
- Standard Edition: Contains the editor and the node types listed below and is suitable for creation of procedural still images like textures
- Professional Edition: Contains all the features of the Standard Edition and adds larger supported image sizes (generated and imported), basic animation support and improved batch rendering support
- Premium Edition: Contains all the features of the Professional Edition and adds even larger supported images sizes, advanced animation support, more node types, scripting facilities and a dedicated batch rendering tool which can be integrated into an automated workflow
The PEPTIG engine is planned to be made available later for integration into games and other visualization applications in the form of an SDK. The conditions for such an integration will be negotiable on a case-by-case basis.
The primary target platform is Windows 7 and above (64 and 32 Bit). If there's demand for support of other platforms (especially for the SDK), I will consider whether a porting effort to a specific platform (primarily the editor) makes economical sense.
For Game Developers and Other Digital Asset creators
The foremost advantage is, of course, a very high compression ratio as the image data is specified as a graph of operations, not the image data itself. This has the following advantages:
- reduce download traffic and download times for projects with downloadable content; this can also result in a reduction in needed infrastructure to support many downloads simultaneously
- save plenty of space on your distribution media for images/textures which are in fact procedurally specifiable which could be a substantial part of your overall set of assets depending on your project
- reduce download times and traffic for your updates if that content has a substantial part of procedurally created content
- reduce download times and save space for images which are derivates of a limited set of original images by specifying the derivation process/steps; the higher the ratio of the number of to-be-distributed images to the number of original images the more savings can be applied
- increase response times and reduce download times for massively multiplayer online games as a part of the content is generated on the end-user machines
- decrease load times as mass storage is several orders of magnitude slower than memory bandwidth: the specification file of an asset is extremely small with respect to the storage of image data; this advantage applies only if the content is generated at each program start
- if you have many graphs and/or very complex graphs, the calculations might take too long or need too much energy/battery life; in that case you can run all the calculations at install time and store the results into your asset files or standard format files; this will not decrease load times at program startup, of course, as the generated content needs to be loaded from mass storage in that case
- based on project files which are text files; these can easily be stored in version control systems; if embedded assets are used, version control systems can't diff and merge these files, but that doesn't apply to normal asset storage in version control systems, either
In short: exchange network and mass storage bandwidth with memory and CPU processing bandwidth. That gap is significant.
The implementation of PEPTIG uses the following techniques and methods to reach the goal of making the local calculations on the end-user machines as fast as possible without up-front exclusion of end-user machine types:
- 100% native code in the engine itself
- heavy usage of SIMD instruction sets where possible to accelerate the calculations
- leverage of multi-core systems if graph dependencies allow parallel calculations
- a single binary of the engine: it automatically falls back to non-SIMD calculations if a machine doesn't support a SIMD instruction set; this makes your configuration management a lot easier
A partial GPU based calculation can be implemented in the future if the need arises.