Remove Debug Text

CMakeLists.txt

@@ -10,6 +10,9 @@ set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 # Declare Project where "GSM_TEMPLATE" is the project name
 project(GSM_TEMPLATE LANGUAGES C CXX)
 
+# Use FreeGlut on Macos (Requires X11 to be installed, but doesn't use it)
+option(USE_FREEGLUT "Use FreeGLUT on Mac (ignored on Windows)" ON)
+
 # Allow cmake to fetch web repositories
 include(FetchContent)
 
@@ -41,13 +44,28 @@ FetchContent_MakeAvailable(stb_image)
 
 
 # If using the Windows compiler
-if (MSVC)
+if (MSVC OR USE_FREEGLUT)
+
+  if (APPLE)
+
+    find_path(XQUARTZ_INCLUDE_DIR X11/Xlib.h
+      PATHS /opt/X11/include
+      NO_DEFAULT_PATH
+    )
+
+    if(NOT XQUARTZ_INCLUDE_DIR)
+      message(FATAL_ERROR "To use FreeGLUT on Mac, you need XQuartz installed.  Please install it from https://www.xquartz.org/ or set the USE_FREEGLUT cache option to OFF")
+    endif()
+
+  endif()
+
+  set(CMAKE_POLICY_VERSION_MINIMUM 3.16)
 
   # Download freeglut
 	FetchContent_Declare(
 		freeglut
 		GIT_REPOSITORY https://github.com/freeglut/freeglut.git
-		GIT_TAG "master"
+    GIT_TAG "v3.8.0"
 		GIT_SHALLOW TRUE
 		GIT_PROGRESS ON
 	)
@@ -56,6 +74,11 @@ if (MSVC)
 	set(FREEGLUT_BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
 	set(FREEGLUT_BUILD_STATIC_LIBS ON CACHE BOOL "" FORCE)
 
+  # Force Cocca on Mac
+  if(APPLE)
+    set(FREEGLUT_USE_X11 OFF CACHE BOOL "" FORCE)
+    set(FREEGLUT_COCOA ON CACHE BOOL "" FORCE)
+  endif()
 
 	FetchContent_MakeAvailable(freeglut)
 
@@ -76,8 +99,8 @@ endif()
 # Tell Cmake to find the locations of libraries
 find_package(OpenGL REQUIRED)
 
-# Only require glut if on macos
+# Only require glut if on macos and not using freeglut
-if (APPLE)
+if (APPLE AND NOT USE_FREEGLUT)
   find_package(GLUT REQUIRED)
 endif()
 # Define MY_SOURCES to be a list of all the source files for my game 
@@ -117,6 +140,37 @@ target_sources("${CMAKE_PROJECT_NAME}" PRIVATE ${MY_SOURCES})
 # If on mac
 if (APPLE)
 
+# FreeGlut for mac
+if (USE_FREEGLUT)
+
+
+target_sources("${CMAKE_PROJECT_NAME}" PRIVATE "${glad_SOURCE_DIR}/src/glad.c")
+target_include_directories("${CMAKE_PROJECT_NAME}" PUBLIC "${glad_SOURCE_DIR}/include")
+
+# Add our include files
+target_include_directories("${CMAKE_PROJECT_NAME}" PUBLIC 
+"${CMAKE_CURRENT_SOURCE_DIR}/include/"
+"${freeglut_SOURCE_DIR}/include"
+"${glad_SOURCE_DIR}/include"
+)
+
+target_compile_definitions("${CMAKE_PROJECT_NAME}" PUBLIC use_freeglut=TRUE)
+
+target_link_libraries("${CMAKE_PROJECT_NAME}" 
+  PRIVATE 
+  OpenGL::GL
+  freeglut_static
+  "-framework Cocoa"
+  "-framework IOKit"
+  "-framework CoreVideo"
+  "-lpthread"
+  stb_image
+  miniaudio
+)
+
+# Native GLUT for Mac
+else()
+
 # Add our include files
 target_include_directories("${CMAKE_PROJECT_NAME}" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include/")
 
@@ -138,6 +192,7 @@ target_link_libraries("${CMAKE_PROJECT_NAME}"
   stb_image
   miniaudio
 )
+endif()
 
 
 # If on windows
@@ -177,4 +232,26 @@ target_link_libraries("${CMAKE_PROJECT_NAME}"
   miniaudio
 )
 
+elseif(UNIX AND NOT APPLE)
+
+target_sources("${CMAKE_PROJECT_NAME}" PRIVATE "${glad_SOURCE_DIR}/src/glad.c")
+target_include_directories("${CMAKE_PROJECT_NAME}" PUBLIC "${glad_SOURCE_DIR}/include")
+
+# Add our include files
+target_include_directories("${CMAKE_PROJECT_NAME}" PUBLIC 
+"${CMAKE_CURRENT_SOURCE_DIR}/include/"
+"${freeglut_SOURCE_DIR}/include"
+"${glad_SOURCE_DIR}/include"
+)
+
+target_compile_definitions("${CMAKE_PROJECT_NAME}" PUBLIC use_freeglut=TRUE)
+
+target_link_libraries("${CMAKE_PROJECT_NAME}" 
+  PRIVATE 
+  OpenGL::GL
+  freeglut_static
+  stb_image
+  miniaudio
+)
+
 endif()

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Colton Staiduhar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,6 +1,71 @@
 # GlutSTBMiniAudio-Template
 
-To compile the project
+## Changing the Project Name
+
+In the CMakeLists.txt file, find line 11 (`project(GSM_TEMPLATE LANGUAGES C CXX)`) and replace "GSM_TEMPLATE" with whatever you'd like
+
+## Setup
+
+### For Windows
+1. Install Visual Studio <br>
+Make sure you have installed Visual Studio, not Visual Studio Code, you need the MSVC Compiler installed which is bundled and accessible with Standard Visual Studio
+
+2. Open the Visual Installer<br>
+![](docs/images/CMAKE_TUTORIAL_WIN_STEP1.png "Open Visual Studio Installer")
+
+3. Modify your Visual Studio Installation<br>
+![](docs/images/CMAKE_TUTORIAL_WIN_STEP2.png "Modify Visual Studio with the Installer")
+
+4. Make sure "Desktop Development wiht C++" is installed<br>
+![](docs/images/CMAKE_TUTORIAL_WIN_STEP3.png "Desktop Development wiht C++ must be installed")
+
+5. Once installed open Visual Studio and select "Open a folder", then find and select the folder of this project
+![](docs/images/CMAKE_TUTORIAL_WIN_STEP4.png "Open a Folder")
+
+6. When the project opens, CMake should immedately start installing thirdparty dependencies. Please make sure you see *"CMake generation finished"* before continuing.
+![](docs/images/CMAKE_TUTORIAL_WIN_STEP5.png "CMake generation finished")
+
+7. Finally select the correct Target from the Target list, to the right of the run button. 
+![](docs/images/CMAKE_TUTORIAL_WIN_STEP6.png "CMake generation finished")
+
+8. Finally press the run button and the application should just work
+
+
+### For MacOS
+
+1. There are many different ways to use CMake on Mac or Linux.  Visual Studio works great, but its a [Command Line Interface](#CLI) application so it's easy to use anywhere.<br>
+However, for this guide, install Visual Studio Code and [Brew](https://brew.sh).  Brew is like apt for MacOS, if you don't want to install it, find some way to install CMake.
+
+2. Open this project in Visual Studio Code.
+3. In the extensions tab, find and install "CMake Tools"
+![](docs/images/CMAKE_TUTORIAL_MAC_STEP3.png "CMake Tools Extension")
+4. You may need to reload the project, so do that with CMD+Shift+P, search for *"Reload Window"*, and Press *enter*
+5. When the project opens, it should immediately start downloading the libraries that this project needs.  Please wait until it completes or you see *"CMake generation finished"* in the console.
+6. Once CMake has finished configuring, press Shift+F5 (You may also need to press fn depending on how your mac is setup), and the application will run.
+
+
+### For Linux (Debian/Ubuntu)
+
+The following packages are needed in order for the included libraries to function: cmake, build-essential, libgl1-mesa-dev, libglu1-mesa-dev, freeglut3-dev, libx11-dev, libxcursor-dev, libxtst-dev, libxft-dev, libxmu-dev, libxi-dev
+
+
+Heres an easy one-line install script
+```
+sudo apt install cmake build-essential libgl1-mesa-dev libglu1-mesa-dev freeglut3-dev libx11-dev libxcursor-dev libxtst-dev libxft-dev libxmu-dev libxi-dev -y
+```
+
+After this point, follow the same instructions for MacOS, or use the CLI Interface below.
+
+*NOTE* - For some reason, unix needs to use #include `<GL/freeglut.h>`, it will thow a error if #include `<gl/freeglut.h>`.  Notice the capitalization
+
+
+
+### CLI
+To compile the project with normal cmake, it's stupid easy.
+```
+cmake .; make;
+```
+The binary should be in the root of the project after it is installed so run 
+```
+./GSM_TEMPLATE
 ```
-cmake .; make; ./GSM_TEMPLATE
-```

src/main.cpp

@@ -1,68 +1,66 @@
-//#############################################################################
+// #############################################################################
-//# main.cpp
+// # main.cpp
-//#############################################################################
+// #############################################################################
-//# Written by Colton Staiduhar
+// # Written by Colton Staiduhar
-//# Date Created:       02/03/2025
+// # Date Created:       02/03/2025
-//# Last Modification:  02/05/2025
+// # Last Modification:  02/05/2025
-//#############################################################################
+// #############################################################################
-//# Main Entry point for Cmake project, declare by the int main() function
+// # Main Entry point for Cmake project, declare by the int main() function
-//#############################################################################
+// #############################################################################
-//#
+// #
-//# This is a simple demonstration of GLUT functioning using STB_Image.H for
+// # This is a simple demonstration of GLUT functioning using STB_Image.H for
-//# loading images and MiniAudio.h for playing audio. The repositories for
+// # loading images and MiniAudio.h for playing audio. The repositories for
-//# these libraries can be found below.
+// # these libraries can be found below.
-//#
+// #
-//# Miniaudio
+// # Miniaudio
-//# https://github.com/mackron/miniaudio
+// # https://github.com/mackron/miniaudio
-//#
+// #
-//# STB_Image.h
+// # STB_Image.h
-//# https://github.com/arizotaz/cmake_stb_image
+// # https://github.com/arizotaz/cmake_stb_image
-//#
+// #
-//#############################################################################
+// #############################################################################
-//#
+// #
-//# For GLUT/OpenGL, the operating system should have GLUT in some form already
+// # For GLUT/OpenGL, the operating system should have GLUT in some form already
-//# installed.  However, freeglut exists as the modern implementation of GLUT.
+// # installed.  However, freeglut exists as the modern implementation of GLUT.
-//#
+// #
-//# GLUT
+// # GLUT
-//# You're on your own for this, but here are some helpful implementation docs
+// # You're on your own for this, but here are some helpful implementation docs
-//#     MacOS: https://developer.apple.com/library/archive/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_drawing/opengl_drawing.html
+// #     MacOS: https://developer.apple.com/library/archive/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_drawing/opengl_drawing.html
-//#     Windows & Linux: https://www.opengl.org/resources/libraries/glut/glut_downloads.php
+// #     Windows & Linux: https://www.opengl.org/resources/libraries/glut/glut_downloads.php
-//#
+// #
-//# FreeGLUT:
+// # FreeGLUT:
-//#	https://freeglut.sourceforge.net/docs/api.php
+// #	https://freeglut.sourceforge.net/docs/api.php
-//#
+// #
-//#############################################################################
+// #############################################################################
-//#
+// #
-//# This file will setup much of GLUT.  Getting some output to the screen
+// # This file will setup much of GLUT.  Getting some output to the screen
-//# The following is executed:
+// # The following is executed:
-//#     Create a windows with GLUT's API
+// #     Create a windows with GLUT's API
-//#     Create a display update timer
+// #     Create a display update timer
-//#     Create Keyboard Interrupts
+// #     Create Keyboard Interrupts
-//#     Load textures the included Texture.H file
+// #     Load textures the included Texture.H file
-//#     Setup the audio engine from MiniAudio
+// #     Setup the audio engine from MiniAudio
-//#     Declare the Main Loop funcitons
+// #     Declare the Main Loop funcitons
-//#     Draw a sprite to the screen
+// #     Draw a sprite to the screen
-//#     Texture said sprite with an image
+// #     Texture said sprite with an image
-//#     Rotate, move, and scale the sprite
+// #     Rotate, move, and scale the sprite
-//#     Apply translations via user keyboard input
+// #     Apply translations via user keyboard input
-//#
+// #
-//#############################################################################
+// #############################################################################
-
-
 
 // Libraries
 #if defined(use_freeglut)
-#	include <glad/glad.h>
+#include <glad/glad.h>
-#   define FREEGLUT_STATIC
+#define FREEGLUT_STATIC
-#	include <gl/freeglut.h>
+#include <GL/freeglut.h>
 #else
-#	include <GLUT/glut.h>
+#include <GLUT/glut.h>
 #endif
 #include <miniaudio.h>
 
 // STD
-#include <math.h>
 #include <iostream>
+#include <math.h>
 #include <stdio.h>
 
 // Custom includes
@@ -76,14 +74,12 @@
 void ProcessKeys(unsigned char, int, int);
 void ProcessSpecialKeys(int, int, int);
 void MainLoop();
-void GlutLoopTimer(int);
 
 // Extended Functionality
 void UpdateViewPort();
 void DrawSprite();
 void LoadUserTextures();
 
-
 // Miniaudio Engine Declaration
 void CreateAudioEngine();
 ma_engine engine; // Miniaudio engine
@@ -97,68 +93,10 @@ unsigned int texID;
 ma_sound musicSound; // Miniaudio sound object
 int lastWinW = 0, lastWinH = 0;
 
-/**
+bool running = true;
- * Main entry point of the application
+void CloseCallBack()
- */
-int main(int argc, char **argv)
 {
-	std:;cout << "Starting";
+    running = false;
-	fflush(stdout);
-
-	int winW = 1280;
-	int winH = 720;
-
-	// Initialize GLUT
-	glutInit(&argc, argv);
-	glutInitDisplayMode(GLUT_RGB); // RGB mode
-
-	// Setup then create the window
-	glutInitWindowSize(winW, winH); // window size
-	glutInitWindowPosition(0, 0);
-	glutCreateWindow("Transform Example");
-
-	// This line only needs to run when glad is in use
-	#if defined(use_freeglut)
-	if (!gladLoadGL()) {}
-	#endif
-
-	// Clear screen
-	glClearColor(0.0, 0.0, 0.0, 1.0); // clear the window screen
-
-	// Sets up the viewport
-	UpdateViewPort();
-
-	// Calls the texture load method
-	LoadUserTextures();
-
-	// Setup Audio Engine
-	CreateAudioEngine();
-
-	// Play the music
-	ma_sound_start(&musicSound);
-
-	// Deplare the Main Loop Function 
-	// (Will be executed when glutPostRedisplay() is called in the timer)
-	glutDisplayFunc(MainLoop);
-
-	// Declare Keyboard Interupts
-	glutKeyboardFunc(ProcessKeys);
-
-	// Declare Special Keys Keyboard Interrupt
-	glutSpecialFunc(ProcessSpecialKeys);
-	
-	// Setup a timer to run the main loop at an interval
-	// (This call will call the GlutLoopTimer() function immediately)
-	glutTimerFunc(0, GlutLoopTimer, 0);
-
-	std:;cout << "Started";
-	fflush(stdout);
-	// Start the Glut Loop (Calls the funtions above repeatedly)
-	glutMainLoop();
-
-	std:;cout << "exited";
-	fflush(stdout);
-	return 0;
 }
 
 /**
@@ -167,11 +105,96 @@ int main(int argc, char **argv)
  */
 void GlutLoopTimer(int v)
 {
-	// Runs the function specified in glutDisplayFunc
+    // Runs the function specified in glutDisplayFunc
-	glutPostRedisplay();
+    glutPostRedisplay();
 
-	// Call the timer again in 16.7 seconds ~ 60 times per second
+    // Call the timer again in 16.7 seconds ~ 60 times per second
-	glutTimerFunc(16.7, GlutLoopTimer, v); // Creates a frame delay that is counted in miliseconds
+    glutTimerFunc(16.7, GlutLoopTimer, v); // Creates a frame delay that is counted in miliseconds
+}
+
+/**
+ * Main entry point of the application
+ */
+int main(int argc, char** argv)
+{
+    std::cout << "Starting";
+    fflush(stdout);
+
+    int winW = 1280;
+    int winH = 720;
+
+    // Initialize GLUT
+    glutInit(&argc, argv);
+    glutInitDisplayMode(GLUT_RGB); // RGB mode
+
+    // Setup then create the window
+    glutInitWindowSize(winW, winH); // window size
+    glutInitWindowPosition(0, 0);
+    glutCreateWindow("Transform Example - Using Native Glut");
+
+// This line only needs to run when glad is in use
+#if defined(use_freeglut)
+	glutSetWindowTitle("Transform Example - using FreeGLUT");
+    if (!gladLoadGL()) { }
+#endif
+
+    // Clear screen
+    glClearColor(0.0, 0.0, 0.0, 1.0); // clear the window screen
+
+    // Sets up the viewport
+    UpdateViewPort();
+
+    // Calls the texture load method
+    LoadUserTextures();
+
+    // Setup Audio Engine
+    CreateAudioEngine();
+
+    // Play the music
+    ma_sound_start(&musicSound);
+
+    // Deplare the Main Loop Function
+    // (Will be executed when glutPostRedisplay() is called in the timer)
+    glutDisplayFunc(MainLoop);
+
+    // Declare Keyboard Interupts
+    glutKeyboardFunc(ProcessKeys);
+
+    // Declare Special Keys Keyboard Interrupt
+    glutSpecialFunc(ProcessSpecialKeys);
+
+#ifndef use_freeglut
+    // Setup a timer to run the main loop at an interval
+    // (This call will call the GlutLoopTimer() function immediately)
+    glutTimerFunc(0, GlutLoopTimer, 0);
+#endif
+
+    std::cout << "Started" << std::endl;
+    fflush(stdout);
+    // Start the Glut Loop (Calls the funtions above repeatedly)
+
+#if defined(use_freeglut)
+	// FreeGlut allows for manual updating of the main loop
+	// So we can call the main loop in a while loop and tell the loop when to stop
+
+	// Tell FreeGlut to do nothing on window X press
+    glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
+
+	// Run callback when window X is pressed
+    glutCloseFunc(CloseCallBack);
+
+	// Our loop, calls the funtion in glutDisplayFunc repeatedly until running = false 
+    while (running)
+        glutMainLoopEvent();
+
+#else
+    // Start the Glut Loop (Calls the funtions above repeatedly)
+    glutMainLoop();
+#endif
+
+    std::cout << "exited" << std::endl;
+    fflush(stdout);
+    return 0;
 }
 
 /**
@@ -179,20 +202,20 @@ void GlutLoopTimer(int v)
  */
 void UpdateViewPort()
 {
-	// Gets the window size
+    // Gets the window size
-	int winW = glutGet(GLUT_WINDOW_WIDTH);
+    int winW = glutGet(GLUT_WINDOW_WIDTH);
-	int winH = glutGet(GLUT_WINDOW_HEIGHT);
+    int winH = glutGet(GLUT_WINDOW_HEIGHT);
 
-	// Sets up OpenGL Matrix Mode
+    // Sets up OpenGL Matrix Mode
-	glMatrixMode(GL_PROJECTION);
+    glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
+    glLoadIdentity();
 
-	// Create projection type (Orthographic with size of window)
+    // Create projection type (Orthographic with size of window)
-	glOrtho(-winW / 2, winW / 2, winH / 2, -winH / 2, -1000.0f, 1000.0f); // Clipping plane is set to 1000 behind camera and 1000 infront, this works because ortho is cool
+    glOrtho(-winW / 2, winW / 2, winH / 2, -winH / 2, -1000.0f, 1000.0f); // Clipping plane is set to 1000 behind camera and 1000 infront, this works because ortho is cool
 
-	// Set last size to the new size
+    // Set last size to the new size
-	lastWinW = winW;
+    lastWinW = winW;
-	lastWinH = winH;
+    lastWinH = winH;
 }
 
 /**
@@ -202,29 +225,25 @@ void UpdateViewPort()
  */
 void ProcessSpecialKeys(int key, int x, int y)
 {
-	if (key == GLUT_KEY_LEFT)
+    if (key == GLUT_KEY_LEFT) {
-	{
+        moveX = -10;
-		moveX = -10;
+        movePressed = true;
-		movePressed = true;
+    }
-	}
 
-	if (key == GLUT_KEY_RIGHT)
+    if (key == GLUT_KEY_RIGHT) {
-	{
+        moveX = 10;
-		moveX = 10;
+        movePressed = true;
-		movePressed = true;
+    }
-	}
 
-	if (key == GLUT_KEY_UP)
+    if (key == GLUT_KEY_UP) {
-	{
+        moveY = 10;
-		moveY = 10;
+        movePressed = true;
-		movePressed = true;
+    }
-	}
 
-	if (key == GLUT_KEY_DOWN)
+    if (key == GLUT_KEY_DOWN) {
-	{
+        moveY = -10;
-		moveY = -10;
+        movePressed = true;
-		movePressed = true;
+    }
-	}
 }
 
 /**
@@ -233,38 +252,37 @@ void ProcessSpecialKeys(int key, int x, int y)
  */
 void ProcessKeys(unsigned char key, int x, int y)
 {
-	switch (key)
+    switch (key) {
-	{
+    case 'q':
-	case 'q':
+        rotX += 1;
-		rotX += 1;
+        break;
-		break;
+    case 'w':
-	case 'w':
+        rotY += 1;
-		rotY += 1;
+        break;
-		break;
+    case 'e':
-	case 'e':
+        rotZ += 1;
-		rotZ += 1;
+        break;
-		break;
+    case 'a':
-	case 'a':
+        rotX -= 1;
-		rotX -= 1;
+        break;
-		break;
+    case 's':
-	case 's':
+        rotY -= 1;
-		rotY -= 1;
+        break;
-		break;
+    case 'd':
-	case 'd':
+        rotZ -= 1;
-		rotZ -= 1;
+        break;
-		break;
+    case 'p':
-	case 'p':
+        scale += .1;
-		scale += .1;
+        break;
-		break;
+    case 'l':
-	case 'l':
+        scale -= .1;
-		scale -= .1;
+        break;
-		break;
+    case 27: // escape
-	case 27: // escape
+        exit(0);
-		exit(0);
+    }
-	}
 
-	rotPressed = true;
+    rotPressed = true;
-	scalePressed = true;
+    scalePressed = true;
 }
 
 /**
@@ -273,22 +291,20 @@ void ProcessKeys(unsigned char key, int x, int y)
  */
 void CreateAudioEngine()
 {
-	ma_result result = ma_engine_init(NULL, &engine);
+    ma_result result = ma_engine_init(NULL, &engine);
-	if (result != MA_SUCCESS)
+    if (result != MA_SUCCESS) {
-	{
+        std::cout << "Failed to setup the miniaudio engine\n";
-		std::cout << "Failed to setup the miniaudio engine\n";
+        fflush(stdout);
-		fflush(stdout);
+    }
-	}
 
-	// Play Test Sound
+    // Play Test Sound
-	ma_sound_init_from_file(
+    ma_sound_init_from_file(
-		&engine,
+        &engine,
-		RESOURCES_PATH "audio/CrazyLaPaint.mp3",
+        RESOURCES_PATH "audio/CrazyLaPaint.mp3",
-		0,
+        0,
-		NULL,
+        NULL,
-		NULL,
+        NULL,
-		&musicSound
+        &musicSound);
-	);
 }
 
 /**
@@ -297,53 +313,54 @@ void CreateAudioEngine()
 void MainLoop()
 {
 
-	// Get the window size
+    // Get the window size
-	int winW = glutGet(GLUT_WINDOW_WIDTH);
+    int winW = glutGet(GLUT_WINDOW_WIDTH);
-	int winH = glutGet(GLUT_WINDOW_HEIGHT);
+    int winH = glutGet(GLUT_WINDOW_HEIGHT);
 
-	// If Changed, update the view port
+    // If Changed, update the view port
-	if (winW != lastWinW || winH != lastWinH)
+    if (winW != lastWinW || winH != lastWinH) {
-	{
+        UpdateViewPort();
-		UpdateViewPort();
+    }
-	}
 
-	// Clear the screen
+    // Clear the screen
-	glClear(GL_COLOR_BUFFER_BIT);
+    glClear(GL_COLOR_BUFFER_BIT);
 
-	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
-	// If scale oneshot is set, scale the image
+    // If scale oneshot is set, scale the image
-	if (scalePressed)
+    if (scalePressed) {
-	{
+        glScalef(scale, scale, scale);
-		glScalef(scale, scale, scale);
+        scalePressed = false;
-		scalePressed = false;
+        scale = 1;
-		scale = 1;
+    }
-	}
 
-	// If rotation oneshot is set, rotate the image
+    // If rotation oneshot is set, rotate the image
-	if (rotPressed)
+    if (rotPressed) {
-	{
+        glRotatef((GLfloat)rotX, 1.0, 0.0, 0.0);
-		glRotatef((GLfloat)rotX, 1.0, 0.0, 0.0);
+        glRotatef((GLfloat)rotY, 0.0, 1.0, 0.0);
-		glRotatef((GLfloat)rotY, 0.0, 1.0, 0.0);
+        glRotatef((GLfloat)rotZ, 0.0, 0.0, 1.0);
-		glRotatef((GLfloat)rotZ, 0.0, 0.0, 1.0);
+        rotPressed = false;
-		rotPressed = false;
+        rotX = rotY = rotZ = 0;
-		rotX = rotY = rotZ = 0;
+    }
-	}
+    // If move oneshot is set, move the image and set move back to 0
-	// If move oneshot is set, move the image and set move back to 0
+    if (movePressed) {
-	if (movePressed)
+        glTranslatef(moveX, moveY, 0);
-	{
+        movePressed = false;
-		glTranslatef(moveX, moveY, 0);
+        moveX = moveY = 0;
-		movePressed = false;
+    }
-		moveX = moveY = 0;
-	}
 
-	// Draws the image
+    // Draws the image
-	DrawSprite();
+    DrawSprite();
 
-	glFlush();
+    glFlush();
 
-	// Swap buffers to display the new frame
+    // Swap buffers to display the new frame
-	glutSwapBuffers();
+    glutSwapBuffers();
+
+	// With freeglut, we can trigger screen update right after we are done
+#if defined(use_freeglut)
+    glutPostRedisplay();
+#endif
 }
 
 /**
@@ -351,33 +368,32 @@ void MainLoop()
  */
 void DrawSprite()
 {
-	// Set texture enviorment
+    // Set texture enviorment
-	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
-	// Enable textures so OpenGL will apply the textures to the created object
+    // Enable textures so OpenGL will apply the textures to the created object
-	glEnable(GL_TEXTURE_2D);
+    glEnable(GL_TEXTURE_2D);
 
-	// Bind our texture
+    // Bind our texture
-	glBindTexture(GL_TEXTURE_2D, texID); // Which texture
+    glBindTexture(GL_TEXTURE_2D, texID); // Which texture
 
-	// Create a polygon and apply textures to it
+    // Create a polygon and apply textures to it
-	glBegin(GL_POLYGON);
+    glBegin(GL_POLYGON);
-	{
+    {
 
+        glTexCoord2f(0.0, 0.0);
+        glVertex3f(-50, -50, 0);
+        glTexCoord2f(1.0, 0.0);
+        glVertex3f(50, -50, 0);
+        glTexCoord2f(1.0, 1.0);
+        glVertex3f(50, 50, 0);
+        glTexCoord2f(0.0, 1.0);
+        glVertex3f(-50, 50, 0);
+    }
+    glEnd();
 
-		glTexCoord2f(0.0, 0.0);
+    // Disable textures so you dont continue adding textures to other objects
-		glVertex3f(-50, -50, 0);
+    glDisable(GL_TEXTURE_2D); // Turn texturing off
-		glTexCoord2f(1.0, 0.0);
-		glVertex3f(50, -50, 0);
-		glTexCoord2f(1.0, 1.0);
-		glVertex3f(50, 50, 0);
-		glTexCoord2f(0.0, 1.0);
-		glVertex3f(-50, 50, 0);
-	}
-	glEnd();
-
-	// Disable textures so you dont continue adding textures to other objects
-	glDisable(GL_TEXTURE_2D); // Turn texturing off
 }
 
 /**
@@ -385,10 +401,10 @@ void DrawSprite()
  */
 void LoadUserTextures()
 {
-	/*
+    /*
-	We add RESOURCES_PATH to the front of the filename
+    We add RESOURCES_PATH to the front of the filename
-	RESOURCES_PATH is the absolute path of the resources folder on the computer
+    RESOURCES_PATH is the absolute path of the resources folder on the computer
-	when the application is build for production it turns into a relative path
+    when the application is build for production it turns into a relative path
-	*/
+    */
-	texID = LoadTexture(RESOURCES_PATH "container.jpg");
+    texID = LoadTexture(RESOURCES_PATH "container.jpg");
 }

src/texture.cpp

@@ -15,7 +15,7 @@
 #if defined(use_freeglut)
 #	include <glad/glad.h>
 #   define FREEGLUT_STATIC
-#	include <gl/freeglut.h>
+#	include <GL/freeglut.h>
 #else
 #	include <GLUT/glut.h>
 #endif