Main page

Table of contents

• Setting up SDL3 for Windows using CMake and MinGW-w64
• Compilation a very simple "Hello, World" example to EXE
• Creating a window using SDL3 and writing code in the separated "main.cpp" file
• How to hide the console
• Setting the background color using OpenGL with the GLAD library
• Qt Creator IDE
• Creating an OpenGL window in Qt Creator
• Embeding text files to EXE using the "embed" library
• Embeding textures to EXE using the "embed" library
• Building ImGUI statically and setting up it to the CMake project
• Setting up Box2D

Setting up SDL3 for Windows using CMake and MinGW-w64

• Download and unzip MinGW-w64: https://winlibs.com/ I have downloaded GCC 11.2.0 + MinGW-w64 10.0.0 (UCRT) - release 1, Win64. This archive contains the "mingw64" folder. Unzip the "mingw64" folder on the C drive (or on the another drive). It requires 672 MB on your hard disk
• The "mingw64" folder contains the "bin" folder. Add the "C:\mingw64\bin" path to the Path environment variable
• Download and install CMake: https://cmake.org/download/ Download "Windows x64 Installer" and install it
• Check that "mingw32-make" and "cmake" is available from the console:

cmake --version
mingw32-make --version

• I use CMake v3.27.7
• Download SDL3 sources from GitHub (Code > Download ZIP)
• Unzip the downloaded archive. Open the console terminal inside the folder
• Copy and paste the following command to the console for the configuration. Replace the installation path to your path if you need:

cmake -G "MinGW Makefiles" --fresh -S . -B dist -DCMAKE_INSTALL_PREFIX=E:\libs\sdl3-desktop-prefix

• It requires 3 minutes 20 seconds
• Note. If you want the pure OpenGL use this command:

cmake -G "MinGW Makefiles" --fresh -S . -B dist -DCMAKE_INSTALL_PREFIX=E:\libs\sdl3-desktop-prefix -DSDL_AUDIO=OFF -DSDL_CAMERA=OFF -DSDL_HAPTIC=OFF -DSDL_HIDAPI=OFF -DSDL_POWER=OFF -DSDL_SENSOR=OFF -DSDL_DIALOG=OFF

• On my laptop, the second command above takes 2 minutes and 55 seconds to complete
• Copy and paste the build command:

cmake --build dist -j4

• Time: 1m 20s for the both configurations above
• Copy and paste the installation command:

cmake --install dist

• You can find the generated DLL inside of the installation folder that you write after "-DCMAKE_INSTALL_PREFIX="
• Size of SDL3.dll for the first configuration: 11.6 MB or 11,924 KB
• Size of SDL3.dll for the second configuration: 10.1 MB or 10,381 KB
• The size can be reduced using UPX to 2.75 MB or 2,818 KB

upx.exe --best SDL3.dll

Compilation a very simple "Hello, World" example to EXE

• Create a folder for a project. You can use this command in the console:

mkdir my-project

• Move to the created folder:

cd my-project

• Create the "CMakeLists.txt" file in the project folder with the content below:

cmake_minimum_required(VERSION 3.20)
project(my_project)
find_package(SDL3)
file(WRITE main.cpp "#include <SDL3/SDL.h>\nint main() {SDL_Init(0);SDL_Quit();return 0;}")
add_executable(app main.cpp)
target_link_libraries(app PRIVATE SDL3::SDL3)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

• Create a folder for building the project:

mkdir dist\win

• Move to the "dist" folder:

cd dist

• Copy and paste the configuration command:

cmake -G "MinGW Makefiles" --fresh -S .. -B ..\dist\win -DSDL3_DIR=E:\libs\sdl3-desktop-prefix\lib\cmake\SDL3

• Move to the "win" folder:

cd win

• Type the build command:

mingw32-make

• The "app.exe" file was created. Run it:

app

• Note. You can embed the following libraries to the EXE (but SDL3.dll and libwinpthread-1.dll must be distributed with the EXE):

target_link_options(app PRIVATE -static-libgcc -static-libstdc++)

• This project doesn't show anything. Let's create a new project with a window below

Creating a window using SDL3 and writing code in the separated "main.cpp" file

The previous example creates "main.cpp" inside of the "CMakeLists.txt" using "file(WRITE... )":

file(WRITE main.cpp "#include <SDL3/SDL.h>\nint main() {SDL_Init(0);SDL_Quit();return 0;}")

Let's create our "main.cpp" and a window.

• Create a folder for a project. You can use this command in the console:

mkdir create-a-window

• Move to the created folder:

cd create-a-window

• Create the "CMakeLists.txt" file in the created folder with the content below:

cmake_minimum_required(VERSION 3.20)

project(create_a_window)
add_executable(app main.cpp)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

find_package(SDL3)
target_link_libraries(app PRIVATE SDL3::SDL3)
target_compile_definitions(app PRIVATE SDL_MAIN_USE_CALLBACKS)

• Create the "main.cpp" file in the created folder with the content below:
main.cpp (Click here to view the full content)

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>

struct AppContext
{
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_AppResult app_quit = SDL_APP_CONTINUE;
};

SDL_AppResult SDL_Fail()
{
    SDL_LogError(SDL_LOG_CATEGORY_CUSTOM, "Error %s", SDL_GetError());
    return SDL_APP_FAILURE;
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        return SDL_Fail();
    }

    SDL_Window *window = SDL_CreateWindow("Window", 352, 430,
        SDL_WINDOW_RESIZABLE);
    if (!window)
    {
        return SDL_Fail();
    }

    SDL_Renderer *renderer = SDL_CreateRenderer(window, NULL);
    if (!renderer)
    {
        return SDL_Fail();
    }

    SDL_ShowWindow(window);

    *appstate = new AppContext {
        window,
        renderer,
    };

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, const SDL_Event *event)
{
    auto *app = (AppContext *)appstate;

    if (event->type == SDL_EVENT_QUIT)
    {
        app->app_quit = SDL_APP_SUCCESS;
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    SDL_SetRenderDrawColor(app->renderer, 128, 255, 128, SDL_ALPHA_OPAQUE);
    SDL_RenderClear(app->renderer);
    SDL_RenderPresent(app->renderer);

    return app->app_quit;
}

void SDL_AppQuit(void *appstate)
{
    auto *app = (AppContext *)appstate;
    if (app)
    {
        SDL_DestroyRenderer(app->renderer);
        SDL_DestroyWindow(app->window);
        delete app;
    }
    SDL_Quit();
}

• Create a folder for building the project:

mkdir dist\win

• Move to the "dist" folder:

cd dist

• Copy and paste the configuration command:

cmake -G "MinGW Makefiles" --fresh -S .. -B ..\dist\win -DSDL3_DIR=E:\libs\sdl3-desktop-prefix\lib\cmake\SDL3

• Move to the "win" folder:

cd win

• Type the build command:

mingw32-make

• The "app.exe" file was created. Run it:

app

• This project doesn't show anything. Let's create a new project with a window below

How to hide the console

When you run the "app.exe" from the example above you see a window and the console. Let's hide the console

• There are two ways to hide the console (see source on the Discord):
• Using WIN32:

add_executable(app WIN32)

• Using the "-mwindows" flag:

target_link_options(app PRIVATE "-mwindows")

• The first way works with MinGW and MSVC. You can download MSVC without Visual Studio using this gist. It is around ~1GB for the compiler toolchain and the Windows SDK

Setting the background color using OpenGL with the GLAD library

• If you haven't installed MinGW, CMake, and SDL3, please refer to this guide: Setting up SDL3 for Windows using CMake and MinGW-w64
• Let's setup GLAD to define OpenGL functions. Google "glad online opengl generator". You will find this link: https://glad.dav1d.de/
• In the "API > gl" select the OpenGL API version what do you want. I prefer to use "Version 2.1" because it is very similar to OpenGL ES 2.0 that is enough for me
• Scroll to the bottom of the page and click on the "Generate" button
• Click on the "glad.zip" archive. Unzip in somewhere. For example: "E:\libs\glad-2.0.6"
• Create an empty project folder somewhere and two files inside it and copy the following content to these files:
CMakeLists.txt (Click here to view the full content)

cmake_minimum_required(VERSION 3.20)

project(background_color)
add_executable(app) # WIN32

target_include_directories(app PRIVATE E:/libs/glad-2.0.6/include)

target_sources(app
PRIVATE
    E:/libs/glad-2.0.6/src/glad.c
    main.cpp
)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

find_package(SDL3)
target_link_libraries(app PRIVATE SDL3::SDL3)
target_compile_definitions(app PRIVATE SDL_MAIN_USE_CALLBACKS)
target_link_options(app PRIVATE -static-libgcc -static-libstdc++)

main.cpp (Click here to view the full content)

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <glad/glad.h>

#include <iostream>

struct AppContext
{
    SDL_Window *window;
    SDL_GLContext glContext;
    SDL_AppResult appQuit = SDL_APP_CONTINUE;
};

SDL_AppResult SDL_Fail()
{
    SDL_LogError(SDL_LOG_CATEGORY_CUSTOM, "Error %s", SDL_GetError());
    return SDL_APP_FAILURE;
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    // Init the library, here we make a window so we only need the Video capabilities.
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        return SDL_Fail();
    }

    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); // Enable MULTISAMPLE
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2); // can be 2, 4, 8 or 16

    // Create a window
    SDL_Window *window = SDL_CreateWindow("SDL3, OpenGL 2.1, C++", 350, 350,
        SDL_WINDOW_OPENGL); // | SDL_WINDOW_RESIZABLE
    if (!window)
    {
        return SDL_Fail();
    }

    SDL_GLContext glContext = SDL_GL_CreateContext(window);
    if (!glContext)
    {
        return SDL_Fail();
    }

    if (!gladLoadGL())
    {
        std::cout << "Failed to load OpenGL functions" << std::endl;
        return SDL_APP_FAILURE;
    }

    glClearColor(0.2f, 0.3f, 0.5f, 1.f);

    SDL_ShowWindow(window);

    // Set up the application data
    *appstate = new AppContext {
        window,
        glContext,
    };

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, const SDL_Event *event)
{
    auto *app = (AppContext *)appstate;

    switch (event->type)
    {
        case SDL_EVENT_QUIT:
        {
            app->appQuit = SDL_APP_SUCCESS;
            break;
        }
        default:
        {
            break;
        }
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    glClear(GL_COLOR_BUFFER_BIT);

    SDL_GL_SwapWindow(app->window);

    return app->appQuit;
}

void SDL_AppQuit(void *appstate)
{
    auto *app = (AppContext *)appstate;
    if (app)
    {
        SDL_GL_DestroyContext(app->glContext);
        SDL_DestroyWindow(app->window);
        delete app;
    }

    SDL_Quit();
}

• Open the console in the current project folder
• Create the "dist\win" folder:

mkdir dist\win

• Go to the "dist" folder:

cd dist

• Copy and paste the following command to the console to configure the project:

cmake -G "MinGW Makefiles" --fresh -S .. -B ../dist/win -DSDL3_DIR=E:/libs/sdl3-desktop-prefix/lib/cmake/SDL3

• Go to the generated "win" folder by typing the following command in the console:

cd win

• Run the following command to building the project and creating the "app.exe":

mingw32-make

• The "app.exe" was created in the "win" folder. You can run "app.exe" by running the following command:

app

• Install UPX and make "app.exe" smaller:

upx.exe --best app.exe

• Source code:
• GitHub
• Dropbox - 1.81 KB
• Archive with EXE for Windows 10 64-bit - 2.57 MB, unzipped - 4.48 MB
• Screenshot

Qt Creator IDE

You can open and the previous project in the Qt Creator

• Press in the Qt Creator menu: "File" > "Open File or Project..."
• Select "CMakeLists.txt" and press "Open"
• Press "Configure project" in the new opened window
• Click "Projects" on the left panel
• Add a new key to the "Initial Configuration". Press "ADD" > "Directory":

Key: SDL3_DIR
Value: E:\libs\sdl3-desktop-prefix\lib\cmake\SDL3

• Press the "Re-configure with Initial Parameters" button below. Press "Yes"
• Return to the "Edit" tab on the left panel
• Run the project by pressing on "Ctrl+R" or click a green triangle at the bottom left
• You can set breakpoint and run your programs step by step for debugging

Creating an OpenGL window in Qt Creator

• Create the empty "opengl-window" folder and "CMakeLists.txt" inside it
• Create the empty "main.cpp" inside of the empty "opengl-window" folder
• Press in the Qt Creator menu: "File" > "Open File or Project..."
• Select "CMakeLists.txt" and press "Open"
• Press "Cofigure project" in the new openned window
• Double click on the "CMakeLists.txt" file inside of Qt Creator
• Write the following command to rename the project:

project("opengl_window")

• Press Ctrl+S. You can see that project was renamed in Qt Creator to "opengl_window"
• Add the following content to the "CMakeLists.txt" file:

cmake_minimum_required(VERSION 3.20)

project(opengl_window)
add_executable(app main.cpp)

target_sources(app
PRIVATE 
    src/main.cpp
    src/math_helper.cpp
    src/shader_program.cpp
    E:/libs/glad-2.0.6/src/glad.c
)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

find_package(SDL3)
target_link_libraries(app PRIVATE SDL3::SDL3)
target_compile_definitions(app PRIVATE SDL_MAIN_USE_CALLBACKS)

• Click "Projects" on the left panel
• Add a new key to the "Initial Configuration". Press "ADD" > "Directory":

Key: SDL3_DIR
Value: E:\libs\sdl3-desktop-prefix\lib\cmake\SDL3

• Press the "Re-configure with Initial Parameters" button below. Press "Yes"
• Return to the "Edit" tab on the left panel
• Copy and paste the following content to the "main.cpp" file
main.cpp (Click here to view the full content)

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>

struct AppContext
{
    SDL_Window *window;
    SDL_GLContext glcontext;
    SDL_AppResult app_quit = SDL_APP_CONTINUE;
};

SDL_AppResult SDL_Fail()
{
    SDL_LogError(SDL_LOG_CATEGORY_CUSTOM, "Error %s", SDL_GetError());
    return SDL_APP_FAILURE;
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    // Init the library, here we make a window so we
    // only need the Video capabilities
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        return SDL_Fail();
    }

    // Create a window
    SDL_Window *window = SDL_CreateWindow("OpenGL Window", 350, 350,
        SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    if (!window)
    {
        return SDL_Fail();
    }

    SDL_GLContext glcontext = SDL_GL_CreateContext(window);
    if (!glcontext)
    {
        return SDL_Fail();
    }

    SDL_ShowWindow(window);

    // Set up the application data
    *appstate = new AppContext {
        window,
        glcontext,
    };

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, const SDL_Event *event)
{
    auto *app = (AppContext *)appstate;

    switch (event->type)
    {
        case SDL_EVENT_QUIT:
        {
            app->app_quit = SDL_APP_SUCCESS;
            break;
        }
        default:
        {
            break;
        }
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    SDL_GL_SwapWindow(app->window);

    return app->app_quit;
}

void SDL_AppQuit(void *appstate)
{
    auto *app = (AppContext *)appstate;
    if (app)
    {
        SDL_GL_DestroyContext(app->glcontext);
        SDL_DestroyWindow(app->window);
        delete app;
    }

    SDL_Quit();
}

• Run the project by pressing on "Ctrl+R" or click a green triangle at the bottom left. You will see a window with a black canvas. Let's set the canvas to green
• Add the glClearColor() and glClear() function calls in the SDL_AppIterate():

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    glClearColor(0.f, 0.5f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);

    SDL_GL_SwapWindow(app->window);

    return app->app_quit;
}

• If you run the current project you will see the following errors

error: 'glClearColor' was not declared in this scope
error: 'GL_COLOR_BUFFER_BIT' was not declared in this scope
error: 'glClear' was not declared in this scope

• Let's setup GLAD to solve these errors. Google "glad online opengl generator". You will find this link: https://glad.dav1d.de/
• In the "API > gl" select the OpenGL API version what do you want. I prefer to use "Version 2.1" because it is very similar to OpenGL ES 2.0 that is enough for me
• Scroll to the bottom of the page and click on the "Generate" button
• Click on the "glad.zip" archive. Unzip in somewhere. For example: "E:\libs\glad-2.0.6"
• Add the following commands to the "CMakeLists.txt" file to setup GLAD in the project:

target_include_directories(app PRIVATE E:/libs/glad-2.0.6/include)

target_sources(app
PRIVATE
    main.cpp
    E:/libs/glad-2.0.6/src/glad.c
)

• Add the following line of the code to the "main.cpp" file to include glad to the project:

#include <glad/glad.h>

• The gladLoadGL() function must be called after SDL_GL_CreateContext()

if (!gladLoadGL())
{
    std::cout << "Failed to load OpenGL functions" << std::endl;
    return SDL_APP_FAILURE;
}

• Add "iostream" to print to the console:

#include <iostream>

• Run the project by pressing on "Ctrl+R" or click a green triangle at the bottom left
• You will see a window with a black canvas
• The final code for this example:
CMakeLists.txt (Click here to view the full content)

cmake_minimum_required(VERSION 3.20)

project(opengl_window)
add_executable(app)

target_include_directories(app PRIVATE E:/libs/glad-2.0.6/include)

target_sources(app
PRIVATE
    main.cpp
    E:/libs/glad-2.0.6/src/glad.c
)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

find_package(SDL3)
target_link_libraries(app PRIVATE SDL3::SDL3)
target_compile_definitions(app PRIVATE SDL_MAIN_USE_CALLBACKS)

main.cpp (Click here to view the full content)

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>

#include <glad/glad.h>
#include <iostream>

struct AppContext
{
    SDL_Window *window;
    SDL_GLContext glcontext;
    SDL_AppResult app_quit = SDL_APP_CONTINUE;
};

SDL_AppResult SDL_Fail()
{
    SDL_LogError(SDL_LOG_CATEGORY_CUSTOM, "Error %s", SDL_GetError());
    return SDL_APP_FAILURE;
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    // Init the library, here we make a window so we
    // only need the Video capabilities
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        return SDL_Fail();
    }

    // Create a window
    SDL_Window *window = SDL_CreateWindow("OpenGL Window", 350, 350,
        SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    if (!window)
    {
        return SDL_Fail();
    }

    SDL_GLContext glcontext = SDL_GL_CreateContext(window);
    if (!glcontext)
    {
        return SDL_Fail();
    }

    if (!gladLoadGL())
    {
        std::cout << "Failed to load OpenGL functions" << std::endl;
        return SDL_APP_FAILURE;
    }

    SDL_ShowWindow(window);

    // Set up the application data
    *appstate = new AppContext {
        window,
        glcontext,
    };

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, const SDL_Event *event)
{
    auto *app = (AppContext *)appstate;

    switch (event->type)
    {
        case SDL_EVENT_QUIT:
        {
            app->app_quit = SDL_APP_SUCCESS;
            break;
        }
        default:
        {
            break;
        }
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    glClearColor(0.f, 0.5f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);

    SDL_GL_SwapWindow(app->window);

    return app->app_quit;
}

void SDL_AppQuit(void *appstate)
{
    auto *app = (AppContext *)appstate;
    if (app)
    {
        SDL_GL_DestroyContext(app->glcontext);
        SDL_DestroyWindow(app->window);
        delete app;
    }

    SDL_Quit();
}

Embeding text files to EXE using the "embed" library

Let's create a text file and embed it in the EXE. We'll print the contents of the text file to the console

• Create a folder for a project. You can use this command in the console:

mkdir embeded-text-file

• Move to the created folder:

cd embeded-text-file

• Create the "assets" folder and the "hello-world.txt" file inside it with the following text:

Hello, World!

• Create the "CMakeLists.txt" file in the project folder with the content below:

cmake_minimum_required(VERSION 3.20)

project(embeded_text_file)
add_executable(app)

target_sources(app
PRIVATE
    src/main.cpp
)

# C++ 20 requires for the "battery-embed" library
target_compile_features(app PUBLIC cxx_std_20)

# This code will install the "battery-embed" library
include(FetchContent)
FetchContent_Declare(
  battery-embed
  GIT_REPOSITORY https://github.com/batterycenter/embed.git
  GIT_TAG        main
)
FetchContent_MakeAvailable(battery-embed)

# Files to embed
b_embed(app assets/hello-world.txt)

• You should comments above
• Create the "src" folder and create the "main.cpp" file in the "src" folder with the contect below:

#include <iostream>
#include <battery/embed.hpp>

int main()
{
    std::string text = b::embed<"assets/hello-world.txt">();
    std::cout << text << std::endl;
    return 0;
}

• Create a folder for building the project:

mkdir dist\win

• Move to the "dist" folder:

cd dist

• Copy and paste the configuration command:

cmake -G "MinGW Makefiles" --fresh -S .. -B ..\dist\win

• Move to the "win" folder:

cd win

• Type the build command:

mingw32-make

• The "app.exe" file was created. Run it the application:

app

• You will see the "Hello, World!" text in the console

Embeding textures to EXE using the "embed" library

This example uses the embed library. You don't need to install this library. It will be installed automatically by "CMakeLists.txt"

• Download the load-a-texture-opengl21-sdl3-cpp example and unzip it
• Go to the example folder in the console and type the commands:

mkdir dist\win
cd dist
cmake -G "MinGW Makefiles" --fresh -S .. -B ..\dist\win -DSDL3_DIR=E:\libs\sdl3-desktop-prefix\lib\cmake\SDL3
cd win
mingw32-make
app

Building ImGUI statically and setting up it to the CMake project

• You should complete the following guide above: Setting up SDL3 for Windows using CMake and MinGW-w64
• Create an empty folder, for example, in my case: "E:\libs\imgui-1.91.1-sdl3-opengl3" and four empty folders inside it:
• include
• lib
• src
• src_to_build
• Download the latest ImGUI release: https://github.com/ocornut/imgui/releases and unzip it
• Go to the ImGUI root folder and copy the following files:
• imgui.cpp
• imgui_draw.cpp
• imgui_tables.cpp
• imgui_widgets.cpp
• Paste the copied files to the "src_to_build" folder, in my case to the "E:\libs\imgui-1.91.1-sdl3-opengl3\src_to_build"
• Go to the ImGUI root folder and copy the following files:
• imgui_impl_opengl3.cpp
• imgui_impl_sdl3.cpp
• Paste the copied files to the "src" folder, in my case to the "E:\libs\imgui-1.91.1-sdl3-opengl3\src"
• Create a temprorary empty folder and name it like you want, for example, "imgui-compilation"
• Create the "CMakeLists.txt" file inside of the "imgui-compilation" folder
• Copy the following content to the "CMakeLists.txt" file:

cmake_minimum_required(VERSION 3.20)

project(imgui_static)

# Set where the ImGui files are stored
set(IMGUI_PATH_INCLUDE "E:/libs/imgui-1.91.1-sdl3-opengl3/include")
set(IMGUI_PATH_SRC "E:/libs/imgui-1.91.1-sdl3-opengl3/src_to_build")

# Compile as static library 
file(GLOB IMGUI_SOURCES ${IMGUI_PATH_SRC}/*.cpp)
add_library("ImGui" STATIC ${IMGUI_SOURCES})
target_include_directories("ImGui" PUBLIC ${IMGUI_PATH_INCLUDE})

• Open the console inside of the "imgui-compilation" folder
• Run the following command in the console to create the "dist" folder:

mkdir dist

• Run the following command in the console to move to the "dist" folder:

cd dist

• Run the following command in the console to configurate the project:

cmake -G "MinGW Makefiles" ..

• Run the following command in the console to build the "libImGui.a" static library:

mingw32-make

• Copy the generated "libImGui.a" static library from the "dist" folder and paste it to the "lib" folder, in my case to the "E:\libs\imgui-1.91.1-sdl3-opengl3\lib" folder
• The ImGuI was set up. Let's create a simple project to test it. This example will draw a simple triangle in pure OpenGL 2.1 and it will draw a simple GUI using ImGUI
• Create an empty folder for the project and create the "CMakeLists.txt" file inside of the created folder with the following content:
CMakeLists.txt (Click here to view the full content)

cmake_minimum_required(VERSION 3.20)

project(imgui_and_triangle)
add_executable(app) # WIN32 - add this to hide the console like this: add_executable(app WIN32)

target_include_directories(app PRIVATE E:/libs/glad-2.0.6/include)
target_include_directories(app PRIVATE E:/libs/imgui-1.91.1-sdl3-opengl3/include)

target_sources(app
PRIVATE
    E:/libs/glad-2.0.6/src/glad.c
    E:/libs/imgui-1.91.1-sdl3-opengl3/src/imgui_impl_opengl3.cpp
    E:/libs/imgui-1.91.1-sdl3-opengl3/src/imgui_impl_sdl3.cpp
    main.cpp
)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

find_package(SDL3)
target_link_directories(app PRIVATE E:/libs/imgui-1.91.1-sdl3-opengl3/lib)
target_link_libraries(app PRIVATE SDL3::SDL3 ImGui opengl32)

target_compile_definitions(app PRIVATE SDL_MAIN_USE_CALLBACKS)
target_link_options(app PRIVATE -static-libgcc -static-libstdc++)

• Create the "main.cpp" file in the project folder with the following content:
main.cpp (Click here to view the full content)

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <glad/glad.h>

#include <iostream>
#include <vector>

#include <imgui_impl_opengl3.h>
#include <imgui_impl_sdl3.h>

struct AppContext
{
    SDL_Window *window;
    SDL_GLContext glContext;
    SDL_AppResult appQuit = SDL_APP_CONTINUE;
};

const char *vertexShaderSource =
    "attribute vec2 aPosition;\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(aPosition, 0.0, 1.0);\n"
    "}\n";

const char *fragmentShaderSource =
    "void main()\n"
    "{\n"
    "    gl_FragColor = vec4(0.2, 0.7, 0.3, 1.0);\n"
    "}\n";

// Helper function for creating shaders
GLuint createShader(const char *shaderSource, int shaderType)
{
    GLuint shader = glCreateShader(shaderType);
    glShaderSource(shader, 1, &shaderSource, NULL);
    glCompileShader(shader);
    GLint status;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if (status == GL_FALSE)
    {
        GLint maxLength = 0;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
        std::vector<GLchar> errorLog(maxLength);
        glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
        glDeleteShader(shader); // Don't leak the shader
        std::cout << &(errorLog[0]) << std::endl;
        std::cout << shaderSource << std::endl;
    }
    return shader;
}

// Helper function for creating a shader program
GLuint createShaderProgram()
{
    GLuint program = glCreateProgram();
    GLuint vShader = createShader(vertexShaderSource, GL_VERTEX_SHADER);
    GLuint fShader = createShader(fragmentShaderSource, GL_FRAGMENT_SHADER);

    glAttachShader(program, vShader);
    glAttachShader(program, fShader);
    glLinkProgram(program);
    glUseProgram(program);

    return program;
}

// Load a triangle to the video card
void initVertexBuffers(GLuint program)
{
    float vertPositions[] = {
        -0.5f, -0.5f,
        0.5f, -0.5f,
        0.f, 0.5f
    };
    GLuint vertPosBuffer;
    glGenBuffers(1, &vertPosBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertPosBuffer);
    int amount = sizeof(vertPositions) / sizeof(vertPositions[0]);
    glBufferData(GL_ARRAY_BUFFER, amount * sizeof(GLfloat),
        vertPositions, GL_STATIC_DRAW);
    GLint aPositionLocation = glGetAttribLocation(program, "aPosition");
    glVertexAttribPointer(aPositionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(aPositionLocation);
}

SDL_AppResult SDL_Fail()
{
    SDL_LogError(SDL_LOG_CATEGORY_CUSTOM, "Error %s", SDL_GetError());
    return SDL_APP_FAILURE;
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    // init the library, here we make a window so we only need the Video capabilities.
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        return SDL_Fail();
    }

    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); // Enable MULTISAMPLE
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2); // can be 2, 4, 8 or 16

    // Create a window
    SDL_Window *window = SDL_CreateWindow("SDL3, OpenGL 2.1, C++", 400, 400,
        SDL_WINDOW_OPENGL); // | SDL_WINDOW_RESIZABLE
    if (!window)
    {
        return SDL_Fail();
    }

    SDL_GLContext glContext = SDL_GL_CreateContext(window);
    if (!glContext)
    {
        return SDL_Fail();
    }

    if (!gladLoadGL())
    {
        std::cout << "Failed to load OpenGL functions" << std::endl;
        return SDL_APP_FAILURE;
    }

    glClearColor(0.188f, 0.22f, 0.255f, 1.f);

    GLuint program = createShaderProgram();
    initVertexBuffers(program);

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO &io = ImGui::GetIO();
    (void)io;

    // Setup Dear ImGui style
    ImGui::StyleColorsDark();
    // ImGui::StyleColorsLight();

    // Setup Platform/Renderer bindings
    ImGui_ImplSDL3_InitForOpenGL(window, glContext);
    ImGui_ImplOpenGL3_Init();

    SDL_ShowWindow(window);

    // set up the application data
    *appstate = new AppContext {
        window,
        glContext,
    };

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, const SDL_Event *event)
{
    auto *app = (AppContext *)appstate;

    // ImGui_ImplSDL3_ProcessEvent(event);

    switch (event->type)
    {
        case SDL_EVENT_QUIT:
        {
            app->appQuit = SDL_APP_SUCCESS;
            break;
        }
        default:
        {
            break;
        }
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    // Start the Dear ImGui frame
    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplSDL3_NewFrame();

    ImGui::NewFrame();

    ImGui::Begin("Another Window");
    ImGui::Text("Hello from another window!");
    if (ImGui::Button("Click Me"))
        std::cout << "clicked" << std::endl;
    ImGui::End();

    ImGui::Render();
    ImGuiIO &io = ImGui::GetIO();
    glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);

    // Clear the canvas
    glClear(GL_COLOR_BUFFER_BIT);

    // Draw a triangle
    glDrawArrays(GL_TRIANGLES, 0, 3);

    // Draw GUI
    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

    SDL_GL_SwapWindow(app->window);

    return app->appQuit;
}

void SDL_AppQuit(void *appstate)
{
    auto *app = (AppContext *)appstate;
    if (app)
    {
        SDL_GL_DestroyContext(app->glContext);
        SDL_DestroyWindow(app->window);
        delete app;
    }

    // Cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplSDL3_Shutdown();
    ImGui::DestroyContext();

    SDL_Quit();
}

• Let's setup GLAD. Google "glad online opengl generator". You will find this link: https://glad.dav1d.de/
• In the "API > gl" select the OpenGL API version what do you want. I prefer to use "Version 2.1" because it is very similar to OpenGL ES 2.0 that is enough for me
• Scroll to the bottom of the page and click on the "Generate" button
• Click on the "glad.zip" archive. Unzip in somewhere. For example: "E:\libs\glad-2.0.6"
• Open the console in the current project folder
• Create the "dist" folder:

mkdir dist

• Go to the "dist" folder:

cd dist

• Copy and paste the following command to the console to configure the project:

cmake -G "MinGW Makefiles" --fresh -S .. -B ../dist/win -DSDL3_DIR=E:/libs/sdl3-desktop-prefix/lib/cmake/SDL3

• Go to the generated "win" folder by typing the following command in the console:

cd win

• Run the following command to building the project and creating the "app.exe":

mingw32-make

• The "app.exe" was created in the "win" folder. You can run "app.exe" by running the following command:

app

• Source code:
• GitHub
• Dropbox - 10 KB
• Screenshot
• EXE for Windows 10, 64-bit - 2.9 MB

Setting up Box2D

• Setting up SDL3 for Windows using CMake and MinGW-w64
• Download the Box2D 2.4.2 release and unzip it
• Open the console in the unzipped folder. Copy and paste the following configuration command:

cmake -G "MinGW Makefiles" --fresh -S . -B dist -DCMAKE_INSTALL_PREFIX=E:\libs\box2d-2.4.2-prefix -DBOX2D_BUILD_TESTBED=OFF -DBOX2D_BUILD_UNIT_TESTS=OFF

• Time: 5s
• Copy, paste, and run the build command:

cmake --build dist -j4

• Time: 15s
• Copy, paste, and run the installation command:

cmake --install dist

• You can use these path in your projects:

E:\libs\box2d-2.4.2-prefix\lib\cmake\box2d

• Let's create a project that will print a gravity to the console and will draw a triangle using OpenGL
• Create a new empy folder and two files inside it:
CMakeLists.txt (Click here to view the full content)

cmake_minimum_required(VERSION 3.20)

project(print_gravity_box2d)
add_executable(app) # WIN32

target_include_directories(app PRIVATE E:/libs/glad-2.0.6/include)

target_sources(app
PRIVATE
    E:/libs/glad-2.0.6/src/glad.c
    main.cpp
)

# This code copies the "SDL3.dll" file to the build directory
add_custom_command(TARGET app POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_RUNTIME_DLLS:app> $<TARGET_FILE_DIR:app>
)

find_package(SDL3)
find_package(box2d)
target_link_libraries(app PRIVATE box2d::box2d SDL3::SDL3)
target_compile_definitions(app PRIVATE SDL_MAIN_USE_CALLBACKS)

target_link_options(app PRIVATE -static-libgcc -static-libstdc++)

main.cpp (Click here to view the full content)

#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <glad/glad.h>
#include <box2d/box2d.h>

#include <iostream>
#include <vector>

b2World *world;

struct AppContext
{
    SDL_Window *window;
    SDL_GLContext glContext;
    SDL_AppResult appQuit = SDL_APP_CONTINUE;
};

const char *vertexShaderSource =
    "attribute vec2 aPosition;\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(aPosition, 0.0, 1.0);\n"
    "}\n";

const char *fragmentShaderSource =
    "void main()\n"
    "{\n"
    "    gl_FragColor = vec4(0.2, 0.7, 0.3, 1.0);\n"
    "}\n";

// Helper function for creating shaders
GLuint createShader(const char *shaderSource, int shaderType)
{
    GLuint shader = glCreateShader(shaderType);
    glShaderSource(shader, 1, &shaderSource, NULL);
    glCompileShader(shader);
    GLint status;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if (status == GL_FALSE)
    {
        GLint maxLength = 0;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
        std::vector<GLchar> errorLog(maxLength);
        glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
        glDeleteShader(shader); // Don't leak the shader
        std::cout << &(errorLog[0]) << std::endl;
        std::cout << shaderSource << std::endl;
    }
    return shader;
}

// Helper function for creating a shader program
GLuint createShaderProgram()
{
    GLuint program = glCreateProgram();
    GLuint vShader = createShader(vertexShaderSource, GL_VERTEX_SHADER);
    GLuint fShader = createShader(fragmentShaderSource, GL_FRAGMENT_SHADER);

    glAttachShader(program, vShader);
    glAttachShader(program, fShader);
    glLinkProgram(program);
    glUseProgram(program);

    return program;
}

// Load a triangle to the video card
void initVertexBuffers(GLuint program)
{
    float vertPositions[] = {
        -0.5f, -0.5f,
        0.5f, -0.5f,
        0.f, 0.5f
    };
    GLuint vertPosBuffer;
    glGenBuffers(1, &vertPosBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertPosBuffer);
    int amount = sizeof(vertPositions) / sizeof(vertPositions[0]);
    glBufferData(GL_ARRAY_BUFFER, amount * sizeof(GLfloat),
        vertPositions, GL_STATIC_DRAW);
    GLint aPositionLocation = glGetAttribLocation(program, "aPosition");
    glVertexAttribPointer(aPositionLocation, 2, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(aPositionLocation);
}

SDL_AppResult SDL_Fail()
{
    SDL_LogError(SDL_LOG_CATEGORY_CUSTOM, "Error %s", SDL_GetError());
    return SDL_APP_FAILURE;
}

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    // Init the library, here we make a window so we only need the Video capabilities.
    if (SDL_Init(SDL_INIT_VIDEO))
    {
        return SDL_Fail();
    }

    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); // Enable MULTISAMPLE
    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2); // can be 2, 4, 8 or 16

    // Create a window
    SDL_Window *window = SDL_CreateWindow("SDL3, OpenGL 2.1, C++", 400, 400,
        SDL_WINDOW_OPENGL); // | SDL_WINDOW_RESIZABLE
    if (!window)
    {
        return SDL_Fail();
    }

    SDL_GLContext glContext = SDL_GL_CreateContext(window);
    if (!glContext)
    {
        return SDL_Fail();
    }

    if (!gladLoadGL())
    {
        std::cout << "Failed to load OpenGL functions" << std::endl;
        return SDL_APP_FAILURE;
    }

    GLuint program = createShaderProgram();
    initVertexBuffers(program);

    b2Vec2 gravity(0.f, -9.8f);
    world = new b2World(gravity);
    float gx = world->GetGravity().x;
    float gy = world->GetGravity().y;
    std::cout << "gravity = (" << gx << ", " << gy << ")" << std::endl;

    SDL_ShowWindow(window);

    // Set up the application data
    *appstate = new AppContext {
        window,
        glContext,
    };

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, const SDL_Event *event)
{
    auto *app = (AppContext *)appstate;

    switch (event->type)
    {
        case SDL_EVENT_QUIT:
        {
            app->appQuit = SDL_APP_SUCCESS;
            break;
        }
        default:
        {
            break;
        }
    }

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    auto *app = (AppContext *)appstate;

    glClearColor(0.188f, 0.22f, 0.255f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLES, 0, 3);
    SDL_GL_SwapWindow(app->window);

    return app->appQuit;
}

void SDL_AppQuit(void *appstate)
{
    auto *app = (AppContext *)appstate;
    if (app)
    {
        SDL_GL_DestroyContext(app->glContext);
        SDL_DestroyWindow(app->window);
        delete app;
    }

    delete world;
    SDL_Quit();
}

• Open the console in the project folder
• Create "dist\win" folders:

mkdir dist\win

• Move to "dist" folder:

cd dist

• Copy, paste, and run the following command to configure:

cmake -G "MinGW Makefiles" --fresh -S .. -B ..\dist\win -DSDL3_DIR=E:\libs\sdl3-desktop-prefix\lib\cmake\SDL3 -Dbox2d_DIR=E:\libs\box2d-2.4.2-prefix\lib\cmake\box2d

• Move to the "win" folder:

cd win

• Type and run the following command to create the "app.exe":

mingw32-make

• Run "app.exe":

app

• Source code:
• GitHub
• Dropbox - 3.63 KB
• EXE for Windows 10, 64-bit - 2.66 MB, unzipped - 4.68 MB
• Screenshot

In the future:

Setting up the header only GLM library

Embeding audio files to EXE and play music and sounds with OpenAL

• play-music-openal-opengl21-sdl3-cpp

  • EXE for Windows 10, 64-bit - 8.21 MB, unzipped - 11.6 MB

Setting up Bullet Physics

• debug-drawer-desktop-opengl21-bullet-physics-sdl3-cpp

  • EXE for Windows 10, 64-bit - 3.1 MB
  • Gif-animation