Changed project back to C++

CMakeLists.txt

@@ -1,23 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-
-# set the project name
-project(RedScarfEngine VERSION 0.1.0)
-
-# specify the C++ standard
-set(CMAKE_C++_STANDARD 14)
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED True)
-
-if (MSVC)
-    # warning level 4 and all warnings as errors
-    add_compile_options(/W4 /WX)
-else()
-    # lots of warnings and all warnings as errors
-    add_compile_options(-Wall -Wextra -pedantic -Werror)
-endif()
-
-add_subdirectory(Graphics)
-add_subdirectory(RedScarfEngine)
-
-install(TARGETS RedScarfEngine GraphicsEngine
-        DESTINATION ${PROJECT_SOURCE_DIR}/bin)

Makefile

@@ -1,20 +1,45 @@
 CC := /usr/bin/g++
 INCLUDE_DIR := -I./include -I./third_party/vma/include
-CFLAGS := -g -Werror -Wall -std=c++17 $(INCLUDE_DIR)
+LFLAGS := -lglfw -lvulkan
+CFLAGS := -g -Wall -Werror -std=c++20 $(INCLUDE_DIR) $(LFLAGS)
 SRC_DIR := src
 BUILD_DIR := ./build
 TARGET := RedScarfEngine
 SOURCES :=  main.cpp \
 	vulkanBase.cpp \
-	window.cpp
+	window.cpp \
+	logger.cpp \
 
-OBJECTS := $(SOURCES:.cpp=.o) 
+OBJECTS := $(SOURCES:%=$(BUILD_DIR)/%)
+OBJECTS := $(OBJECTS:cpp=o)
 
-all: $(BUILD_DIR)/$(OBJECTS)
+SHADERS_DIR := ./shaders
-	$(CC) $(CFLAGS) -o $(BUILD_DIR)/$(TARGET) $(BUILD_DIR)/$(OBJECTS)
 
-$(BUILD_DIR)/main.o: $(SRC_DIR)/main.cpp   $(BUILD_DIR)/vulkanBase.o
+SHADER_OBJECTS := vertex.spv \
-	$(CC) $(CFLAGS) -c $(SRC_DIR)/main.cpp
+	fragments.spv \
 
-$(BUILD_DIR)/vulkanBase.o: $(SRC_DIR)/vulkanBase.cpp
+all: prepare_dirs $(OBJECTS) $(SHADER_OBJECTS)
-	$(CC) $(CFLAGS) -c $(SRC_DIR)/vulkanBase.cpp
+	$(CC) $(CFLAGS) -o $(BUILD_DIR)/$(TARGET) $(OBJECTS)
+
+# Build shader files
+vertex.spv: $(SHADERS_DIR)/shader.vert
+	glslc $^ -o $(BUILD_DIR)/$@
+
+fragments.spv: $(SHADERS_DIR)/shader.frag
+	glslc $^ -o $(BUILD_DIR)/$@
+
+$(BUILD_DIR)/%.spv:
+	echo $(basename $^)
+	glslc $^ -o $@
+
+# Generic build command
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.cpp
+	$(CC) $(CFLAGS) -c $^ -o $@
+
+.PHONY: prepare_dirs
+prepare_dirs:
+	mkdir -p ./build
+
+.PHONY: clean
+clean:
+	rm -rf ./build

include/localeVulkan.hpp

@@ -4,16 +4,24 @@
  * @brief Error messages for Vulkan initializers
  * @version 0.1
  * @date 2022-05-13
- * 
+ *
  * @copyright Copyright (c) 2022
- * 
+ *
  */
 
-#ifndef LOCALE_VULKAN_H
+#pragma once
-#define LOCALE_VULKAN_H
+
+#include <array>
+#include <vector>
 
 #include "localization.hpp"
 
+
+namespace rse::locale::vulkan
+{
+
+#define vulkanErrorMesssages vulkanErrorMesssages_nolocale[SELECTED_LANGUAGE]
+
 enum Errors
 {
     VULKAN_INTANCE_INIT_FAILED,
@@ -27,78 +35,58 @@ enum Errors
     VULKAN_SURFACE_CREATION_FAILED,
     VULKAN_SWAPCHAIN_CREATION_FAILED,
     VULKAN_SWAPCHAIN_IMVIEW_CREATION_FAILED,
+    VULKAN_SHADER_UNABLE_TO_OPEN,
+    VULKAN_SHADER_UNABLE_TO_CREATE_SHADER,
+    VULKAN_PIPELAYOUT_CREATION_FAILED,
+    VULKAN_RENDERPASS_CREATION_FAILED,
+    VULKAN_GRAPHICSPIPELINE_CREATION_FAILED,
+    VULKAN_FRAMEBUFFERS_CREATION_FAILED,
+    VULKAN_RECORD_COMMAND_BUFFER_FAILED,
+    VULKAN_SYNCOBJCTS_CREATION_FAILED,
     LAST_MESSAGE
 };
 
-const struct MessageString_t vulkanErrorMesssages[LAST_MESSAGE] =
+std::array<std::array<const char*, LAST_MESSAGE>, LAST_LANGUAGE> vulkanErrorMesssages_nolocale = {
-{
+    {/* EN_US */
-    {
+     /* VULKAN_INTANCE_INIT_FAILED */
-    38,
+     "Vulkan instance initialization failed",
-    {/* VULKAN_INTANCE_INIT_FAILED */
+     /* VULKAN_NO_PHYSICAL_DEVICES */
-        "Vulkan instance initialization failed"
+     "No physical graphical physical devices found in system",
+     /* VULKAN_NO_SUITABLE_PHYSICAL_DEVICES */
+     "No suitable physical device found",
+     /* VULKAN_QUEUE_NOT_SUPPORTED */
+     "Selected physical device does not support required queue capabilities",
+     /* VULKAN_FAILED_TO_CREATE_DEVICE */
+     "Failed to create logical device",
+     /* VULKAN_ALLOCATOR_CREATION_FAILED */
+     "Failed to create Vulkan Memory Allocator",
+     /* VULKAN_COMMAND_POOL_CREATION_FAILED */
+     "Failed to create command pool",
+     /* VULKAN_COMMAND_BUFFER_ALLOCATION_FAILED */
+     "Failed to allocate command buffers",
+     /* VULKAN_SURFACE_CREATION_FAILED */
+     "Failed to create window surface",
+     /* VULKAN_SWAPCHAIN_CREATION_FAILED */
+     "Failed to create swapchain",
+     /* VULKAN_SWAPCHAIN_IMVIEW_CREATION_FAILED */
+     "Failed to create swapchain image view",
+     /* VULKAN_SHADER_UNABLE_TO_OPEN */
+     "Failed to open a file containing shader code",
+     /* VULKAN_SHADER_UNABLE_TO_CREATE_SHADER */
+     "Failed to create a shader",
+     /* VULKAN_PIPELAYOUT_CREATION_FAILED */
+     "Failed to create pipeline layout",
+     /* VULKAN_RENDERPASS_CREATION_FAILED */
+     "Failed to create render pass",
+     /* VULKAN_GRAPHICSPIPELINE_CREATION_FAILED */
+     "Failed to create graphics pipeline",
+     /* VULKAN_FRAMEBUFFERS_CREATION_FAILED */
+     "Failed to create framebuffer",
+     /* VULKAN_RECORD_COMMAND_BUFFER_FAILED */
+     "Failed to record command buffer. Validate your commands.",
+     /* VULKAN_SYNCOBJCTS_CREATION_FAILED */
+     "Failed to create sync objects"
     }
-    },
-    {
-    55,
-    {/* VULKAN_NO_PHYSICAL_DEVICES */
-        "No physical graphical physical devices found in system"
-    }
-    },
-    {
-    35,
-    {/* VULKAN_NO_SUITABLE_PHYSICAL_DEVICES */
-        "No suitable physical device found"
-    }
-    },
-    {
-    70,
-    {/* VULKAN_QUEUE_NOT_SUPPORTED */
-        "Selected physical device does not support required queue capabilities"
-    }
-    },
-    {
-    23,
-    {/* VULKAN_FAILED_TO_CREATE_DEVICE */
-        "Failed to create logical device"
-    }
-    },
-    {
-    41,
-    {/* VULKAN_ALLOCATOR_CREATION_FAILED */
-        "Failed to create Vulkan Memory Allocator"
-    }
-    },
-    {
-    30,
-    {/* VULKAN_COMMAND_POOL_CREATION_FAILED */
-        "Failed to create command pool"
-    }
-    },
-    {
-    35,
-    {/* VULKAN_COMMAND_BUFFER_ALLOCATION_FAILED */
-        "Failed to allocate command buffers"
-    }
-    },
-    {
-    32,
-    {/* VULKAN_SURFACE_CREATION_FAILED */
-        "Failed to create window surface"
-    }
-    },
-    {
-    27,
-    {/* VULKAN_SWAPCHAIN_CREATION_FAILED */
-        "Failed to create swapchain"
-    }
-    },
-    {
-    38,
-    {/* VULKAN_SWAPCHAIN_IMVIEW_CREATION_FAILED */
-        "Failed to create swapchain image view"
-    }
-    },
 };
 
-
+}  // namespace rse::locale::vulkan
-#endif

include/localeWindow.hpp

@@ -9,7 +9,17 @@
  *
  */
 
-#include "localization.h"
+#pragma once
+
+#include <array>
+
+#include "localization.hpp"
+
+
+namespace rse::locale::window
+{
+
+#define windowErrorMesssages windowErrorMesssages_nolocale[SELECTED_LANGUAGE]
 
 enum Errors
 {
@@ -19,23 +29,15 @@ enum Errors
     LAST_MESSAGE
 };
 
-const struct MessageString_t windowErrorMesssages[LAST_MESSAGE] =
+std::array<std::array<const char*, LAST_LANGUAGE>, LAST_MESSAGE> windowErrorMesssages_nolocale = {
-{
+    {/* EN_US */
-    {
+     /* WINDOW_GLFW_INIT_FAILED */
-    17,
+     "GLFW init failed!"
-    {/* WINDOW_GLFW_INIT_FAILED */
+     /* WINDOW_VULKAN_NOT_SUPPORTED */
-        "GLFW init failed!"
+     "Unable to load Vulkan"
+     /*WINDOW_NOT_CREATED*/
+     "Window context creation failed"
     }
-    },
-    {
-    22,
-    {/* WINDOW_VULKAN_NOT_SUPPORTED */
-        "Unable to load Vulkan"
-    }
-    },
-    {
-    31,
-    {/*WINDOW_NOT_CREATED*/
-        "Window context creation failed"
-    }}
 };
+
+}  // namespace rse::locale::window

include/localization.hpp

@@ -1,5 +1,5 @@
 /**
- * @file localization.h
+ * @file localization.hpp
  * @author Piotr Krygier (everyonencancode@gmail.com)
  * @brief Simple localization header
  * @version 0.1
@@ -9,14 +9,11 @@
  *
  */
 
-#ifndef LOCALIZATION_H
+#pragma once
-#define LOCALIZATION_H
+#define SELECTED_LANGUAGE rse::locale::EN_US
 
-#include <stdlib.h>
+namespace rse::locale
-
+{
-#define SELECTED_LANGUAGE EN_US
-
-#define LOCALIZE(string) string.message[SELECTED_LANGUAGE]
 
 /**
  * @brief Available languages
@@ -28,24 +25,4 @@ enum Languages_t
     LAST_LANGUAGE
 };
 
-/**
+}  // namespace rse::locale
- * @brief
- *
- */
-struct MessageString_t
-{
-    /**
-     * @brief Maximum message length. I.e. if French version is longer than English, use French length.
-     *
-     */
-    size_t maxMessageLength;
-
-    /**
-     *
-     * @brief Array holding list of translations for specific message
-     *
-     */
-    const char* const message[LAST_LANGUAGE];
-};
-
-#endif /* LOCALIZATION_H */

include/log.hpp

@@ -1,90 +0,0 @@
-/**
- * @file log.hxx
- * @author Piotr Krygier (everyonencancode@gmail.com)
- * @brief Logging interfaces
- * @version 0.1
- * @date 2022-02-11
- *
- * @copyright Copyright (c) 2022
- *
- */
-
-#ifndef LOG_H
-#define LOG_H
-
-#include <stdio.h>
-
-/* Controls level of logging. TODO: Move this to cmake or some config */
-#define LOG_LEVEL 6
-
-#define LOG(level, ...) _LOG_##level(__VA_ARGS__)
-
-#if LOG_LEVEL >= 1
-#define _LOG_FATAL(...) __LOG(FATAL, __VA_ARGS__)
-#else
-#define _LOG_FATAL(...)
-#endif
-
-#if LOG_LEVEL >= 2
-#define _LOG_ERROR(...) __LOG(ERROR, __VA_ARGS__)
-#else
-#define _LOG_ERROR(...)
-#endif
-
-#if LOG_LEVEL >= 3
-#define _LOG_WARNING(...) __LOG(WARNING, __VA_ARGS__)
-#else
-#define _LOG_WARNING(...)
-#endif
-
-#if LOG_LEVEL >= 4
-#define _LOG_INFO(...) __LOG(INFO, __VA_ARGS__)
-#else
-#define _LOG_INFO(...)
-#endif
-
-#if LOG_LEVEL >= 5
-#define _LOG_DEBUG(...) __LOG(DEBUG, __VA_ARGS__)
-#else
-#define _LOG_DEBUG(...)
-#endif
-
-#if LOG_LEVEL >= 6
-#define _LOG_TRACE(...) __LOG(TRACE, __VA_ARGS__)
-#else
-#define _LOG_TRACE(...)
-#endif
-
-/* Macro magic, that makes logging work. It's better than C++ solution anyway... */
-#define _LOG_SIZEOF(...) __LOG_SIZEOF(__VA_ARGS__, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0)
-#define __LOG_SIZEOF(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, N, \
-                     ...)                                                                                          \
-    N
-#define _LOG_EVAL(x) x
-#define __LOG(level, ...) ___LOG(_LOG_SIZEOF(__VA_ARGS__), level, __VA_ARGS__)
-#define ___LOG(n, ...) ____LOG(n, __VA_ARGS__)
-#define ____LOG(n, ...) ____LOG##n(__VA_ARGS__)
-#define ____LOG1(level, format)      \
-    fprintf(stdout,                  \
-            "[" #level               \
-            "]"                      \
-            "\t%s:%d\t" format "\n", \
-            __builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__, __LINE__)
-#define ____LOG2(level, format, ...) \
-    fprintf(stdout,                  \
-            "[" #level               \
-            "]"                      \
-            "\t%s:%d\t" format "\n", \
-            __builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__, __LINE__, __VA_ARGS__)
-
-typedef enum
-{
-    TRACE = 1,
-    DEBUG = 2,
-    INFO = 3,
-    WARNING = 4,
-    ERROR = 5,
-    FATAL = 6
-} LogLevel;
-
-#endif /* LOG_H */

include/logger.hpp

@@ -0,0 +1,73 @@
+/**
+ * @file log.hpp
+ * @author Piotr Krygier (everyonencancode@gmail.com)
+ * @brief Logging interfaces
+ * @version 0.1
+ * @date 2022-02-11
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+
+#pragma once
+
+#include <sstream>
+
+#ifndef LOG_LEVEL
+#define LOG_LEVEL LOGLEVEL_WARNING
+#endif
+
+#define LOGT rse::log::Logger(rse::log::LOGLEVEL_TRACE)
+#define LOGD rse::log::Logger(rse::log::LOGLEVEL_DEBUG)
+#define LOGI rse::log::Logger(rse::log::LOGLEVEL_INFO)
+#define LOGW rse::log::Logger(rse::log::LOGLEVEL_WARNING)
+#define LOGE rse::log::Logger(rse::log::LOGLEVEL_ERROR)
+#define LOGF rse::log::Logger(rse::log::LOGLEVEL_FATAL)
+
+
+namespace rse::log
+{
+
+/**
+ * @brief Log level. Is not an enum class, because level is being compared to enable prints
+ * 
+ */
+typedef enum
+{
+    LOGLEVEL_TRACE = 1,
+    LOGLEVEL_DEBUG = 2,
+    LOGLEVEL_INFO = 3,
+    LOGLEVEL_WARNING = 4,
+    LOGLEVEL_ERROR = 5,
+    LOGLEVEL_FATAL = 6
+} LogLevel;
+
+/**
+ * @brief Class used indirectly as a logger.
+ *
+ */
+class Logger {
+   private:
+    std::stringstream mMessageBuffer;
+
+   public:
+    /**
+     * @brief Construct a new Logger object
+     * 
+     */
+    Logger(LogLevel);
+    ~Logger();
+
+    /**
+     * @brief For log printing. I want it to work like log << "Message " << args;
+     *
+     */
+    template <typename T>
+    Logger& operator<<(T&& message)
+    {
+        mMessageBuffer << message;
+        return *this;
+    }
+};
+
+}  // namespace rse::log

include/vulkanBase.hpp

@@ -4,15 +4,21 @@
  * @brief Vulkan wrapper functions used by other parts of Graphics component
  * @version 0.1
  * @date 2022-05-13
- * 
+ *
  * @copyright Copyright (c) 2022
- * 
+ *
  */
 
-#ifndef VULKAN_BASE_H
+#pragma once
-#define VULKAN_BASE_H
 
-int initVulkan();
+#include <cstdint>
+
+namespace rse::graphics::vulkanbase
+{
+
+uint8_t initVulkan();
 void deinitVulkan();
 
-#endif /* VULKAN_BASE_H */
+void drawFrame();
+
+} /* namespace rse::graphics::vulkanbase */

include/window.hpp

@@ -9,14 +9,16 @@
  *
  */
 
-#ifndef WINDOW_HANDLER_H
+#pragma once
-#define WINDOW_HANDLER_H
 
-/* Vulkan header MUST be included before glfw */
 #include <vulkan/vulkan.h>
 
+/* Vulkan header MUST be included before glfw */
 #include <GLFW/glfw3.h>
 
+namespace rse::graphics::window
+{
+
 /**
  * @brief Initialize window
  *
@@ -42,4 +44,4 @@ void windowTerminate();
 
 GLFWwindow* getWindowHandle();
 
-#endif /* WINDOW_HANDLER_H */
+} /* namespace rse::graphics::window */

shaders/shader.frag

@@ -0,0 +1,9 @@
+#version 450
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}

shaders/shader.vert

@@ -0,0 +1,20 @@
+#version 450
+
+layout(location = 0) out vec3 fragColor;
+
+vec2 positions[3] = vec2[](
+    vec2(0.0, -0.5),
+    vec2(0.5, 0.5),
+    vec2(-0.5, 0.5)
+);
+
+vec3 colors[3] = vec3[](
+    vec3(1.0, 0.0, 0.0),
+    vec3(0.0, 1.0, 0.0),
+    vec3(0.0, 0.0, 1.0)
+);
+
+void main() {
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    fragColor = colors[gl_VertexIndex];
+}

src/logger.cpp

@@ -0,0 +1,58 @@
+/**
+ * @file logger.cpp
+ * @author Piotr Krygier (everyonecancode@gmail.com)
+ * @brief Implementation for the logger
+ * @version 0.1
+ * @date 2022-07-06
+ *
+ * @copyright Copyright (c) 2022
+ *
+ */
+
+#include "logger.hpp"
+
+#include <iostream>
+
+namespace rse::log
+{
+
+Logger::Logger(LogLevel level)
+{
+    if (level < LOG_LEVEL)
+    {
+        return;
+    }
+    
+    switch (level)
+    {
+    case LOGLEVEL_TRACE:
+        mMessageBuffer << "[TRACE] ";
+        break;
+    case LOGLEVEL_DEBUG:
+        mMessageBuffer << "[DEBUG] ";
+        break;
+    case LOGLEVEL_INFO:
+        mMessageBuffer << "[INFO] ";
+        break;
+    case LOGLEVEL_WARNING:
+        mMessageBuffer << "[WARNING] ";
+        break;
+    case LOGLEVEL_ERROR:
+        mMessageBuffer << "[ERROR] ";
+        break;
+    case LOGLEVEL_FATAL:
+        mMessageBuffer << "[FATAL] ";
+        break;
+    
+    default:
+        break;
+    }
+    
+}
+
+Logger::~Logger()
+{
+    std::cout << mMessageBuffer.str() << std::endl;
+}
+
+}  // namespace rse::log

src/main.cpp

@@ -1,4 +1,4 @@
-#include "log.hpp"
+#include "logger.hpp"
 #include "window.hpp"
 #include "vulkanBase.hpp"
 
@@ -8,15 +8,15 @@ int main(int argc, char** argv)
     (void)argc;
     (void)argv;
 
-    windowInit();
+    rse::graphics::window::windowInit();
 
-    initVulkan();
+    rse::graphics::vulkanbase::initVulkan();
 
-    windowLoop();
+    rse::graphics::window::windowLoop();
 
-    deinitVulkan();
+    rse::graphics::vulkanbase::deinitVulkan();
 
-    windowTerminate();
+    rse::graphics::window::windowTerminate();
 
     return 0;
 }

src/window.cpp

@@ -9,10 +9,16 @@
  *
  */
 
-#include "window.h"
+#include "window.hpp"
 
-#include "localeWindow.h"
+#include "localeWindow.hpp"
-#include "log.h"
+#include "logger.hpp"
+#include "vulkanBase.hpp"
+
+namespace rse::graphics::window
+{
+
+using namespace locale::window;
 
 /* Error codes */
 typedef enum {
@@ -33,7 +39,7 @@ GLFWwindow *gpWindowHandle = NULL;
 static void errrorCallback(int error, const char* description)
 {
     (void)error;
-    LOG(ERROR, "Error: %s", description);
+    LOGE << "Error: " << description;
 }
 
 /**
@@ -55,19 +61,20 @@ static void keyCallback(GLFWwindow* window, int key, int scancode, int action, i
     }
 }
 
+
 uint16_t windowInit()
 {
     /* Initiliaze GLFW AP */
     if (GLFW_TRUE != glfwInit())
     {
-        LOG(FATAL, "%s", LOCALIZE(windowErrorMesssages[WINDOW_GLFW_INIT_FAILED]));
+        LOGF << windowErrorMesssages[WINDOW_GLFW_INIT_FAILED];
         return WINDOW_ERROR_GLFW_INIT_FAILED;
     }
 
 
     /* Check for Vulkan support */
     if (GLFW_FALSE == glfwVulkanSupported()) {
-        LOG(FATAL, "%s", LOCALIZE(windowErrorMesssages[WINDOW_VULKAN_NOT_SUPPORTED]));
+        LOGF << windowErrorMesssages[WINDOW_VULKAN_NOT_SUPPORTED];
         return WINDOW_ERROR_VULKAN_NOT_LOADED;
     }
 
@@ -80,7 +87,7 @@ uint16_t windowInit()
     gpWindowHandle = glfwCreateWindow(640, 480, "RedScarfEngine", NULL, NULL);
 
     if (NULL == gpWindowHandle) {
-        LOG(FATAL, "%s", LOCALIZE(windowErrorMesssages[WINDOW_NOT_CREATED]));
+        LOGF << windowErrorMesssages[WINDOW_NOT_CREATED];
         return WINDOW_ERROR_WINDOW_NOT_CREATED;
     }
 
@@ -93,6 +100,7 @@ uint16_t windowLoop()
 {
     while (!glfwWindowShouldClose(gpWindowHandle)) {
         glfwPollEvents();
+        rse::graphics::vulkanbase::drawFrame();
     }
 
     return WINDOW_ERROR_NO_ERROR;
@@ -108,4 +116,6 @@ void windowTerminate()
 GLFWwindow* getWindowHandle()
 {
     return gpWindowHandle;
-}
+}
+
+} /* namespace rse::graphics::window */