Implemented features needed for first game

.clang-format

@@ -0,0 +1,45 @@
+Language:        Cpp
+# Start with the Microsoft base style
+BasedOnStyle:    Microsoft
+
+# Visual Studio Standard: Allman style (curly braces on new lines)
+BreakBeforeBraces: Allman
+
+# USE TABS INSTEAD OF SPACES
+# UseTab: Always tells clang-format to use tab characters (\t)
+# IndentWidth and TabWidth ensure the tabs appear as 4 columns wide
+UseTab:          Always
+IndentWidth:     4
+TabWidth:        4
+
+# Align pointers to the type (int* p)
+PointerAlignment: Left
+
+# Access Modifiers (public/private)
+# We pull modifiers back by 1 tab (4 columns) to align with the class definition
+AccessModifierOffset: -4
+
+# Indentation logic
+IndentCaseLabels: true
+IndentRequires:  true
+NamespaceIndentation: All
+
+# Line breaking and Column limits
+# Set to 0 to disable line wrapping, or keep 120 as a guideline
+ColumnLimit:     120
+
+# C++ Version
+Standard:        Latest
+
+# Sort includes (mimics VS "Organize Imports" behavior)
+SortIncludes:    CaseInsensitive
+
+# Specific Visual Studio nuances
+AllowShortFunctionsOnASingleLine: Empty
+BreakAfterAttributes: Always
+BreakBeforeBinaryOperators: None
+BreakConstructorInitializers: BeforeComma
+FixNamespaceComments: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesInParentheses: false

.gitignore

@@ -41,6 +41,9 @@ bld/
 .vscode/
 [Bb]uild/
 
+# Ignore CLion build/temporary directories
+cmake-build*/
+
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot

CMakeLists.txt

@@ -2,14 +2,17 @@ cmake_minimum_required(VERSION 3.10)
 
 project(WeirdEngine)
 
-set(CMAKE_CXX_STANDARD 17)
+execute_process(COMMAND git submodule update --init --recursive)
+
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF) # Ensure strictly standard C++
 
 message(STATUS "WeirdEngine path: ${CMAKE_CURRENT_SOURCE_DIR}")
 
 set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
 
-file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/*.vert" "${CMAKE_CURRENT_SOURCE_DIR}/src/*.frag")
+file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/*.vert" "${CMAKE_CURRENT_SOURCE_DIR}/src/*.frag" "${CMAKE_CURRENT_SOURCE_DIR}/src/*.glsl")
 file(GLOB_RECURSE HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h" "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp")
 
 add_library(${PROJECT_NAME} STATIC ${SOURCES} ${HEADERS})
@@ -31,6 +34,11 @@ target_include_directories(glad
 
 
 # SDL3 setup
+# FORCE SDL3 to build as a STATIC library.
+# This prevents the creation of libSDL3.so and embeds the code
+# directly into your engine/game.
+set(SDL_SHARED OFF CACHE BOOL "Build SDL shared library" FORCE)
+set(SDL_STATIC ON CACHE BOOL "Build SDL static library" FORCE)
 # Add dependencies
 add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/third-party/SDL)
 # add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/third-party/SDL_image)
@@ -68,18 +76,34 @@ target_link_libraries(${PROJECT_NAME} PUBLIC SDL3::SDL3)
 
 
 # Shaders
+option(WEIRD_ENGINE_USE_RUNTIME_ASSETS
+    "Load shaders/assets from runtime folder instead of source tree"
+    OFF
+)
+
+if (WEIRD_ENGINE_USE_RUNTIME_ASSETS)
+    set(WEIRD_ENGINE_FONTS_PATH "./fonts/")
+    set(WEIRD_ENGINE_SHADERS_PATH "./shaders/")
+else()
+    set(WEIRD_ENGINE_FONTS_PATH
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/weird-renderer/fonts/"
+    )
+    set(WEIRD_ENGINE_SHADERS_PATH
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/weird-renderer/shaders/"
+    )
+endif()
+
 target_compile_definitions(${PROJECT_NAME} PUBLIC
-    ENGINE_PATH="${CMAKE_CURRENT_SOURCE_DIR}"
-    SHADERS_PATH="${CMAKE_CURRENT_SOURCE_DIR}/src/weird-renderer/shaders/"
+    FONTS_PATH="${WEIRD_ENGINE_FONTS_PATH}"
+    SHADERS_PATH="${WEIRD_ENGINE_SHADERS_PATH}"
 )
 
-#
+# target_compile_definitions(${PROJECT_NAME} PRIVATE NOMINMAX)
+
 set_target_properties(${PROJECT_NAME} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lib
 )
 
-
-
 function(assign_source_groups TARGET)
     foreach(source_file IN LISTS ARGN)
         get_filename_component(FILE_PATH "${source_file}" PATH)

examples/3d-experiments/CMakeLists.txt

@@ -0,0 +1,94 @@
+cmake_minimum_required(VERSION 3.10)
+project(Weird3D)
+
+# Create folders if they don't exist
+file(MAKE_DIRECTORY "${CMAKE_SOURCE_DIR}/assets")
+file(MAKE_DIRECTORY "${CMAKE_SOURCE_DIR}/include")
+file(MAKE_DIRECTORY "${CMAKE_SOURCE_DIR}/src")
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Option to switch between local and online version of WeirdEngine
+option(USE_LOCAL_WEIRD_ENGINE "Use local version of WeirdEngine" ON)
+
+# Set paths for the local WeirdEngine
+set(WEIRD_ENGINE_LOCAL_PATH "../../")
+
+if(USE_LOCAL_WEIRD_ENGINE)
+    # Use the local version of WeirdEngine
+    message(STATUS "Using local version of WeirdEngine")
+    add_subdirectory(${WEIRD_ENGINE_LOCAL_PATH} ${CMAKE_BINARY_DIR}/weird-engine)
+else()
+    # Fetch WeirdEngine from GitHub
+    message(STATUS "Using online version of WeirdEngine")
+    include(FetchContent)
+    FetchContent_Declare(
+        WeirdEngine
+        GIT_REPOSITORY https://github.com/damacaa/weird-engine
+        GIT_TAG main
+    )
+    FetchContent_MakeAvailable(WeirdEngine)
+endif()
+
+# Glob source files and header files from the proper directories.
+file(GLOB_RECURSE WEIRDGAME_SOURCES "${CMAKE_SOURCE_DIR}/src/*.cpp")
+file(GLOB_RECURSE WEIRDGAME_HEADERS 
+    "${CMAKE_SOURCE_DIR}/include/*.h"
+    "${CMAKE_SOURCE_DIR}/include/*.hpp"
+)
+file(GLOB_RECURSE WEIRDGAME_ASSETS 
+    "${CMAKE_SOURCE_DIR}/assets/*.*"
+)
+
+# Mark headers as header-only so that Visual Studio treats them appropriately.
+set_source_files_properties(${WEIRDGAME_HEADERS} PROPERTIES HEADER_FILE_ONLY TRUE)
+
+# Add executable including both sources and headers.
+add_executable(${PROJECT_NAME} ${WEIRDGAME_SOURCES} ${WEIRDGAME_HEADERS} ${WEIRDGAME_ASSETS})
+
+# Set include directories.
+target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/include)
+target_include_directories(${PROJECT_NAME} PRIVATE
+    ${CMAKE_BINARY_DIR}/weird-engine/include
+    ${CMAKE_BINARY_DIR}/weird-engine/third-party/include
+)
+
+# Link to WeirdEngine.
+target_link_libraries(${PROJECT_NAME} PRIVATE WeirdEngine)
+
+# Set Asset Path Macro
+# Define the assets path variable
+set(ASSETS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/assets/")
+# set(ASSETS_PATH "./assets") # Set the asset path macro in release mode to a relative path that assumes the assets folder is in the same directory as the game executable
+
+# Print the assets path for debugging or confirmation
+message(STATUS "Assets path: ${ASSETS_PATH}")
+
+# Use the variable in target_compile_definitions
+target_compile_definitions(${PROJECT_NAME} PUBLIC ASSETS_PATH="${ASSETS_PATH}")
+
+if (MINGW)
+    target_link_options(${PROJECT_NAME} PRIVATE -static -static-libgcc -static-libstdc++)
+endif()
+
+# ----------------------------------------------------------
+# Helper function to assign source groups based on folder structure.
+function(assign_source_groups TARGET)
+    foreach(source_file IN LISTS ARGN)
+        # Get the full path to the file's directory.
+        get_filename_component(FILE_PATH "${source_file}" PATH)
+        # Compute the path relative to the project's root.
+        file(RELATIVE_PATH REL_PATH "${CMAKE_SOURCE_DIR}" "${FILE_PATH}")
+        # Replace forward slashes with backslashes for Visual Studio filter naming.
+        string(REPLACE "/" "\\" FILTER_PATH "${REL_PATH}")
+        if(FILTER_PATH STREQUAL "")
+            set(FILTER_PATH "Root")
+        endif()
+        # Assign the file to the computed filter.
+        source_group("${FILTER_PATH}" FILES "${source_file}")
+    endforeach()
+endfunction()
+
+# Assign source groups for all your files.
+assign_source_groups(${PROJECT_NAME} ${WEIRDGAME_SOURCES} ${WEIRDGAME_HEADERS} ${WEIRDGAME_ASSETS})

examples/sample-scenes/assets/fire/shaders/fireParticles.vert → examples/3d-experiments/assets/fire/shaders/fireParticles.vert

@@ -1,10 +1,10 @@
 #version 330 core
 
 // Vertex attributes
-layout (location = 0) in vec3 in_position;
-layout (location = 1) in vec3 in_normal;
-layout (location = 2) in vec3 in_color;
-layout (location = 3) in vec2 in_texCoord;
+layout(location = 0) in vec3 in_position;
+layout(location = 1) in vec3 in_normal;
+layout(location = 2) in vec3 in_color;
+layout(location = 3) in vec2 in_texCoord;
 
 // Outputs to fragment shader
 out vec3 v_worldPos;
@@ -20,9 +20,9 @@ uniform mat3 u_normalMatrix;
 uniform float u_time;
 
 // ChatGPT: I want a function that, for a given x, gros linearly but then plateaus
-float plateauFunction(float x, float maxValue, float growthRate) 
+float plateauFunction(float x, float maxValue, float growthRate)
 {
-    return maxValue * (1.0 - exp(-growthRate * x));
+	return maxValue * (1.0 - exp(-growthRate * x));
 }
 
 void main()
@@ -32,19 +32,16 @@ void main()
 
 	float maxHeight = 1.5 + (fract(gl_InstanceID * 123.45678) - 0.5); // Constant + random offset
 	float y = plateauFunction(2.0 * delta, maxHeight, 0.8);
-	
+
 	float distanceToCenterXZ = 0.1 + (0.3 * smoothstep(0, 1, sqrt(1.5 * delta))); // TODO: find an alternative to sqrt
 
-	vec3 offset = vec3(
-		distanceToCenterXZ * sin(u_time + gl_InstanceID), 
-		y, 
-		distanceToCenterXZ * cos(u_time + gl_InstanceID)
-	);
+	vec3 offset =
+		vec3(distanceToCenterXZ * sin(u_time + gl_InstanceID), y, distanceToCenterXZ * cos(u_time + gl_InstanceID));
 
-    v_worldPos = vec3(u_model * vec4(2.0 * (1.0 - delta * delta) * in_position, 1.0)) + offset;
-    v_normal   = u_normalMatrix * in_normal;
-    v_color    = in_color;
-    v_texCoord = in_texCoord;
+	v_worldPos = vec3(u_model * vec4(2.0 * (1.0 - delta * delta) * in_position, 1.0)) + offset;
+	v_normal = u_normalMatrix * in_normal;
+	v_color = in_color;
+	v_texCoord = in_texCoord;
 
-    gl_Position = u_camMatrix * vec4(v_worldPos, 1.0);
+	gl_Position = u_camMatrix * vec4(v_worldPos, 1.0);
 }

examples/3d-experiments/assets/fire/shaders/flame.frag

@@ -0,0 +1,71 @@
+#version 330 core
+
+out vec4 FragColor;
+
+// Inputs from vertex shader
+in vec3 v_worldPos;
+in vec3 v_normal;
+in vec3 v_color;
+in vec2 v_texCoord;
+
+uniform float u_time;
+
+uniform sampler2D t_noise;
+uniform sampler2D t_flameShape;
+
+const int NUM_STOPS = 4;
+uniform vec3 colors[NUM_STOPS] = vec3[](vec3(0.1, 0.1, 0.1), // Grey
+										vec3(0.8, 0.3, 0.2), // Red
+										vec3(1.1, 0.7, 0.2), // Orange
+										vec3(1.2, 1.2, 1.2)	 // White
+);
+
+uniform float stops[NUM_STOPS] = float[](0.0, 0.7, 0.9, 1.0);
+
+vec3 getGradientColor(float t)
+{
+	// This could be replace with a texture, but this approach makes it easier to iterate and choose colors
+	for (int i = 0; i < NUM_STOPS - 1; ++i)
+	{
+		if (t >= stops[i] && t <= stops[i + 1])
+		{
+			float localT = (t - stops[i]) / (stops[i + 1] - stops[i]);
+			return mix(colors[i], colors[i + 1], localT);
+		}
+	}
+
+	return colors[NUM_STOPS - 1]; // fallback
+}
+
+void main()
+{
+	vec2 uv = v_texCoord;
+
+	// Noise0
+	float noise0 = texture(t_noise, fract((3.0f * uv) - vec2(0.0f, u_time))).x - 0.5f;
+
+	// Noise1
+	float noise1 = texture(t_noise, fract((2.0 * uv) - vec2(0.0f, 1.2f * u_time))).x - 0.5f;
+
+	// Combine all noise
+	float sumNoise = noise0 + noise1;
+
+	// Reduce noise at the bottom of the flame
+	float noiseMask = clamp(3.0f * (v_texCoord.y - 0.35f), 0, 1);
+	sumNoise *= noiseMask;
+
+	// Reduce overall noise strength
+	float noiseIntensity = 0.1f;
+	sumNoise *= noiseIntensity;
+
+	// Sample texture with noise applied to uv coordinates
+	float alpha = texture(t_flameShape, clamp(uv + sumNoise, 0, 1)).x;
+
+	alpha = smoothstep(.3, 1.0, alpha);
+	alpha = alpha * (alpha + 0.01f);
+	alpha = clamp(alpha, 0.0, 1.0);
+
+	FragColor = vec4(getGradientColor(alpha), alpha);
+	// FragColor = vec4(vec3(sumNoise / noiseIntensity), 1.0f); // Debug noise
+	// FragColor = vec4(vec3(alpha), 1.0f); // Debug alpha
+}