SUNENGINE Documentation

Introduction

Welcome to the documentation for the SUNENGINE application. This engine is designed to provide a comprehensive framework for game development, offering a wide range of features to facilitate the creation and management of GameObjects, scenes, and input handling. The engine is built with a modular design, allowing for easy extension and customization to suit various game development needs.

Features

• Game Loop: Provides a game loop for managing the flow of the game, including initialization, updating, drawing, and ending scenes.
• AZUL Graphics: Utilizes the AZUL graphics library for rendering 2D/3D models, textures, and shaders.
• Asset Management: Manages the loading and unloading of game assets, including textures, models, and fonts.
• Scene Management: Efficiently handles the initialization, updating, drawing, and unloading of scenes.
• GameObject Management: Provides a base class for game entities, allowing for easy registration and management of GameObjects.
• Input Handling: Manages keyboard and mouse input events, providing a robust system for user interaction.
• Collision Detection: Manages the registration and processing of collisions between GameObjects.
• Drawable and Updatable Management: Handles objects that need to be drawn or updated in the game loop.
• Sprites and SpriteFonts: Provides classes for managing 2D sprites and sprite fonts for rendering text.
• Alarm System: Allows for timed events and actions within the game loop.
• Camera Management: Manages the camera view for rendering scenes.
• Memory Tracking: Dynamic memory leak tracking to ensure efficient memory usage.

Installation

Step 1: Setting Up the Project

• Add "Framework.h" as a forced include file in your project settings.
• Define the following preprocessor definitions:
  • WINDOWS_TARGET_PLATFORM="$(TargetPlatformVersion)"
  • MEMORY_LOGS_DIR=R"($(SolutionDir))"

Step 2: Building the Engine

• Include the necessary headers in your source files.
• Link against the required libraries.
• Build the project using Visual Studio 2022.

Usage

Initialization

The engine is initialized and run through the WinMain function:

int WINAPI WinMain(_In_ HINSTANCE, _In_opt_ HINSTANCE, _In_ LPSTR, _In_ int)
{
    SUNENGINEAttorney::InitDestroy::Run();
    SUNENGINEAttorney::InitDestroy::Destroy();
    return 0;
}

LoadResources and Asset Management

The engine provides classes for managing the loading and unloading of game assets, including textures, models, and fonts.

TextureManager::Load("TextureName", "texture_file.tga");
ShaderManager::Load("ShaderName", "shader_file");
ModelManager::Load("ModelName", "model_file.azul");
ImageManager::Load("ImageName", TextureManager::Get("TextureName"));
SpriteFontManager::Load("FontName", "font_file.tga");
 
Texture* myTexture = TextureManager::Get("MyTexture");
Model* myModel = ModelManager::Get("MyModel");
SpriteFont* myFont = SpriteFontManager::Get("MyFont");
 
SceneManager::SetNextScene(new MyScene()); // Set the next scene to be loaded

Scene Management

Scenes are managed by the Scene class, which provides methods for initialization, updating, drawing, and ending the scene. GameObjects can be registered for updates, drawing, alarms, input, and collisions.

class MyScene : public Scene
{
public:
    void Initialize() override
    {
        // Initialization code here
    }
    void SceneEnd() override
    {
        // Cleanup code here
    }
};
 
// Setting the current scene
SceneManager::SetCurrentScene(new MyScene());

GameObject Management

GameObjects are the primary class for game entities that use the following components. They can be registered for updates, drawing, alarms, input, and collisions. The GameObject class provides a base implementation for game entities.

class MyGameObject : public GameObject
{
public:
    void SceneEntry() override
    {
        // Code to execute when the object enters the scene
        SubmitUpdateRegistration();
        SubmitDrawRegistration();
        SubmitAlarmRegistration(AlarmableManager::ALARM_ID::ALARM_0, 5.0f);
        SubmitKeyRegistration(AZUL_KEY::KEY_A, EventType::KEY_HELD);
        SubmitCollisionRegistration();
    }
 
    void SceneExit() override
    {
        // Code to execute when the object exits the scene
        SubmitUpdateDeregistration();
        SubmitDrawDeregistration();
        SubmitAlarmDeregistration(AlarmableManager::ALARM_ID::ALARM_0);
        SubmitKeyDeregistration(AZUL_KEY::KEY_A, EventType::KEY_HELD);
        SubmitCollisionDeregistration();
    }
 
    void Update() override
    {
        // Update logic here
    }
 
    void Draw() override
    {
        // Drawing logic here
    }
 
    void Draw2D() override
    {
        // 2D drawing logic here
    }
 
    void KeyInactive(AZUL_KEY key) override
    {
        // Key pressed logic here
    }
 
    void KeyPress(AZUL_KEY key) override
    {
        // Key pressed logic here
    }
 
    void KeyHeld(AZUL_KEY key) override
    {
        // Key pressed logic here
    }
 
    void KeyRelease(AZUL_KEY key) override
    {
        // Key released logic here
    }
 
    void Alarm0() override
    {
        // Alarm logic here
    }
 
    void Collision(GameObject* other) override
    {
        // Collision handling logic here
    }
};

Input Handling

The Inputable class provides a base implementation for handling keyboard input events. It manages registration and deregistration with the KeyboardEventManager.

class MyInputable : public GameObject
{
public:
    void KeyInactive(AZUL_KEY key) override
    {
        // Key pressed logic here
    }
 
    void KeyPress(AZUL_KEY key) override
    {
        // Key pressed logic here
    }
 
    void KeyHeld(AZUL_KEY key) override
    {
        // Key pressed logic here
    }
 
    void KeyRelease(AZUL_KEY key) override
    {
        // Key released logic here
    }
};
 
SubmitKeyRegistration(AZUL_KEY::KEY_A, EventType::KEY_HELD); // Register for key held events

Collision Detection

The Collidable class provides a base implementation for objects that need to participate in collision detection. It manages registration and deregistration with the CollisionManager.

class MyCollidable : public GameObject
{
public:
    void Collision(GameObject* other) override
    {
        // Collision handling logic here
    }
};
 
SetCollisionSelf<AdvancedFrigate>();
SetCollisionSelf<Cottage>();
SetCollisionPair<AdvancedFrigate, Cottage>(); // Set collision pairs for the scene
 
 
SetColliderModel(pGObj->getModel());
SetCollidableGroup<AdvancedFrigate>();
SubmitCollisionRegistration(); //Set the collision model and group in the GameObject.
 
this->UpdateCollisionData(world); // Ensure the collision data is up to date after movement.

Drawable Management

The Drawable class provides a base implementation for objects that need to be drawn during the game loop. It manages registration and deregistration with the DrawableManager.

class MyDrawable : public GameObject
{
public:
    void Draw() override
    {
        // Drawing logic here
    }
 
    void Draw2D() override
    {
        // 2D drawing logic here
    }
};
 
SubmitDrawRegistration(); // Register for drawing

Updatable Management

The Updatable class provides a base implementation for objects that need to be updated during the game loop. It manages registration and deregistration with the UpdatableManager.

class MyUpdatable : public GameObject
{
public:
    void Update() override
    {
        // Update logic here
    }
};
 
SubmitUpdateRegistration(); // Register for updates

Sprites and SpriteFonts

The engine provides classes for managing 2D sprites and sprite fonts for rendering text.

SUNENGINESprite* mySprite = new SUNENGINESprite("MySprite");
mySprite->SetPosition(100.0f, 150.0f);
mySprite->SetScaleFactor(0.5f, 0.5f);
 
SpriteString* myString = new SpriteString(SpriteFontManager::Get("Courier_New"), "Hello, World!", 10, 40);

Alarm System

The engine provides an alarm system that allows for timed events and actions within the game loop.

class MyAlarmable : public GameObject
{
public:
    void Alarm0() override
    {
        // Alarm logic here
    }
};
 
SubmitAlarmRegistration(AlarmableManager::ALARM_ID::ALARM_0, 5.0f); // Set an alarm for 5 seconds

Camera Management

The engine provides classes for managing the camera view for rendering scenes.

Camera* myCamera = new Camera(Camera::Type::PERSPECTIVE_3D);
myCamera->setOrientAndPosition(Vect(0.0f, 1.0f, 0.0f), Vect(0.0f, 0.0f, -1.0f), Vect(0.0f, 0.0f, 5.0f));