Tutorial 04: Custom cursor

Overview

This tutorial extends Tutorial 02 with a custom mouse cursor. Tutorial 02 creates Tutorial.cdc with the background and ship images. Tutorial 04 opens that archive, adds a cursor and its owned image, then loads every runtime resource from the CDC.

The render callback, fixed-rate movement, DebugWindow and Console remain unchanged so the new code stays focused on Cursor and CursorMgr.

Final result

CRM64Pro Tutorial 04 final result

Runtime controls

• Cursor keys: Move the ship image.
• D: Show or hide the debug window.
• Grave key: Show or hide the built-in console.
• Any key or mouse click: Write the input event to the log.
• Q or ESC: Exit the tutorial.

Prerequisites

• CRM64Pro GDK installed and configured with a supported C++17 compiler.
• Tutorial package downloaded and fully extracted, preserving its folder structure.
• Run Tutorial 02 first to create Tutorial.cdc with Tutorial_bg and Tutorial_ship.
• Included assets available under bin/Base/: tutorial_cursor.png.
• Write access to the platform output directory.

What you will learn

• Add a cursor resource to an existing CDC archive.
• Create a Cursor and assign an Image to it.
• Transfer Image ownership to a Cursor.
• Load Cursor and Image resources from a CDC archive.
• Set the cursor hotspot, select the cursor and make it visible.

Step by step

1. Verify the Tutorial 02 archive

Tutorial 04 adds a resource instead of creating a new archive. Checking the prerequisite first prevents an incomplete cursor-only CDC from being created when Tutorial 02 has not been run.

// Tutorial 04 introduces one new resource. Tutorial 02 already created
// the CDC with the background and ship.
mLog.msg(LL_INFO, "  Find Tutorial 02 CDC: %s ... ", OUTPUT_CDC);
if(!mC64.tool().fileExists(OUTPUT_CDC))
{
    logTaskFailed(mLog);
    return false;
}
logTaskOk(mLog);

2. Load the cursor image

The cursor starts as a normal PNG loaded through ImageMgr. Both the returned ID and borrowed Image pointer are checked before creating the Cursor.

mLog.msg(LL_INFO, "  Load cursor image: %s ... ", RESOURCE_CURSOR_IMAGE);
Sint32 idCursorImage = mC64.imageMgr().loadFromFile(RESOURCE_CURSOR_IMAGE, "tutorialCursorImageFile");
Image* pCursorImage = mC64.imageMgr().get(idCursorImage);
if(idCursorImage < 0 || pCursorImage == nullptr)
{
    logTaskFailed(mLog, idCursorImage);
    return false;
}
logTaskOk(mLog);

3. Create the Cursor and assign its Image

CursorMgr::create() returns an empty Cursor. Passing 1 to assignImage() transfers ownership of the loaded Image to that Cursor. Closing the Cursor will therefore also close its owned Image.

mLog.msg(LL_INFO, "  Create cursor from image ... ");
Sint32 idCursorFile = mC64.cursorMgr().create(RESOURCE_CURSOR_CDC_NAME);
Cursor* pCursorFile = mC64.cursorMgr().get(idCursorFile);
if(idCursorFile < 0 || pCursorFile == nullptr)
{
    logTaskFailed(mLog, idCursorFile);
    mC64.imageMgr().close(idCursorImage);
    return false;
}
if(pCursorFile->assignImage(idCursorImage, 1) < 0)
{
    logTaskFailed(mLog);
    mC64.cursorMgr().close(idCursorFile);
    mC64.imageMgr().close(idCursorImage);
    return false;
}
logTaskOk(mLog);

4. Save the Cursor to the CDC

Cursor::save() stores both the Cursor block and its associated Image block. An existing resource with the same name is replaced, so the tutorial can be run again against the same Tutorial 02 archive.

// Save appends or replaces the cursor resource in Tutorial.cdc.
mLog.msg(LL_INFO, "  Save cursor to CDC ... ");
if(pCursorFile->save(OUTPUT_CDC, RESOURCE_CURSOR_CDC_NAME) < 0)
{
    logTaskFailed(mLog);
    mC64.cursorMgr().close(idCursorFile);
    return false;
}
logTaskOk(mLog);
 
// Close the temporary cursor. The tutorial loads a fresh copy from CDC next.
mLog.msg(LL_INFO, "  Close temporary cursor ... ");
mC64.cursorMgr().close(idCursorFile);
logTaskOk(mLog);

5. Load all runtime resources from the CDC

The background and ship keep the names created by Tutorial 02. CursorMgr loads the new Cursor by its resource name and also restores its associated Image.

mLog.msg(LL_INFO, "  Load cursor from CDC ... ");
state.idCursor = mC64.cursorMgr().load(OUTPUT_CDC, RESOURCE_CURSOR_CDC_NAME);
Cursor* pCursor = mC64.cursorMgr().get(state.idCursor);
if(state.idCursor < 0 || pCursor == nullptr)
{
    logTaskFailed(mLog, state.idCursor);
    Main::terminate();
    return -1;
}
logTaskOk(mLog);

6. Configure and show the custom cursor

PH_CENTER places the cursor hotspot at the center of its image. CursorMgr then builds and selects the cursor before making it visible. Each operation is checked so setup stops cleanly if any step fails.

// Center hotspot is a good default for a game-style pointer.
mLog.msg(LL_INFO, "  Set cursor hotspot and select cursor ... ");
if(!pCursor->setHotSpot(PH_CENTER, PH_CENTER) ||
   mC64.cursorMgr().select(state.idCursor) < 0 ||
   !mC64.cursorMgr().show())
{
    logTaskFailed(mLog);
    Main::terminate();
    return -1;
}
logTaskOk(mLog);

7. Let CursorMgr draw the pointer

The render callback still draws only the background and ship. CursorMgr draws the selected mouse cursor automatically, so no cursor rendering code is added to renderFrame().

// Draw the current frame. CursorMgr draws the selected cursor automatically.
static void renderFrame(Image* pBgImage, Image* pPlayerImage, const TutorialState& rState)
{
    if(pBgImage) pBgImage->render();
 
    if(pPlayerImage)
    {
        SDL_FRect rDst = {
            rState.fPlayerX,
            rState.fPlayerY,
            static_cast<float>(pPlayerImage->getWidth()),
            static_cast<float>(pPlayerImage->getHeight())
        };
        pPlayerImage->render(0, nullptr, &rDst);
    }
}

8. Update logic and release resources

A quit request exits before the next fixed logic update. Cleanup closes cursors before images because each custom Cursor may own an Image.

if(!bRunning) break;
state.fMouseX = mC64.cursorMgr().getX();
state.fMouseY = mC64.cursorMgr().getY();
updateLogic(state, pPlayerImage, 1.0f / static_cast<float>(iLogicRate));

mLog.msg(LL_INFO, "  Close cursors ... ");
mC64.cursorMgr().close(0);
logTaskOk(mLog);
mLog.msg(LL_INFO, "  Close images ... ");
mC64.imageMgr().close(0);
logTaskOk(mLog);
mLog.msg(LL_INFO, "  Close CDC archives ... ");
mC64.archiveMgr().close(0);
logTaskOk(mLog);
Main::terminate();

Complete source

The tutorial source is authoritative. The following listing is included directly from validation/source/Tutorial_04_Cursor.cpp.

/* ----------------------------------------------------------------------
    CRM64Pro GDK - Roberto Prieto
    Copyright (C) 2013-2026 MegaStorm Systems
 
    This software is provided 'as-is', without any express or implied
    warranty. In no event will the authors be held liable for any damages
    arising from the use of this software.
 
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
 
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
 
------------------------------------------------------------------------
                        Tutorial 04: Cursor
------------------------------------------------------------------------
 
    Overview:
    This tutorial extends Tutorial 02 System with a custom cursor.
    Tutorial 02 creates Tutorial.cdc with the background and ship images.
    This tutorial adds the cursor to that CDC, then loads all resources from it.
 
    Key concepts:
    - Add a new cursor resource to an existing CDC file.
    - Create a Cursor from an Image.
    - Load Image and Cursor resources from a CDC file.
    - Select and show a custom cursor.
    - Keep the render callback, debug window and console from Tutorial 02.
 
    Controls:
    - Cursor Keys: Move the ship image.
    - D: Toggle debug window.
    - Grave: Toggle console.
    - Any Key/Mouse: Logs events.
    - Q / ESC: Quit.
 
    Loop order:
    - Process input events.
    - Run one fixed logic update.
    - Let Main::update() call the screen render callback.
------------------------------------------------------------------------ */
 
#include "CRM64Pro.h"
#include "RunParameter.h"
 
using namespace CRM64Pro;
 
#define BASEDIR "Base/"
#ifdef CRM64PRO_PLATFORM_WINDOWS
#define OUTPUTDIR "Win64/"
#elif defined(CRM64PRO_PLATFORM_LINUX)
#define OUTPUTDIR "Linux/"
#elif defined(CRM64PRO_PLATFORM_MACOS)
#define OUTPUTDIR "macOS/"
#endif
 
#define RESOURCE_CURSOR_IMAGE BASEDIR"tutorial_cursor.png"
#define RESOURCE_BG_CDC_NAME "Tutorial_bg"
#define RESOURCE_PLAYER_CDC_NAME "Tutorial_ship"
#define RESOURCE_CURSOR_CDC_NAME "Tutorial_cursor"
#define OUTPUT_CDC OUTPUTDIR"Tutorial.cdc"
 
// Fixed-rate timing.
// Render rate 0 lets the screen render as often as possible. Logic rate controls movement.
static const Sint32 iLogicRate = 20;
static const Sint32 iRenderRate = 0;
 
// Window size and movement speed.
static const Sint32 iScreenW = 960;
static const Sint32 iScreenH = 540;
static const float fMoveSpeed = 220.0f;
 
// Values changed while the tutorial runs.
struct TutorialState
{
    Sint32 idBgImage = -1;
    Sint32 idPlayerImage = -1;
    Sint32 idCursor = -1;
    Sint32 idDebugWindow = -1;
    float fPlayerX = 386.0f;
    float fPlayerY = 186.0f;
    float fMouseX = 0.0f;
    float fMouseY = 0.0f;
    Sint32 iLogicFrames = 0;
    bool bMoveLeft = false;
    bool bMoveRight = false;
    bool bMoveUp = false;
    bool bMoveDown = false;
};
 
// Keep a value inside the given range.
static float clampFloat(float fValue, float fMin, float fMax)
{
    if(fValue < fMin) return fMin;
    if(fValue > fMax) return fMax;
    return fValue;
}
 
// Helper functions used by the setup log messages.
static void logTaskOk(Log& mLog)
{
    mLog.msg(LL_DEBUG, "OK\n");
}
 
// Record a failed tutorial task.
static void logTaskFailed(Log& mLog, Sint32 iCode)
{
    mLog.msg(LL_ERROR, "FAILED (Code %d)\n", iCode);
}
 
// Record a failed tutorial task.
static void logTaskFailed(Log& mLog)
{
    mLog.msg(LL_ERROR, "FAILED\n");
}
 
// Move the ship image one fixed logic step.
static void updateLogic(TutorialState& rState, Image* pPlayerImage, float fDeltaTime)
{
    if(!pPlayerImage) return;
 
    float fDX = 0.0f;
    float fDY = 0.0f;
 
    if(rState.bMoveLeft) fDX -= fMoveSpeed * fDeltaTime;
    if(rState.bMoveRight) fDX += fMoveSpeed * fDeltaTime;
    if(rState.bMoveUp) fDY -= fMoveSpeed * fDeltaTime;
    if(rState.bMoveDown) fDY += fMoveSpeed * fDeltaTime;
 
    const float fMaxX = static_cast<float>(iScreenW - pPlayerImage->getWidth());
    const float fMaxY = static_cast<float>(iScreenH - pPlayerImage->getHeight());
    rState.fPlayerX = clampFloat(rState.fPlayerX + fDX, 0.0f, fMaxX);
    rState.fPlayerY = clampFloat(rState.fPlayerY + fDY, 0.0f, fMaxY);
    rState.iLogicFrames++;
}
 
// Draw the current frame. CursorMgr draws the selected cursor automatically.
static void renderFrame(Image* pBgImage, Image* pPlayerImage, const TutorialState& rState)
{
    if(pBgImage) pBgImage->render();
 
    if(pPlayerImage)
    {
        SDL_FRect rDst = {
            rState.fPlayerX,
            rState.fPlayerY,
            static_cast<float>(pPlayerImage->getWidth()),
            static_cast<float>(pPlayerImage->getHeight())
        };
        pPlayerImage->render(0, nullptr, &rDst);
    }
}
 
// Screen render callback.
// Main::update() calls this when the screen is ready to render.
static Sint32 renderWrapper(Sint32, void* pObj)
{
    TutorialState* pState = static_cast<TutorialState*>(pObj);
    if(!pState) return 0;
 
    ImageMgr& mImageMgr = Main::instance().imageMgr();
    Image* pBgImage = mImageMgr.get(pState->idBgImage);
    Image* pPlayerImage = mImageMgr.get(pState->idPlayerImage);
    renderFrame(pBgImage, pPlayerImage, *pState);
 
    return 0;
}
 
// Show or hide the debug window.
static void toggleDebugWindow(DebugWindow* pDebug)
{
    if(!pDebug) return;
    if(pDebug->baseWidget().status() == GS_SHOWN) pDebug->baseWidget().hide();
    else pDebug->baseWidget().show();
}
 
// Add the cursor resource to the tutorial archive.
static bool addCursorToCDC(Main& mC64, Log& mLog)
{
    // Tutorial 04 introduces one new resource. Tutorial 02 already created
    // the CDC with the background and ship.
    mLog.msg(LL_INFO, "  Find Tutorial 02 CDC: %s ... ", OUTPUT_CDC);
    if(!mC64.tool().fileExists(OUTPUT_CDC))
    {
        logTaskFailed(mLog);
        return false;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "  Load cursor image: %s ... ", RESOURCE_CURSOR_IMAGE);
    Sint32 idCursorImage = mC64.imageMgr().loadFromFile(RESOURCE_CURSOR_IMAGE, "tutorialCursorImageFile");
    Image* pCursorImage = mC64.imageMgr().get(idCursorImage);
    if(idCursorImage < 0 || pCursorImage == nullptr)
    {
        logTaskFailed(mLog, idCursorImage);
        return false;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "  Create cursor from image ... ");
    Sint32 idCursorFile = mC64.cursorMgr().create(RESOURCE_CURSOR_CDC_NAME);
    Cursor* pCursorFile = mC64.cursorMgr().get(idCursorFile);
    if(idCursorFile < 0 || pCursorFile == nullptr)
    {
        logTaskFailed(mLog, idCursorFile);
        mC64.imageMgr().close(idCursorImage);
        return false;
    }
    if(pCursorFile->assignImage(idCursorImage, 1) < 0)
    {
        logTaskFailed(mLog);
        mC64.cursorMgr().close(idCursorFile);
        mC64.imageMgr().close(idCursorImage);
        return false;
    }
    logTaskOk(mLog);
 
    // Save appends or replaces the cursor resource in Tutorial.cdc.
    mLog.msg(LL_INFO, "  Save cursor to CDC ... ");
    if(pCursorFile->save(OUTPUT_CDC, RESOURCE_CURSOR_CDC_NAME) < 0)
    {
        logTaskFailed(mLog);
        mC64.cursorMgr().close(idCursorFile);
        return false;
    }
    logTaskOk(mLog);
 
    // Close the temporary cursor. The tutorial loads a fresh copy from CDC next.
    mLog.msg(LL_INFO, "  Close temporary cursor ... ");
    mC64.cursorMgr().close(idCursorFile);
    logTaskOk(mLog);
 
    return true;
}
 
// Run the tutorial application and release its resources.
int main(int argc, char* argv[])
{
    eConfigRendererDriver eRenderer = CRD_SOFTWARE;
    if(!runParameterReadRender(argc, argv, eRenderer)) return 1;
 
    // Start CRM64Pro memory tracking before creating engine resources.
    // atexit() releases memory tracking data when the program exits.
    CMem::setStatsLevel(CMem::MSL_NORMAL);
    atexit(CMem::destroy);
 
    // Main gives access to the CRM64Pro managers.
    Main& mC64 = Main::instance();
    Log& mLog = *mC64.logMgr().get();
 
    TutorialState state;
 
    // Write log output to stdout and to a file under validation/bin.
    mLog.init("Tutorial_04_Cursor", LL_DEBUG, LM_FILE | LM_STDOUT, OUTPUTDIR"Tutorial_04_Cursor.log");
 
    mLog.msg(LL_INFO, "\nSETUP: screen and timing\n");
 
    // Initialize the timer before calling Main::update().
    // setRate() receives render frames per second, then logic frames per second.
    mLog.msg(LL_INFO, "  Initialize timer ... ");
    if(!mC64.timer().init())
    {
        logTaskFailed(mLog);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "  Set frame rates (render=%d, logic=%d) ... ", iRenderRate, iLogicRate);
    if(!mC64.timer().setRate(iRenderRate, iLogicRate))
    {
        logTaskFailed(mLog);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    // Add a 1 ms idle delay inside Main::update().
    mC64.configMgr().setMTFriendly(1);
 
    // Configure and show the default screen.
    Screen* pScreen = mC64.configMgr().get();
    pScreen->setSize(iScreenW, iScreenH);
    pScreen->setDriver(eRenderer);
    pScreen->setTitle("CRM64Pro - Tutorial 04: Cursor");
 
    mLog.msg(LL_INFO, "  Create screen (%dx%d) ... ", iScreenW, iScreenH);
    if(pScreen->show() < 0)
    {
        mLog.msg(LL_CRITICAL, "FAILED\n");
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "  Set render callback ... ");
    if(!pScreen->setRenderCallback([&state](Sint32 iMode) { return renderWrapper(iMode, &state); }))
    {
        logTaskFailed(mLog);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "\nRESOURCES: add cursor and load from CDC\n");
 
    if(!addCursorToCDC(mC64, mLog))
    {
        Main::terminate();
        return -1;
    }
 
    // From this point, all runtime resources are loaded from Tutorial.cdc.
    mLog.msg(LL_INFO, "  Load background image from CDC ... ");
    state.idBgImage = mC64.imageMgr().load(OUTPUT_CDC, RESOURCE_BG_CDC_NAME);
    if(state.idBgImage < 0)
    {
        logTaskFailed(mLog, state.idBgImage);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "  Load ship image from CDC ... ");
    state.idPlayerImage = mC64.imageMgr().load(OUTPUT_CDC, RESOURCE_PLAYER_CDC_NAME);
    if(state.idPlayerImage < 0)
    {
        logTaskFailed(mLog, state.idPlayerImage);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    Image* pPlayerImage = mC64.imageMgr().get(state.idPlayerImage);
    if(pPlayerImage == nullptr)
    {
        logTaskFailed(mLog);
        Main::terminate();
        return -1;
    }
 
    mLog.msg(LL_INFO, "  Load cursor from CDC ... ");
    state.idCursor = mC64.cursorMgr().load(OUTPUT_CDC, RESOURCE_CURSOR_CDC_NAME);
    Cursor* pCursor = mC64.cursorMgr().get(state.idCursor);
    if(state.idCursor < 0 || pCursor == nullptr)
    {
        logTaskFailed(mLog, state.idCursor);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    // Center hotspot is a good default for a game-style pointer.
    mLog.msg(LL_INFO, "  Set cursor hotspot and select cursor ... ");
    if(!pCursor->setHotSpot(PH_CENTER, PH_CENTER) ||
       mC64.cursorMgr().select(state.idCursor) < 0 ||
       !mC64.cursorMgr().show())
    {
        logTaskFailed(mLog);
        Main::terminate();
        return -1;
    }
    logTaskOk(mLog);
 
    mLog.msg(LL_INFO, "\nTOOLS: debug window and console\n");
 
    // The DebugWindow displays live values while the program runs.
    mLog.msg(LL_INFO, "  Create debug window ... ");
    state.idDebugWindow = mC64.guiMgr().create("Debug", CRM64PRO_GUI_DEBUGWINDOW);
    DebugWindow* pDebug = mC64.guiMgr().getDebugWindow(state.idDebugWindow);
    if(!pDebug)
    {
        logTaskFailed(mLog, state.idDebugWindow);
        Main::terminate();
        return -1;
    }
    pDebug->baseWidget().setPosition(Position(PH_RIGHT, -120), Position(PH_TOP, 10));
    pDebug->addWatch("Player X", nullptr, &state.fPlayerX);
    pDebug->addWatch("Player Y", nullptr, &state.fPlayerY);
    pDebug->addWatch("Mouse X", nullptr, &state.fMouseX);
    pDebug->addWatch("Mouse Y", nullptr, &state.fMouseY);
    pDebug->addWatch("Logic frames", &state.iLogicFrames);
    pDebug->baseWidget().show();
    logTaskOk(mLog);
 
    // Main creates the default Console. Log output is also sent there.
    Console* pConsole = mC64.guiMgr().getConsole();
    if(pConsole) pConsole->print("Tutorial 04: Cursor ready. Press ` to toggle the console.\n");
 
    mLog.msg(LL_INFO, "\nCONTROLS\n");
    mLog.msg(LL_INFO, "  [Q] / [ESC] Quit\n");
    mLog.msg(LL_INFO, "  [Arrow Keys] Move the ship image\n");
    mLog.msg(LL_INFO, "  [D] Toggle debug window\n");
    mLog.msg(LL_INFO, "  [`] Toggle console\n");
    mLog.msg(LL_INFO, "  Any key or mouse button logs the input event\n");
    mLog.msg(LL_INFO, "\nRUNNING\n");
 
    SDL_Event event;
    bool bRunning = true;
    while(bRunning)
    {
        // Main::update() processes input, runs internal GUI logic and calls the
        // screen render callback when a render frame is ready.
        while(mC64.update(&event))
        {
            if(event.type == SDL_EVENT_QUIT)
            {
                bRunning = false;
            }
            else if(event.type == SDL_EVENT_KEY_DOWN)
            {
                // SDL3 stores the key value in event.key.key.
                mLog.msg(LL_INFO, "  Key pressed: %s (%d)\n", SDL_GetKeyName(event.key.key), event.key.key);
 
                if(event.key.key == SDLK_Q || event.key.key == SDLK_ESCAPE)
                {
                    bRunning = false;
                }
                else if(event.key.key == SDLK_LEFT)
                {
                    state.bMoveLeft = true;
                }
                else if(event.key.key == SDLK_RIGHT)
                {
                    state.bMoveRight = true;
                }
                else if(event.key.key == SDLK_UP)
                {
                    state.bMoveUp = true;
                }
                else if(event.key.key == SDLK_DOWN)
                {
                    state.bMoveDown = true;
                }
                else if(event.key.key == SDLK_D)
                {
                    toggleDebugWindow(pDebug);
                }
            }
            else if(event.type == SDL_EVENT_KEY_UP)
            {
                if(event.key.key == SDLK_LEFT) state.bMoveLeft = false;
                else if(event.key.key == SDLK_RIGHT) state.bMoveRight = false;
                else if(event.key.key == SDLK_UP) state.bMoveUp = false;
                else if(event.key.key == SDLK_DOWN) state.bMoveDown = false;
            }
            else if(event.type == SDL_EVENT_MOUSE_BUTTON_DOWN)
            {
                mLog.msg(LL_INFO, "  Mouse clicked: button %d at %d, %d\n", event.button.button, (Sint32)event.button.x, (Sint32)event.button.y);
            }
        }
 
        if(!bRunning) break;
        state.fMouseX = mC64.cursorMgr().getX();
        state.fMouseY = mC64.cursorMgr().getY();
        updateLogic(state, pPlayerImage, 1.0f / static_cast<float>(iLogicRate));
    }
 
    // Close resources owned by this tutorial.
    mC64.cursorMgr().info();
    mLog.msg(LL_INFO, "\nCLEANUP\n");
    mLog.msg(LL_INFO, "  Close debug window ... ");
    mC64.guiMgr().close(state.idDebugWindow);
    logTaskOk(mLog);
    mLog.msg(LL_INFO, "  Close cursors ... ");
    mC64.cursorMgr().close(0);
    logTaskOk(mLog);
    mLog.msg(LL_INFO, "  Close images ... ");
    mC64.imageMgr().close(0);
    logTaskOk(mLog);
    mLog.msg(LL_INFO, "  Close CDC archives ... ");
    mC64.archiveMgr().close(0);
    logTaskOk(mLog);
    Main::terminate();
 
    return 0;
}

Navigation

Previous: Tutorial 03 - Configuration

Back to the tutorials index

The next tutorial adds bitmap fonts and renders text.

Continue with Tutorial 05: Fonts