The Squire3D Graphics Engine is a multi-purpose high-level graphics engine, designed to free game designers from the mundane details of graphics programming.

Game processing can be divided into two interacting sides: game logic, and graphics display. The game logic produces directions on how graphics should change, and the graphics display translates those directions to actual polygons drawn on the screen. However, most current games are programmed in such a way that the two are tightly intermixed, because models have grown quite complex, and we use sophisticated methods to get neat visual results. Most games will have custom model formats, custom model processing, and even custom code to draw each individual model. This has brought the art of game development to be primarily that of hacking graphics code until the desired results are achieved.

Squire3D is an attempt to change this situation to boost the productivity of game design. Our engine eliminates the need for game programmers to delve into the details of model display, and control the graphics with very high-level input. This allows the game and the graphics to evolve independent of one another, since models can be updated and replaced without changing a single line of game code. Such updates happen quite often in the game development process, such as making updates to model appearance, or taking advantage of new hardware capabilities. Other possible applications for this methodology include adding new characters or skins, upgrading graphics for new hardware, or having different versions of models for different configurations. With Squire3D, these changes can be made without touching the game logic.

The overall structure combines scene graphs with a programming language (such as C). From the game programmer’s view, drawing a model is like calling a function with customized inputs. Its implementation is in a “smart scene graph” (described below) which provides high flexibility in the way models are drawn. Constructing this scene graph is done with a utility program, which mixes notions from both programming and scene graphs in an intuitive GUI.

The scene graph level is a “smart scene graph” that changes states and draws objects much like a regular scene graph, with additional nodes that process data (such as adding, multiplying, performing dynamics computations, etc.). This allows for very customizable computations that remove the game programmer from the details of the model processing. This scene graph library is extendable via plugins to allow user-defined graph nodes, which essentially adds unlimited computational flexibility.

The programming aspect comes from the interpretation of this scene graph as a syntax tree of a programming language. This “language” is written much like a regular programming language, with functions as the primary design concept. The model can be conceived as a function that is called to draw the model.

This approach is similar to having every model stored in a DLL. This approach would have an interface to the model (e.g. model.draw(), model.setAnimation(), etc) defined inside a DLL, which would then be loaded at run-time. This would allow model changes to be as simple as replacing a DLL, without recompiling the main game code. Our method shares the same advantages, but they differ in a few key areas. Firstly, DLLs have infinite processing ability with completely customizable functions, which is only possible using Squire3D extensions (for model drawing, the power of DLLs may be overkill). Furthermore, they have compiled code, which accesses processing power directly. Squire3D has to go through a few steps of interpretation, so it isn’t quite as fast. However, programming DLLs requires an entire development environment, which may be daunting for non-programmers. On the other hand, Squire3D provides an editing utility that offers a workspace where both programmers and non-programmers alike can edit models intuitively. Making DLLs also requires implementation of an underlying graphics interface, whereas Squire3D does this automatically.

In summary, Squire3D is a middle point between the inflexibility of a single model format, and the overkill of using an entire DLL to represent a model.

The Squire3D Adventure Game Development System is a level-editing tool and interface that allow 3D adventure games to be constructed with a level editor and scripted with a c-like scripting language. It is currently in development.

Three forms of skeletal vertex weighting ("skinning"), including a never-before seen non-linear weighting method
Smooth keyframe interpolation and animation blending
Infinite layers of animation
Automatic resource management
Uniform support for both Direct3D and OpenGL
Support for hardware vertex shaders
Import models, skeletons, animations, and textures from a variety of formats (with more and more to come).
Intuitive and poweful weighting assignment, using "airbrushing"

Contact Sales