The Principia Production Platform: Structure and Components

The Principia Production Platform features almost everything you need to produce a release-grade game. It consists of:

Large collection of software components that are designed to be embedded in your finished product, and that implement nearly every aspect of building top-grade digital entertainment products such as games, animation, machinima, and more. You can also use Principia to build multimedia management applications.
Script interpreter, which you use to define which components make up your application, configure their properties and appearance, and execute the application workflows. Principia scripts can be written in XML and in native XML-like forms.
Many utilities for authoring and managing multimedia content, such as procedural generators for textures, materials, geometry, items, characters, animations, terrain, game levels and worlds ...etc.
Hundreds of "Do-By-the-Example" tutorials and demos, which show you how to use Principia to implement virtually everything that goes in a game - from the simple to the arcane - and help you get started fast.

Principia Software Components

The Principia components are objects that you define using a simple scripting language, and that you use to assemble your application from top to bottom. There are five major classes of Principia components:

Internal components: Normally used internally by Principia, these basic software objects are still accessible and available to your application for tasks such as managing sets, data cubes, networks...etc.
Application components: A vast array of parts from which the bulk of the finished product is assembled (more...)
Analysis components: Provide extensive mathematical and geometric analysis capabilities that are required for AI, geometry manipulation, etc.
Physics components: Designed for integration in your game, these components enable the simulation of real-world physical processes and support gameplay.
Procedures: A broad array of components for the procedural generation and management of a broad variety of multimedia content (more...)

Principia's Application Components are divided in several major groups:

Graphic components: Encapsulate and manage textures, geometry, meshes, shaders, materials...etc, in brief, everything you need to form an image.
Media components: Encapsulate audio and video streams, create and manage soundtracks and sound FX for your applications.
Controls: Define GUI components and implement the flow of your application.
Effects: Perform real-time operations on graphics and media content.
Objects: Provide for a large variety of game objects such as items, animals, characters, buildings...etc.
Behaviors: Define what objects do when in gameplay.
Operations: Perform tasks on groups of objects, such as visibility testing.
Worlds and world layers: Hold and manage terrains, objects...etc.
Viewers: Display the content of worlds as well as data items such as maps or charts.
Engines: Engines are made by combining worlds, viewers and controls. Engines are defined and instanced in script.
Interfaces: Master components that define and manage input/output modalities.
System components: Implement the application windows, processes and its interaction with the hardware platform it's running on.
Platform components: High-level product definition components that provide tasks such as installation, encryption, DRM, data persistence, application architecture definition…etc.
Data components: Encapsulate a variety of data structures used in game and graphic-related applications.

Principia Scripts and Interpreters

A powerful feature of Principia is the ability to use scripting and code in any combination to create the desired application. Scripting is a much more efficient manner to define application components, workflows...etc. that are portable and do not require specialized developer skills. Here is a very simple example, that renders a 3D object with procedural materials:

##define (MTRL_STATUE) as <MATERIAL_3A>
#tag VShader = ( VS_LAYERED_STONE )
#tag PShader = ( PS_LAYERED_STONE )
#tag Material = ( M_EMBEDDEDLIGHT , NONE )
#tag TX = ( "Files_Media\Ochre_Layers.png" , SLOT_0 )
#tag TX = ( "Files_Media\Synthetic_Map.png" , SLOT_1 )

##define (GEOM_STATUE) as <VERTEXSET_3A>
#tag File = "Files_Media\Mesh_Statue.3ds"
#tag Definer = ( DECL_POS3F )
#tag Loader = ( PROC_3DSLD_DEMO )

##define (MESH_STATUE) as <MESH_3A>
#tag Component = ( FRAME_0 , MTRL_STATUE , GEOM_STATUE )

##define (OBJ_STATUE) as <OBJECT_3A>
#tag Construct = ("Decl(M);Set(tM,0)", MESH_STATUE , ANIM_STATUE)

##define (WORLD_DEMO) as <WORLD_3A>
#tag Layer_Decl = ( LAYER1 , "Solid Items" , NONE , NONE , 16 )
#tag Layer_Item = ( LAYER1 , OBJ_STATUE )

##define (VIEWER_DEMO) as <WORLDVIEWER_3A>
#tag World = ( WORLD_DEMO )
#tag Camera = ( MAIN_CAMERA )

##define (SCENE_DEMO) as <SCENE_2A>
#tag Element = ( 0 , 0 , VIEWER_DEMO )

##run (SCENE_MAIN)

The script defines a shader-based material, a geometry, an object, a world and a simple engine for viewing these. If this script is stored in a file named "statue.cfg", the application code consists in a single line:

Principia->Parse("statue.cfg");

Of course, even the simplest game consists in more than this, but the principle remains the same:

Virtually all data, and most game tasks are generic. They can be created using pre-defined Principia components and a template-based scripting language. The latter does not require specialized development resources, and is much faster than doing it yourself.
Some game tasks (pertaining mostly to gameplay) are unique and will need your development effort. You will be surprised how few of these tasks are left for you do once you become familiar with the full span of Principia's components.

For instance, Principia covers about 98% of the total coding effort (TCE) required for simple game such as "BubbleBath II", and about 90% of TCE required for a more complex game such as "Word War III".

Q: You might ask “why not have a more natural scripting language, reading something like - render (head.3ds) with shader (layered_stone.vs) ...etc”?

A: That would be fine if we wanted a fine-arts rendering language. For game development however, we need a much deeper structural resolution into the rendering cascade and its relationship to the game contents. Hence, the scripting language is a bit more complex and hierarchical. But think of the alternative - coding API calls to the graphic subsystem, audio drivers, resource managers...and so on.

Principia Procedures and Utilities

Principia’s procedural software components are divided in several major groups:

Texture generation procedures
Geometry generation procedures
Animation generation procedures
Object and character generation procedures
World generation procedures
Basic field procedures: generate numeric fields and distributions that are mathematical representations of lines, textures, height fields, particle systems, and act as fundamental units for procedural generation.
Basic relationship procedures: generate relational data structures such as networks, graphs…etc., that are another fundamental input to content.
Particle systems generation procedures
Audio content generation procedures
Data management procedures that perform a wide variety of content management tasks, such as generating Wang texture sets, extracting RGBA masks...etc.

To find out how Western Star Entertainment can help you make the most of Principia, please visit our Production Services Overview.