The Pascal Game Engine

I created this game engine during the game engine track at DePaul (GAM 475, GAM 575, GAM 576). It was built using C++ and OpenGL. The engine utilizes many static libraries that I also made for class. They cover the following the following areas: Linear Algebra, File Operations, and PCS Tree.

Here is a video overview of the Pascal Engine. More in-depth information can be found further down this page.

* Video coming soon! *

What can it do?

The Pascal Engine is pretty simple and is mostly for rendering models and animation for now. The core technology that powers it is OpenGL. It can open Models and Animations that have been converted to the .yogi format (see Yogi Archiver). It can also skin Animations that have been loaded. Models and Animations are manipulated using different types of Game Objects. Models are attached to Simple Game Objects. Animations are attached to Rigid Game Objects. Both of these can be attached to other Rigid Game Objects and moved together as groups.

This is all accomplished using resources, managers, and static libraries.

Resources and Managers

Manager Pattern

The managers that are used to manage engine resources are made of two main parts: a singleton manager and a doubly linked list of nodes. Each node is a base class that a resource class is derived from. For example: the Model Manager contains a list of Models. By storing only one instance of each type of resource in each manager, a lot of space and time is saved.


Models are abstractions of vertices and triangles that will be rendered to the screen. They are responsible for keeping track of all information necessary to build triangles using the OpenGL API.


Textures are abstractions of texuture data to be mapped to model geometry. There can be more than one instance of a texture containing the same image data, but it may have different uv mapping settings.


Shaders are abstractions containing shader files and data for rendering objects. They are responsible for keeping track of all information necessary for graphics objects to know what to send to the GPU.

Resource Manager

The Resource Manager does not actually use the Manager Pattern previously mentioned. This manager is used to load Yogi archives created by the Yogi Archiver. These can be static models, skeletal animations, or skinned animations.

Static Libraries

File Static Library

The File Library is a wrapper for Win32 system file IO operations. It can:

  • Open and close files
  • Open files for read only, write only, or read and write operations
  • Seek and Tell locations on disk
  • Flush the file buffer
  • Check if file handles are valid

Math Static Library

The Math Library can many 3D geometric operations. It also wraps some basic trigonmetry from the C++ standard library. The library limits the use of types to increase performance, so floats are always used instead of doubles. The library contains operations and definitions for:

  • Trigonmetry (general operations)
  • Vectors (general operations, special constructions, conversions, and linear interpolation)
  • Quaternions (general operations, special constructions, conversions, and spherical linear interpolation)
  • Matrices (general operations, special constructions, and conversions
  • Utilities for comparing floating point values within error
  • Frequently used mathematical constants

PCS Tree Static Library

The PCS Tree Library can create and manipulate trees constructed using a Parent, Child, Sibling relationship structure. It can:

  • Create and destroy PCS trees
  • Create, destroy, insert, and remove PCS nodes
  • Use iterators to traverse PCS trees from front to back or vice versa
  • Return information about a tree and its nodes
Card image cap