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 & Geometry, File Operations, PCS Trees, and Memory Management.

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 graphics technology that powers it is OpenGL. It can open Models that have been converted from a .fbx to a .yogi format (see Yogi Archiver). It can also skin and animate models. 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

Managers are used to organize and control engine resources and are made of two main structures: 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 that the manager is in charge of creating, updating, and destroying. By managing only one type of resource in each manager, responsibilities are clear and resources remain organized.

Models

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. Models are also responsible for preparing their data to be sent to the GPU.

Textures

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. So even though there may be multiple versions of a texture in the cpp code, there is only one texture data gpu resource that is accessed with different texture views.

Shaders

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. It is important for performance to render as many graphics objects, that use the same shader, together so that the graphics pipeline state changes as little as possible.

Resource Manager

The Resource Manager does not 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 do many linear algebra and 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

Memory Management Static Library

The Memory Management library takes controll of all memory management that the engine does. It can:

  • Allocate and reserve blocks of memory
  • Collasce blocks to reduce fragmentation
  • Overload operator new and delete
  • Track memory leaks