Graphics Engine is now part of the whole engine instead, Project will

actually compile #9

BarinkEngine/BarinkEngine.cpp

@@ -1,4 +1,4 @@
-#include "Include/BarinkEngine.h"
+#include "BarinkEngine.h"
 
 extern void Start(int argc, char* argv[]);
 extern void UpdateApplication();
@@ -31,4 +31,7 @@ int main(int argc, char* argv[]) {
 }
 
 
+void WARN(std::string message) {
+	spdlog::warn(message);
 
+}

BarinkEngine/Include/AssetManager/ModelImporter.h

@@ -0,0 +1,26 @@
+#pragma once
+#define TINYGLTF_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define TINYGLTF_NO_EXTERNAL_IMAGE
+
+#include "Graphics/Mesh.h"
+#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h> 
+#include <string>
+
+class ModelImporter {
+private:
+	void ImportFBX(std::string path); 
+	void ImportBlend(std::string path);
+	void ImportGLTF(std::string path);
+	void ImportOBJ(std::string path);
+	static BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene);
+	static std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene);
+
+public:
+	void Import(std::string path);
+
+	static std::vector<BarinkEngine::Mesh> Test();
+};

BarinkEngine/Include/BarinkEngine.h

@@ -2,21 +2,19 @@
 #include <iostream>
 #include <string>
 #include <filesystem>
+
+
 #include "Engine.h"
-
-#include <spdlog/spdlog.h>
-
-/*
-#include "../MemoryManager.h"
-#include <glm/glm.hpp>
+#include "glm/glm.hpp"
 
 
-#include <MyGraphicsEngine/Shader.h>
-#include <MyGraphicsEngine/Window.h>
-#include <MyGraphicsEngine/Camera.h>
-#include <MyGraphicsEngine/Renderable.h>
-
+#include "graphics/Shader.h"
+#include "graphics/Window.h"
+#include "graphics/Camera.h"
+#include "graphics/Renderable.h"
+#include "spdlog/spdlog.h"
 
+#include "MemoryManager.h"
 
 extern "C"
 {
@@ -24,5 +22,4 @@ extern "C"
 	#include "lua.h"
 	#include "lualib.h"
 }
-
-*/
+void WARN(std::string message);

BarinkEngine/Include/Editor/EditorWindow.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <string>
+
+class EditorWindow {
+protected:
+	std::string WindowTitle;
+
+public:
+
+	virtual void Show() = 0;
+
+};

BarinkEngine/Include/Engine.h

@@ -1,7 +1,7 @@
 #pragma once
 namespace BarinkEngine {
 
-	static class Engine {
+class Engine {
 	public:
 		static void Startup();
 		static void Shutdown();

BarinkEngine/Include/Graphics/Buffer.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <glad/glad.h>
+class Buffer {
+private:
+	unsigned int id;
+public:
+
+	int getBufferID();
+
+	void createBuffer();
+
+	void setBufferData(void* data, size_t dataSize, bool elementBuffer );
+
+	void Bind(bool elementBuffer);
+	void Unbind(bool elementBuffer);
+
+	void Delete();
+
+};

BarinkEngine/Include/Graphics/Camera.h

@@ -0,0 +1,22 @@
+#pragma once
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+class Camera {
+public:
+	glm::vec3 Position;
+	glm::vec3 Rotation;
+	float Zoom;
+
+	Camera(glm::vec3 position, glm::vec3 rotation, float zoom );
+	~Camera();
+
+	glm::mat4 GetViewMatrix();
+
+
+private:
+	glm::vec3 Front;  
+	glm::vec3 Right;
+	glm::vec3 Up;
+
+};

BarinkEngine/Include/Graphics/Mesh.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <vector>
+#include <glm/glm.hpp>
+
+namespace BarinkEngine{
+
+	class Mesh {
+	public:
+		std::vector<glm::vec3> vertices;
+		std::vector<unsigned int > elements;
+		std::vector<glm::vec2> uv;
+	};
+}

BarinkEngine/Include/Graphics/Renderable.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <vector>
+#include "Mesh.h"
+#include "Transform.h"
+#include "Buffer.h"
+#include "VertexArray.h"
+
+/*
+#include <MyGraphicsEngine/AssetManager/ModelImporter.h>
+#include <MyGraphicsEngine/MyGraphicsEngine/Buffer.h>
+#include <MyGraphicsEngine/MyGraphicsEngine/VertexArray.h>
+
+*/
+
+class Renderable {
+private:
+	std::vector<BarinkEngine::Mesh> meshes;
+	Renderable();
+	
+public:
+	Buffer vertexBuffer;
+	Buffer elementBuffer;
+	VertexArray VAO;
+	Transform transform;
+	~Renderable();
+
+	static Renderable Load();
+	void Draw();
+
+};

BarinkEngine/Include/Graphics/Shader.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <glad/glad.h>
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+
+class Shader {
+    private:
+        int id;
+        char* readFile (const char* filePath);
+    public:
+        Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath);
+        void Use();
+        void setUniformMat4(std::string uniformName, glm::mat4 matrix4);
+        void setUniformVec4(std::string uniformName, glm::vec4 vector4);
+        void setUniformVec3(std::string uniformName, glm::vec3 vector3);
+        void setUniformVec2(std::string uniformName, glm::vec2 vector2);
+        void setUniformFloat(std::string uniformName, float value);
+        void setUniformInt(std::string uniformName, int value);
+
+
+};

BarinkEngine/Include/Graphics/Transform.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <glm/glm.hpp>
+
+struct Transform {
+	glm::vec3 Position;
+	glm::vec3 Rotation;
+	glm::vec3 Scale;
+};

BarinkEngine/Include/Graphics/VertexArray.h

@@ -0,0 +1,18 @@
+#pragma once 
+
+class VertexArray{
+private:
+unsigned int id;
+
+
+public:
+void Create();
+void Bind();
+void Unbind();
+
+void Delete();
+
+void AttachAttribute(unsigned int index, int size, int stride);
+
+
+};

BarinkEngine/Include/Graphics/Window.h

@@ -0,0 +1,33 @@
+#pragma once 
+#define GLFW_STATIC
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+
+
+
+
+class BarinkWindow{
+    private:
+        GLFWwindow* window;
+        bool FullScreen;
+        bool VulkanSupported;
+        int Width, Height;
+
+        static bool InitGLFW();
+
+
+    public:
+        BarinkWindow(const int width, const int height);
+        ~BarinkWindow();
+
+        GLFWwindow* windowptr();
+
+        bool WindowShouldClose();
+
+        void Poll();
+        void SwapBuffers();
+
+
+};

BarinkEngine/Include/MemoryManager.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <iostream>
+#include <stdlib.h>
+
+static int HeapAllocations = 0;
+static int HeapDeallocations = 0;
+
+inline void* operator new(std::size_t sz) {
+	HeapAllocations++;
+	return std::malloc(sz);
+}
+
+inline void operator delete(void* ptr) noexcept {
+	HeapDeallocations++;
+	std::free(ptr);
+}
+

BarinkEngine/graphics/Buffer.cpp

@@ -0,0 +1,47 @@
+#include "Graphics/Buffer.h"
+
+
+int Buffer::getBufferID() {
+	return id;
+}
+
+void Buffer::createBuffer() {
+	glGenBuffers(1, (GLuint*) &id);
+}
+
+void Buffer::setBufferData(void* data, size_t dataSize, bool elementBuffer = false ) {
+	
+	if (elementBuffer) {
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER, dataSize, data, GL_STATIC_DRAW);
+
+	}
+	else {
+		glBufferData(GL_ARRAY_BUFFER, dataSize, data, GL_STATIC_DRAW);
+	}
+
+}
+
+void Buffer::Bind(bool elementBuffer = false ) {
+	if (elementBuffer) {
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
+
+	}
+	else {
+		glBindBuffer(GL_ARRAY_BUFFER, id);
+
+	}
+}
+
+void Buffer::Unbind(bool elementBuffer = false) {
+	if (elementBuffer) {
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+	}
+	else {
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	}
+}
+
+void Buffer::Delete() {
+	glDeleteBuffers(1, (GLuint*) &id);
+}

BarinkEngine/graphics/Camera.cpp

@@ -0,0 +1,22 @@
+#include "Graphics/Camera.h"
+
+Camera::Camera(glm::vec3 position, glm::vec3 rotation, float zoom)
+: Position(position), Rotation(rotation), Zoom(zoom) {
+	
+	Front = glm::vec3(-1.0f, 0.0f, 0.0f);
+	Right = glm::vec3(0.0f, 0.0f, 1.0f);
+	Up = glm::vec3(0.0f, 1.0f, 0.0f);
+
+}
+
+Camera::~Camera() {
+
+}
+
+glm::mat4 Camera::GetViewMatrix() {
+	return glm::lookAt(
+		Position,
+		Position + Front,
+		Up
+	);
+}

BarinkEngine/graphics/ModelImporter.cpp

@@ -0,0 +1,117 @@
+#include "AssetManager/ModelImporter.h"
+
+
+void ModelImporter::ImportFBX(std::string path)
+{
+    //spdlog::warn("ImportFBX not implemented!");
+}
+
+void ModelImporter::ImportBlend(std::string path)
+{
+    //spdlog::warn("ImportBlend not implemented!");
+}
+
+void ModelImporter::ImportGLTF(std::string path)
+{
+    //spdlog::warn("ImportGLTF not implemented!");
+}
+
+void ModelImporter::ImportOBJ(std::string path)
+{
+    //spdlog::warn("ImportOBJ not implemented!");
+}
+
+void ModelImporter::Import(std::string path)
+{
+    //spdlog::warn("Import not implemented!");
+}
+
+std::vector<BarinkEngine::Mesh> ModelImporter::Test() {
+   
+    /*
+    spdlog::info("====== Tiny GLTF ======");
+    tinygltf::Model loadedModel;
+    tinygltf::TinyGLTF loader;
+    std::string error;
+    std::string warn;
+    bool ret = loader.LoadASCIIFromFile(&loadedModel, &error, &warn, "./Build/SandboxApplication/Debug/sponza.gltf");
+
+    if (!warn.empty())
+        spdlog::warn("TinyGLTF Warning: {}", warn);
+    if (!error.empty())
+        spdlog::error("TinyGLTF Error: {}", error);
+    if (!ret) {
+        spdlog::error("TinyGLTF Error: Failed to parse glTF");
+        exit(-1);
+    }
+
+    spdlog::info("Meshes in model: {}", loadedModel.meshes.size());
+    spdlog::info("Primitives in mesh: {}", loadedModel.meshes[0].primitives.size());
+
+    */
+    
+   
+    //spdlog::info("======= Assimp ======");
+
+    Assimp::Importer importer;
+    const aiScene* scene = importer.ReadFile("build/SandboxApplication/Debug/Cube.obj", aiProcess_Triangulate | aiProcess_FlipUVs);
+    
+    aiNode* currentNode = scene->mRootNode;
+
+   return processNode(currentNode, scene);
+
+
+}
+
+std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene) {
+    std::vector<BarinkEngine::Mesh> meshes;
+    for (unsigned int i = 0; i < node->mNumMeshes; i++) {
+        aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+        meshes.push_back(processMesh(mesh, scene));
+    }
+
+    for (unsigned int i = 0; i < node->mNumChildren; i++) {
+       auto m2 =  processNode(node->mChildren[i], scene);
+
+       for(auto m : m2) {
+           meshes.push_back(m);
+       }
+    }
+
+    return meshes;
+}
+
+BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) {
+    std::vector<glm::vec3> vertices ; 
+    std::vector<unsigned int> indices;
+
+    // Process vertices
+    for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
+        glm::vec3 vector;
+        vector.x = mesh->mVertices[i].x;
+        vector.y = mesh->mVertices[i].y;
+        vector.z = mesh->mVertices[i].z;
+        vertices.push_back(vector);
+    }
+
+    //spdlog::info("{} == {}", mesh->mNumVertices, vertices.size());
+
+    // Process Indices
+    for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
+        aiFace face = mesh->mFaces[i];
+        if (face.mNumIndices < 3)
+            continue;
+        for (unsigned int j = 0; j < face.mNumIndices; j++) {
+            indices.push_back(face.mIndices[j]);
+        }
+    }
+
+    BarinkEngine::Mesh result;
+    
+
+    result.vertices = vertices;
+    result.elements = indices;
+
+    return result;
+
+}

BarinkEngine/graphics/Renderable.cpp

@@ -0,0 +1,53 @@
+#include "Graphics/Renderable.h"
+#include "AssetManager/ModelImporter.h"
+
+
+
+Renderable Renderable::Load()
+{
+    return Renderable();
+}
+
+Renderable::Renderable()
+{
+
+    meshes = ModelImporter::Test();
+
+    transform.Scale = glm::vec3(1.0f);
+    transform.Rotation = glm::vec3(0.0f, 90.0f, 0.0f);
+    transform.Position = glm::vec3(0.0f, 0.0f, -10.0f);
+
+
+    VAO.Create();
+    VAO.Bind();
+
+
+    vertexBuffer.createBuffer();
+    vertexBuffer.Bind(false);
+    vertexBuffer.setBufferData(&meshes[0].vertices[0], meshes[0].vertices.size() * sizeof(glm::vec3), false);
+
+
+    elementBuffer.createBuffer();
+    elementBuffer.Bind(true);
+    elementBuffer.setBufferData(&meshes[0].elements[0], meshes[0].elements.size() * sizeof(unsigned int), true);
+
+    VAO.AttachAttribute(0, 3, 0);
+
+    vertexBuffer.Unbind(false);
+    VAO.Unbind();
+
+
+}
+
+Renderable::~Renderable()
+{
+}
+
+void Renderable::Draw()
+{
+    VAO.Bind();
+    elementBuffer.Bind(true);
+    glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(meshes[0].elements.size()), GL_UNSIGNED_INT, NULL);
+    VAO.Unbind();
+
+}

BarinkEngine/graphics/Shader.cpp

@@ -0,0 +1,124 @@
+#include "Graphics/Shader.h"
+
+Shader::Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath)
+{
+    char infoLog[512];
+    int succes;
+    
+    char* vertexCode = readFile(vertexShaderPath.c_str());
+    //spdlog::info(vertexCode);
+    unsigned int vertId = glCreateShader(GL_VERTEX_SHADER);
+    
+    glShaderSource(vertId, 1, &vertexCode, NULL);
+    glCompileShader(vertId);
+
+    glGetShaderiv(vertId, GL_COMPILE_STATUS, &succes);
+    if(!succes){
+        glGetShaderInfoLog(vertId, 512, NULL, infoLog);
+        //spdlog::error( "Vertex shader has compile error {}", infoLog);
+        return;
+    }
+
+
+    char* fragmentCode = readFile(fragmentShaderPath.c_str());
+    //spdlog::info(fragmentCode); 
+    unsigned int fragId = glCreateShader(GL_FRAGMENT_SHADER);
+
+
+    
+    glShaderSource(fragId, 1, &fragmentCode, NULL);
+    glCompileShader(fragId);
+
+    
+    glGetShaderiv(fragId, GL_COMPILE_STATUS, &succes);
+    if(!succes){
+        glGetShaderInfoLog(fragId, 512, NULL, infoLog);
+        //spdlog::error("Fragment shader has compile error {}", infoLog);
+        return;
+    }
+
+    id = glCreateProgram();
+
+    glAttachShader(id, vertId);
+    glAttachShader(id, fragId);
+    glLinkProgram(id);
+
+
+    int success;
+    glGetProgramiv(id, GL_LINK_STATUS, &success);
+    if(!success) {
+        glGetProgramInfoLog(id, 512, NULL, infoLog);
+        printf("ERROR::SHADER_PROGRAM::LINKING_FAILED\n %s", infoLog);
+    }
+
+
+    delete vertexCode;
+    delete fragmentCode;
+
+
+}
+char* Shader::readFile (const char* filePath){
+
+    std::ifstream file ;
+    file.open(filePath);
+
+    if(file.is_open() == false){
+        //spdlog::info("File not found.");
+         return nullptr;
+    }
+
+
+    // Determine the file size!
+    file.seekg(0, std::ios::end);
+    size_t filesize = file.tellg();
+
+    // Undo previous seek.
+    file.seekg(0, std::ios::beg);
+    //spdlog::info("filesize: {}", filesize);
+
+
+    // Create a big enough buffer for the file
+
+    size_t bufferSize = filesize + 3;
+    char* FileBuffer = new char[bufferSize];
+ 
+    memset(FileBuffer, '\0', bufferSize);
+   
+    // read the whole file
+    file.read(FileBuffer, filesize);
+    
+    return FileBuffer;
+}
+
+void Shader::Use()
+{
+    glUseProgram(id);
+}
+
+
+void Shader::setUniformMat4(std::string uniformName, glm::mat4 matrix4) 
+{    
+    glUniformMatrix4fv(glGetUniformLocation(id, uniformName.c_str()), 1, GL_FALSE, glm::value_ptr(matrix4));
+}
+void Shader::setUniformVec4(std::string uniformName, glm::vec4 vector4) 
+{
+    glUniform4fv(glGetUniformLocation(id, uniformName.c_str()), 1, glm::value_ptr(vector4));
+}
+void Shader::setUniformVec3(std::string uniformName, glm::vec3 vector3) 
+{
+    glUniform3fv(glGetUniformLocation(id, uniformName.c_str()), 1, glm::value_ptr(vector3));
+}
+void Shader::setUniformVec2(std::string uniformName, glm::vec2 vector2) 
+{
+    glUniform2fv(glGetUniformLocation(id, uniformName.c_str()),1, glm::value_ptr(vector2));
+}
+
+void Shader::setUniformFloat(std::string uniformName, float value) 
+{
+    glUniform1f(glGetUniformLocation(id, uniformName.c_str()), value);
+}
+
+void Shader::setUniformInt(std::string uniformName, int value) 
+{
+    glUniform1i(glGetUniformLocation(id, uniformName.c_str()), value);
+}

BarinkEngine/graphics/VertexArray.cpp

@@ -0,0 +1,25 @@
+#include "Graphics/VertexArray.h"
+#include <glad/glad.h>
+
+void VertexArray::Create(){
+    glGenVertexArrays(1, &id);
+}
+
+void VertexArray::Bind(){
+    glBindVertexArray(id);
+}
+
+void VertexArray::Unbind(){
+    glBindVertexArray(0);
+}
+
+void VertexArray::Delete() {
+    glDeleteVertexArrays(1, &id);
+}
+
+
+void VertexArray::AttachAttribute(unsigned int index , int size, int stride  ){
+    glVertexAttribPointer(index, size, GL_FLOAT, GL_FALSE, stride, 0);
+    glEnableVertexAttribArray(0);
+}
+

BarinkEngine/graphics/shaders/fragment.shader

@@ -0,0 +1,7 @@
+#version 440 core
+
+out vec4 FragColor;
+
+void main(){
+	FragColor = vec4(0.5f, 0.5f, 0.0f , 1.0f);
+}

BarinkEngine/graphics/shaders/vertex.shader

@@ -0,0 +1,10 @@
+#version 440 core
+in layout(location=0) vec3 aPos;
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+
+void main() {
+    gl_Position = P * V * M * vec4(aPos.x, aPos.y, aPos.z, 1.0);
+}

BarinkEngine/graphics/window.cpp

@@ -0,0 +1,74 @@
+#include "Graphics/Window.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+
+bool BarinkWindow::InitGLFW(){
+	if(!glfwInit())
+	{
+//		spdlog::error("Failed to initialise GLFW!");
+		return false;
+	}
+	
+	return true;
+}
+
+BarinkWindow::BarinkWindow(const int width, const int height) :
+Width(width), Height(height), FullScreen(false){
+	if (InitGLFW()==false) {
+		exit(-1);
+	}
+
+	window = glfwCreateWindow(Width, Height, "BarinkEngine", NULL, NULL);
+
+	if( !window)
+	{
+//		spdlog::error("GLFW failed to create window!");
+		glfwTerminate();
+		return;
+	}
+
+	glfwMakeContextCurrent(window);
+	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+		printf("Failed to initialize GLAD!\n");
+		exit(-1);
+	}
+
+	VulkanSupported = glfwVulkanSupported();
+
+	glfwGetFramebufferSize(window, &Width, &Height);
+	glViewport(0,0, Width, Height);
+
+
+
+	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+
+
+
+}
+
+
+BarinkWindow::~BarinkWindow(){
+
+	glfwTerminate();
+}
+
+GLFWwindow* BarinkWindow::windowptr()
+{
+	return window;
+}
+
+bool BarinkWindow::WindowShouldClose(){
+	return glfwWindowShouldClose(window);
+}
+
+void BarinkWindow::Poll()
+{
+	
+	glfwPollEvents();
+}
+
+void BarinkWindow::SwapBuffers() 
+{
+	glfwSwapBuffers(window);
+}

BarinkEngine/premake5.lua

@@ -3,32 +3,56 @@ project "BarinkEngine"
 
   buildmessage "Building BarinkEngine"
 
-  includedirs{
-    "./../libs/lua/include",
-    "./libs/spdlog/include",
+  includedirs {
+    "Include/",
 
-    "./../libs/glm",
-    "./../MyGraphicsEngine/include",
+    "../libs/lua/include",
+    "../libs/spdlog/include",
+    "../libs/glm",
+    "../libs/GorillaAudio/include",
 
-    "./../libs/GorillaAudio/include"
+    "../libs/assimp/include",
+    "../libs/glad/include",
+    "../libs/glfw/include",
+    "../libs/tinygltf",
+    "../libs/glew/include",
+    "../libs/glm",
+    "../libs/ImGui",
 
   }
 
   libdirs {
-    "./../libs/lua",
-    "./../libs/spdlog/build/Release"
+    "../libs/lua",
+    "../libs/spdlog/build/Release",
+    "../libs/assimp/lib/Debug",
+    "../libs/glfw/build/src/Debug",
+    "../libs/ImGui"
   }
 
   links {
     "lua54",
     "spdlog",
-    "MyGraphicsEngine"
+    "assimp-vc143-mtd",
+    "glfw3"
   }
 
   files {
+    "../libs/ImGui/*.cpp",
+    "../libs/ImGui/backends/imgui_impl_glfw.cpp",
+    "../libs/ImGui/backends/imgui_impl_Opengl3.cpp",
+    "../libs/glad/src/glad.c",
+
     "./*.cpp",
     "./*.h",
     "./**/*.cpp",
     "./**/*.h"
   }
 
+
+
+  -- NOTE: make these copy instructions more flexible
+  ok, err = os.copyfile("graphics/shaders/fragment.shader", "../build/SandboxApplication/Debug/test.fs")
+  if err then error("Copy fragment shader source failed!") end
+
+  ok, err = os.copyfile("graphics/shaders/vertex.shader", "../build/SandboxApplication/Debug/test.vs")
+  if err then error("Copy vertex shader source failed!") end