8 Commits

Author SHA1 Message Date
db6def3bc9 FIXED inputsystem linker error 2022-08-15 21:15:12 +02:00
ab5599f1fc Started development of BECS - the basic ECS system for the engine 2022-08-06 18:24:05 +02:00
3639f967e1 Ignore untracked file changes in some submodules
These files are probably nothing of great importance to our
development and thus have no business showing up in our git status
2022-08-06 18:22:10 +02:00
5a06b068f3 Moving source files to a src folder 2022-08-06 18:21:42 +02:00
e31fd036ea Added the basics for a scene explorer in ImGui 2022-07-10 15:52:25 +02:00
6a2e8d3b2f Basic Scene creation 2022-07-09 22:21:56 +02:00
f8b390923e Working on semi proper API to build a scene 2022-07-09 21:22:50 +02:00
b7e3465406 Editing the modelimporter to allow to create scene graphs 2022-07-08 21:35:14 +02:00
64 changed files with 974 additions and 926 deletions

3
.gitmodules vendored
View File

@ -4,12 +4,14 @@
[submodule "glm"] [submodule "glm"]
path = libs/glm path = libs/glm
url = https://github.com/nigelbarink/glm.git url = https://github.com/nigelbarink/glm.git
ignore = untracked
[submodule "spdlog"] [submodule "spdlog"]
path = libs/spdlog path = libs/spdlog
url = https://github.com/nigelbarink/spdlog.git url = https://github.com/nigelbarink/spdlog.git
[submodule "tinygltf"] [submodule "tinygltf"]
path = libs/tinygltf path = libs/tinygltf
url = https://github.com/syoyo/tinygltf.git url = https://github.com/syoyo/tinygltf.git
ignore = untracked
[submodule "GorrillaAudio"] [submodule "GorrillaAudio"]
path = libs/GorillaAudio path = libs/GorillaAudio
url = https://github.com/mewspring/gorilla-audio.git url = https://github.com/mewspring/gorilla-audio.git
@ -22,6 +24,7 @@
[submodule "libs/steam-audio"] [submodule "libs/steam-audio"]
path = libs/steam-audio path = libs/steam-audio
url = https://github.com/ValveSoftware/steam-audio.git url = https://github.com/ValveSoftware/steam-audio.git
ignore = untracked
[submodule "libs/physx"] [submodule "libs/physx"]
path = libs/physx path = libs/physx
url = https://git.barink.dev/Nigel/PhysX.git url = https://git.barink.dev/Nigel/PhysX.git

View File

@ -1,6 +0,0 @@
{
"cmake.configureOnOpen": true,
"files.associations": {
"iosfwd": "cpp"
}
}

View File

@ -1,7 +1,8 @@
#pragma once #pragma once
#define TINYGLTF_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION #define STB_IMAGE_WRITE_IMPLEMENTATION
#define TINYGLTF_IMPLEMENTATION
#define TINYGLTF_NO_EXTERNAL_IMAGE #define TINYGLTF_NO_EXTERNAL_IMAGE
#include "Graphics/Mesh.h" #include "Graphics/Mesh.h"
@ -9,15 +10,25 @@
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/postprocess.h> #include <assimp/postprocess.h>
#include <string> #include <string>
#include "Scene/SceneNodeTypes.h"
class ModelImporter { void ProcessVertices(aiMesh* mesh, std::vector<BarinkEngine::Vertex>& out_vertices);
void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices);
public: namespace BarinkEngine {
static std::vector<BarinkEngine::Mesh> Import(std::string path); class ModelImporter {
public:
private:
static BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene);
static std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene);
}; SceneObject* Import(const std::string path);
private:
static BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene);
static std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene);
};
}

View File

@ -13,14 +13,9 @@
#include "Graphics/Renderer.h" #include "Graphics/Renderer.h"
#include "Graphics/GUI/GUIManager.h" #include "Graphics/GUI/GUIManager.h"
#include "Scene.h" #include "Scene.h"
#include "PerfCounter.h" #include "PerfCounter.h"
extern void Start(); extern void Start();
extern void Update(); extern void Update();
extern void ImmediateGraphicsDraw(); extern void ImmediateGraphicsDraw();
extern void Stop(); extern void Stop();
extern BarinkEngine::InputManager InputSystem;

View File

@ -0,0 +1,7 @@
#pragma once
namespace BECS {
struct Component {
};
}

View File

@ -0,0 +1,13 @@
#pragma once
#include <vector>
#include "Component.h"
namespace BECS {
typedef unsigned long int Entity;
}

View File

@ -0,0 +1,7 @@
#pragma once
namespace BECS {
struct System {
};
}

View File

@ -0,0 +1,17 @@
#pragma once
#include "System.h"
#include <vector>
#include "Component.h"
#include "Entity.h"
namespace BECS {
struct World {
private:
std::vector<System> systems;
std::vector<Component> components;
std::vector<Entity> entities;
};
}

View File

@ -5,5 +5,7 @@ struct Event
{ {
public: public:
std::string name; std::string name;
int argc;
void** argv;
}; };

View File

@ -6,12 +6,10 @@ class EventEmitter {
public: public:
void Subscribe (EventListener& subscriber); void Subscribe (EventListener& subscriber);
void Unsubscribe(EventListener& subscriber); void Unsubscribe(EventListener& subscriber);
void EmitEvent(Event& incident);
protected: protected:
std::list<EventListener*> subscribers; std::list<EventListener*> subscribers;
void EmitEvent(Event& incident);
EventEmitter(); EventEmitter();

View File

@ -1,5 +0,0 @@
#include "EventListener.h"
void EventListener::ReceiveEvent(Event& incident)
{
}

View File

@ -1,8 +1,12 @@
#pragma once #pragma once
#include "Event.h"
#include <list> #include <list>
#include <iostream>
#include "spdlog/spdlog.h"
#include "Event.h"
class EventListener{ class EventListener{
public: public:
virtual void ReceiveEvent(Event& incident); virtual void ReceiveEvent(Event& incident) = 0 ;
}; };

View File

@ -1,18 +0,0 @@
#pragma once
#include "Event.h"
struct KEY_DOWN_EVENT : public Event {
public:
int scancode;
int keycode;
int mods;
};
struct KEY_UP_EVENT : public Event {
public:
int scancode;
int keycode;
int mods;
};

View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <glad/glad.h> #include <glad/glad.h>
class Buffer { class GpuBuffer {
private: private:
unsigned int id; unsigned int id;
public: public:

View File

@ -1,10 +1,11 @@
#pragma once #pragma once
#include <vector> #include <vector>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include "VertexArray.h"
#include "Buffer.h"
namespace BarinkEngine{ namespace BarinkEngine{
struct Vertex { struct Vertex {
glm::vec3 vertices; glm::vec3 vertices;
glm::vec2 uv; glm::vec2 uv;
@ -13,8 +14,13 @@ namespace BarinkEngine{
class Mesh { class Mesh {
public: public:
std::vector<Vertex> vertices; std::vector<Vertex> vertices;
std::vector<unsigned int > elements; std::vector<unsigned int> elements;
private:
GpuBuffer vertexBuffer;
GpuBuffer elementBuffer;
VertexArray VAO;
unsigned int UV_id;
}; };
} }

View File

@ -20,8 +20,8 @@ private:
std::vector<unsigned int > indices; std::vector<unsigned int > indices;
Buffer vertexBuffer; GpuBuffer vertexBuffer;
Buffer elementBuffer; GpuBuffer elementBuffer;
VertexArray VAO; VertexArray VAO;

View File

@ -1,37 +1,23 @@
#pragma once #pragma once
#include <vector> #include <vector>
#include "Mesh.h" #include "Mesh.h"
#include "Buffer.h"
#include "Material.h" #include "Material.h"
#include "Texture.h" #include "Texture.h"
#include "VertexArray.h"
#include "Scene.h" #include "Scene.h"
namespace BarinkEngine {
class Renderable : public SceneNode { class Renderable {
public: public:
/* Mesh mesh;
* NOTE: Should combine into a Mesh!! Material* material;
*/ Texture* texture;
Buffer vertexBuffer;
Buffer elementBuffer;
//Buffer uv;
VertexArray VAO;
Shader* shader;
GLuint UV_id; Renderable();
Material* material; ~Renderable();
Texture* texture; };
}
Shader* shader;
~Renderable();
static Renderable* Load(std::string& path);
void Draw();
private:
std::vector<BarinkEngine::Mesh> meshes;
Renderable(std::string& path);
};

View File

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

View File

@ -2,12 +2,15 @@
#define GLFW_STATIC #define GLFW_STATIC
#include <glad/glad.h> #include <glad/glad.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#include "../Include/EventSystem/EventListener.h" #include <spdlog/spdlog.h>
#include "EventSystem/Event.h"
#include "EventSystem/EventListener.h"
class BarinkWindow : EventListener { class BarinkWindow : EventListener {
private: private:
@ -18,16 +21,13 @@ class BarinkWindow : EventListener {
static bool InitGLFW(); static bool InitGLFW();
public: public:
BarinkWindow(const int width, const int height); BarinkWindow(const int width, const int height);
~BarinkWindow(); ~BarinkWindow();
GLFWwindow* windowptr(); GLFWwindow* windowptr();
void ReceiveEvent(Event& incident) override; void ReceiveEvent(Event& incident) override ;
bool WindowShouldClose(); bool WindowShouldClose();
void Poll(); void Poll();

View File

@ -1,14 +0,0 @@
#pragma once
#include "GLFW/glfw3.h"
namespace BarinkEngine {
namespace Input {
void BE_GLFW_KEYS(GLFWwindow* window, int key, int scancode, int action, int mods);
void BE_GLFW_CURSOR_POSITION(GLFWwindow* window, double x, double y);
void BE_GLFW_CURSOR_ENTER(GLFWwindow* window, int entered);
void BE_GLFW_MOUSE_BUTTON(GLFWwindow* window, int button, int action, int mods);
void BE_GLFW_SCROLL(GLFWwindow* window, double xoffset, double yoffset);
}
}

View File

@ -1,29 +1,31 @@
#pragma once #pragma once
#include <list> #include <vector>
#include <iostream>
#include "Graphics/Window.h" #include "spdlog/spdlog.h"
#include "EventSystem/EventEmitter.h" #include "EventSystem/EventEmitter.h"
#include "../Include/Input/GLFWInput.h" #include "EventSystem/EventListener.h"
#include "BarinkEngine.h" #include "Graphics/Window.h"
namespace BarinkEngine { namespace BarinkEngine {
class InputManager : public EventEmitter { class InputManager : EventEmitter {
public: public:
InputManager(); InputManager();
void PollEvents(); void PollEvents();
void attach(BarinkWindow* window); void attach(BarinkWindow* window);
void detach(BarinkWindow* window);
// GLFW Handlers
void setupGLFWInput(GLFWwindow* window); static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
static void CursorPositionCallback(GLFWwindow* window, double x, double y);
static void CursorEnterCallback(GLFWwindow* window, int entered);
static void MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
static void ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
private: private:
std::list<BarinkWindow*> windows; std::vector<BarinkWindow*> windows;
}; };
} }
extern BarinkEngine::InputManager InputSystem;

View File

@ -3,13 +3,13 @@
#include <imgui.h> #include <imgui.h>
struct EngineStatistics { struct EngineStatistics {
uint32_t lastSampleTime; long long lastSampleTime;
float frameTime; float frameTime;
uint32_t verts; uint32_t verts;
uint32_t DC; uint32_t DC;
uint64_t frames; long long frames;
uint64_t FPS; long long FPS;
}; };
extern EngineStatistics* ES; extern EngineStatistics* ES;
@ -18,15 +18,15 @@ inline void PerfomanceSamplerInit(){
ES->frames = 0; ES->frames = 0;
ES->lastSampleTime = 0; ES->lastSampleTime = 0;
ES->lastSampleTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); ES->lastSampleTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
} }
inline void SamplePerformance(void) { inline void SamplePerformance(void) {
ES->frames++; ES->frames++;
ES->DC = 0; ES->DC = 0;
ES->verts = 0; ES->verts = 0;
unsigned int now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); unsigned long long now = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
unsigned int MilliSecondsPast = now - ES->lastSampleTime; unsigned long long MilliSecondsPast = now - ES->lastSampleTime;
if (MilliSecondsPast >= 1000) { if (MilliSecondsPast >= 1000) {
ES->frameTime = (float)1000 / ES->frames; ES->frameTime = (float)1000 / ES->frames;

View File

@ -2,46 +2,22 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "glm/glm.hpp" #include "Graphics/Transform.h"
#include "Scene/Node.h"
/* /*
* Scene should be a description of a game world * Scene should be a description of a game world
*/ */
struct Transform {
glm::vec3 Position;
glm::vec3 Rotation;
glm::vec3 Scale;
glm::mat4 ModelMatrix;
};
class SceneNode {
public:
std::string name;
Transform transform;
SceneNode* parent;
std::vector<SceneNode*> children;
void addChild(SceneNode& node);
};
class Scene { class Scene {
public: public:
SceneNode& GetSceneNode(std::string); Node& GetSceneNode(std::string);
SceneNode& GetRoot(); Node& GetRoot();
Scene(std::string SceneName = "Default Scene"); Scene(const std::string& sceneName = "Default Scene");
~Scene(); ~Scene();
private: private:
SceneNode* root; Node* root;
}; };

View File

@ -0,0 +1,24 @@
#pragma once
#include <string>
#include <vector>
#include "Graphics/Transform.h"
class Node {
public:
Node(const std::string& name);
std::string name;
Node* parent;
std::vector<Node*> children;
void addChild(Node& node);
};
class Group : public Node {
public:
Group(const std::string& name);
Transform& transform;
};

View File

@ -0,0 +1,15 @@
#pragma once
#include "Graphics/Renderable.h"
#include "Scene/SceneNodeTypes.h"
#include <glm/glm.hpp>
#include "../../src/Scene/SceneNodeTypes.cpp"
/*
* Define a helper class to more easily build a proper scene
*/
static class SceneBuilder {
static Group* AddGroup(std::string name);
static BarinkEngine::SceneObject* AddVisual(std::string name, BarinkEngine::Renderable& object, glm::vec3 position );
};

View File

@ -0,0 +1,17 @@
#pragma once
#include <string>
#include <map>
#include "Scene.h"
class SceneManager {
public:
static Scene* CreateScene(const std::string& name );
static Scene& GetScene(const std::string& name);
static void LoadScene(Scene& scene);
private:
static Scene* CurrentScene;
static std::map<std::string, Scene*> Scenes;
};

View File

@ -0,0 +1,22 @@
#pragma once
#include "Graphics/Camera.h"
#include "Graphics/Renderable.h"
#include "Scene/Node.h"
namespace BarinkEngine {
class SceneCamera : public Group
{
public:
Camera& camera;
SceneCamera();
};
class SceneObject : public Group
{
public:
SceneObject(std::string name, Renderable* visual);
~SceneObject();
Renderable* renderable;
};
}

View File

@ -1,104 +0,0 @@
#include "BarinkEngine.h"
#include "../Include/Input/GLFWInput.h"
#include "../Include/EventSystem/InputSystemEvents.h"
#include "../Include/Input/InputManager.h"
namespace BarinkEngine {
namespace Input {
void BE_GLFW_KEYS(GLFWwindow* window, int key, int scancode, int action, int mods)
{
switch (action)
{
case GLFW_KEY_DOWN: {
KEY_DOWN_EVENT keydown{};
keydown.name = "KEY::DOWN";
keydown.mods = mods;
keydown.scancode = scancode;
keydown.keycode = key;
InputSystem.EmitEvent(keydown);
break;
}
case GLFW_KEY_UP: {
KEY_UP_EVENT keyup{};
keyup.name = "KEY::DOWN";
keyup.mods = mods;
keyup.scancode = scancode;
keyup.keycode = key;
InputSystem.EmitEvent(keyup);
break;
}
default:
Event KeyEvent{};
KeyEvent.name = "KEY";
InputSystem.EmitEvent(KeyEvent);
break;
}
}
void BE_GLFW_CURSOR_POSITION(GLFWwindow* window, double x, double y)
{
Event CursorPosUpdate{};
CursorPosUpdate.name = "UPDATE::CURSOR:POSITION";
InputSystem.EmitEvent(CursorPosUpdate);
}
void BE_GLFW_CURSOR_ENTER(GLFWwindow* window, int entered)
{
if (entered) {
Event mouseEntered{};
mouseEntered.name = "Mouse Entered Window's confines!";
InputSystem.EmitEvent(mouseEntered);
}
else {
Event mouseLeft{};
mouseLeft.name = "Mouse Left Window's confines!";
InputSystem.EmitEvent(mouseLeft);
}
}
void BE_GLFW_MOUSE_BUTTON(GLFWwindow* window, int button, int action, int mods)
{
Event MouseButtonEvent{};
MouseButtonEvent.name = "MOUSEBUTTON";
InputSystem.EmitEvent(MouseButtonEvent);
}
void BE_GLFW_SCROLL(GLFWwindow* window, double xoffset, double yoffset)
{
Event ScrollEvent{};
ScrollEvent.name = "SCROLL";
InputSystem.EmitEvent(ScrollEvent);
}
}
}

View File

@ -1,44 +0,0 @@
#include "Input/InputManager.h"
namespace BarinkEngine {
void InputManager::PollEvents()
{
for (auto it = windows.begin(); it != windows.end(); ++it) {
(*it)->Poll();
}
}
void InputManager::setupGLFWInput(GLFWwindow* window) {
// Attach callbacks
glfwSetKeyCallback(window, BarinkEngine::Input::BE_GLFW_KEYS);
glfwSetCursorPosCallback(window, BarinkEngine::Input::BE_GLFW_CURSOR_POSITION);
glfwSetCursorEnterCallback(window, BarinkEngine::Input::BE_GLFW_CURSOR_ENTER);
glfwSetMouseButtonCallback(window, BarinkEngine::Input::BE_GLFW_MOUSE_BUTTON);
glfwSetScrollCallback(window, BarinkEngine::Input::BE_GLFW_SCROLL);
}
void InputManager::attach(BarinkWindow* window)
{
windows.push_back(window);
this->Subscribe((EventListener&)(*window));
}
void InputManager::detach(BarinkWindow* window)
{
windows.remove(window);
this->Unsubscribe((EventListener&)*window);
}
InputManager::InputManager() : EventEmitter()
{
windows = std::list<BarinkWindow*>();
}
}

View File

@ -1,52 +0,0 @@
#include "Scene.h"
SceneNode* SearchInChildren(SceneNode* root, std::string name ) {
if (root->name == name)
return root;
SceneNode* found = nullptr;
for (auto child : root->children) {
found = SearchInChildren(child, name);
}
return found;
}
SceneNode& Scene::GetSceneNode(std::string name)
{
return *SearchInChildren(root, name);
}
SceneNode& Scene::GetRoot()
{
return *root;
}
Scene::Scene(std::string sceneName)
{
// Create a root node
root = new SceneNode();
root->name = sceneName;
root->transform = Transform();
root->transform.Position = glm::vec3(0);
root->transform.Rotation = glm::vec3(0);
root->transform.Scale = glm::vec3(0);
root->transform.ModelMatrix = glm::mat4(0);
}
Scene::~Scene()
{
// Destruct scene!
}
void SceneNode::addChild(SceneNode& node)
{
children.push_back(&node);
}

View File

@ -1,62 +0,0 @@
#include "Graphics/Renderable.h"
#include "AssetManager/ModelImporter.h"
#include "PerfCounter.h"
Renderable* Renderable::Load(std::string& path)
{
return new Renderable(path);
}
Renderable::Renderable(std::string& path)
{
meshes = ModelImporter::Import(path);
transform.Scale = glm::vec3(1.0f);
transform.Rotation = glm::vec3(0.0f, 0.0f, 0.0f);
transform.Position = glm::vec3(0.0f, 0.0f, 0.0f);
VAO.Create();
VAO.Bind();
vertexBuffer.createBuffer();
vertexBuffer.Bind(false);
vertexBuffer.setBufferData(&meshes[0].vertices[0], meshes[0].vertices.size() * sizeof(BarinkEngine::Vertex), false);
elementBuffer.createBuffer();
elementBuffer.Bind(true);
elementBuffer.setBufferData(&meshes[0].elements[0], meshes[0].elements.size() * sizeof(unsigned int), true);
VAO.AttachAttribute(0, 3, sizeof(BarinkEngine::Vertex));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(BarinkEngine::Vertex),(void* )offsetof(BarinkEngine::Vertex, vertices));
glEnableVertexAttribArray(1);
vertexBuffer.Unbind(false);
VAO.Unbind();
}
Renderable::~Renderable()
{
glDeleteBuffers(1, &UV_id);
}
void Renderable::Draw()
{
VAO.Bind();
elementBuffer.Bind(true);
glActiveTexture(GL_TEXTURE0);
glUniform1i(glGetUniformLocation(shader->id, "Texture"), GL_TEXTURE0);
texture->Bind();
ES->verts = meshes[0].vertices.size();
ES->DC++;
glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(meshes[0].elements.size()), GL_UNSIGNED_INT, NULL);
VAO.Unbind();
}

View File

@ -52,10 +52,10 @@ project "BarinkEngine"
files { files {
"../libs/glad/src/glad.c", "../libs/glad/src/glad.c",
"./*.cpp", "./src/*.cpp",
"./*.h", "./Include/*.h",
"./**/*.cpp", "./src/**/*.cpp",
"./**/*.h" "./Include/**/*.h"
} }
@ -63,10 +63,10 @@ project "BarinkEngine"
filter { "system:windows"} filter { "system:windows"}
prebuildcommands { prebuildcommands {
-- Copy shaders -- Copy shaders
"copy graphics\\shaders\\fragment.shader ..\\build\\SandboxApplication\\Debug\\test.fs", "copy src\\graphics\\shaders\\fragment.shader ..\\build\\SandboxApplication\\Debug\\test.fs",
"copy graphics\\shaders\\vertex.shader ..\\build\\SandboxApplication\\Debug\\test.vs", "copy src\\graphics\\shaders\\vertex.shader ..\\build\\SandboxApplication\\Debug\\test.vs",
"copy graphics\\shaders\\RenderSurfaceFrag.shader ..\\build\\SandboxApplication\\Debug\\RenderSurface.fs", "copy src\\graphics\\shaders\\RenderSurfaceFrag.shader ..\\build\\SandboxApplication\\Debug\\RenderSurface.fs",
"copy graphics\\shaders\\RenderSurfaceVert.shader ..\\build\\SandboxApplication\\Debug\\RenderSurface.vs" "copy src\\graphics\\shaders\\RenderSurfaceVert.shader ..\\build\\SandboxApplication\\Debug\\RenderSurface.vs"
} }
@ -74,10 +74,10 @@ project "BarinkEngine"
filter { "system:linux" } filter { "system:linux" }
prebuildcommands { prebuildcommands {
-- Copy shaders -- Copy shaders
"cp graphics/shaders/fragment.shader ../build/SandboxApplication/Debug/test.fs", "cp src/graphics/shaders/fragment.shader ../build/SandboxApplication/Debug/test.fs",
"cp graphics/shaders/vertex.shader ../build/SandboxApplication/Debug/test.vs", "cp src/graphics/shaders/vertex.shader ../build/SandboxApplication/Debug/test.vs",
"cp graphics/shaders/RenderSurfaceFrag.shader ../build/SandboxApplication/Debug/RenderSurface.fs", "cp src/graphics/shaders/RenderSurfaceFrag.shader ../build/SandboxApplication/Debug/RenderSurface.fs",
"cp graphics/shaders/RenderSurfaceVert.shader ../build/SandboxApplication/Debug/RenderSurface.vs" "cp src/graphics/shaders/RenderSurfaceVert.shader ../build/SandboxApplication/Debug/RenderSurface.vs"
} }
include('../ImGui') include('../ImGui')

View File

@ -1,82 +1,62 @@
#include "BarinkEngine.h" #include "BarinkEngine.h"
EngineStatistics* ES; EngineStatistics* ES;
BarinkEngine::InputManager InputSystem;
int main(int argc, char* argv[]) {
int main(int argc, char* argv[]) { // Setup performance sampler
// Setup performance sampler PerfomanceSamplerInit();
PerfomanceSamplerInit();
// Startup services
// Create the window BarinkWindow MainWindow = BarinkWindow(800, 600);
BarinkWindow MainWindow = BarinkWindow(800, 600);
BarinkEngine::Renderer renderer = BarinkEngine::Renderer();
// ================================================= InputSystem = BarinkEngine::InputManager();
// Startup services
// ================================================= InputSystem.attach(&MainWindow);
// Startup Renderer GUIManager GUISystem = GUIManager(&MainWindow);
BarinkEngine::Renderer renderer = BarinkEngine::Renderer();
glEnable(GL_DEPTH_TEST);
// Startup InputManager
InputSystem = BarinkEngine::InputManager();
InputSystem.attach(&MainWindow); // First call to setup game
InputSystem.setupGLFWInput(MainWindow.windowptr()); Start();
// Startup GUI System // Runtime loop
GUIManager GUISystem = GUIManager(&MainWindow); while (!MainWindow.WindowShouldClose()) {
SamplePerformance();
// Enable depth testing // Execute main logic
// NOTE: TODO Move this into the renderer InputSystem.PollEvents();
glEnable(GL_DEPTH_TEST);
Update();
renderer.Render();
// First call to setup game
Start(); ImmediateGraphicsDraw();
GUISystem.Render();
// Runtime loop
while (!MainWindow.WindowShouldClose()) {
MainWindow.SwapBuffers();
SamplePerformance(); }
// Execute main logic // Shutdown game
InputSystem.PollEvents(); Stop();
Update();
// Shutdown Services
renderer.Render(); delete ES;
ImmediateGraphicsDraw(); return 0;
}
GUISystem.Render();
MainWindow.SwapBuffers();
}
// Shutdown game
Stop();
// Shutdown Services
delete ES;
InputSystem.detach(&MainWindow);
return 0;
}

View File

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

View File

@ -1,10 +1,10 @@
#include "../Include/Graphics/Material.h" #include "../Include/Graphics/Material.h"
Material::Material(const Shader& shader) : Material::Material(const Shader& shader) :
shader(shader) { shader(shader) {
} }
void Material::Apply() { void Material::Apply() {
shader.setUniformVec3("Color", Color); shader.setUniformVec3("Color", Color);
} }

View File

@ -1,80 +1,95 @@
#include "AssetManager/ModelImporter.h" #include "AssetManager/ModelImporter.h"
std::vector<BarinkEngine::Mesh> ModelImporter::Import(std::string path) BarinkEngine::SceneObject* BarinkEngine::ModelImporter::Import(const std::string path)
{ {
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(path.c_str(), aiProcess_Triangulate | aiProcess_FlipUVs); SceneObject* root = new SceneObject(std::string(path), nullptr);
aiNode* currentNode = scene->mRootNode;
Assimp::Importer importer;
return processNode(currentNode, scene); const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
}
aiNode* currentNode = scene->mRootNode;
std::vector<BarinkEngine::Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene) {
std::vector<BarinkEngine::Mesh> meshes; std::vector<BarinkEngine::Mesh> meshes = processNode(currentNode, scene);
for (unsigned int i = 0; i < node->mNumMeshes; i++) {
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
meshes.push_back(processMesh(mesh, scene)); return root;
}
}
for (unsigned int i = 0; i < node->mNumChildren; i++) {
auto m2 = processNode(node->mChildren[i], scene); std::vector<BarinkEngine::Mesh> BarinkEngine::ModelImporter::processNode(aiNode* node, const aiScene* scene)
{
for(auto m : m2) {
meshes.push_back(m); std::vector<BarinkEngine::Mesh> meshes;
}
} for (unsigned int i = 0; i < node->mNumMeshes; i++) {
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
return meshes; meshes.push_back(processMesh(mesh, scene));
} }
BarinkEngine::Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) { for (unsigned int i = 0; i < node->mNumChildren; i++) {
std::vector<unsigned int> indices; auto m2 = processNode(node->mChildren[i], scene);
std::vector<BarinkEngine::Vertex> vertices;
for(auto m : m2) {
// Process vertices meshes.push_back(m);
for (unsigned int i = 0; i < mesh->mNumVertices; i++) { }
BarinkEngine::Vertex v{}; }
glm::vec3 vector;
vector.x = mesh->mVertices[i].x; return meshes;
vector.y = mesh->mVertices[i].y; }
vector.z = mesh->mVertices[i].z;
BarinkEngine::Mesh BarinkEngine::ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) {
v.vertices = vector; std::vector<unsigned int> indices;
std::vector<BarinkEngine::Vertex> vertices;
if (mesh->mTextureCoords[0]) {
ProcessVertices(mesh, vertices);
glm::vec2 texCoord;
ProcessIndices(mesh, indices);
texCoord.x = mesh->mTextureCoords[0][i].x;
texCoord.y = mesh->mTextureCoords[0][i].y; BarinkEngine::Mesh result;
result.vertices = vertices;
v.uv = texCoord; result.elements = indices;
}
return result;
vertices.push_back(v);
} }
// Process Indices void ProcessVertices(aiMesh* mesh, std::vector<BarinkEngine::Vertex>& out_vertices) {
for (unsigned int i = 0; i < mesh->mNumFaces; i++) { // Process vertices
aiFace face = mesh->mFaces[i]; for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
if (face.mNumIndices < 3) BarinkEngine::Vertex v{};
continue; glm::vec3 vector;
for (unsigned int j = 0; j < face.mNumIndices; j++) { vector.x = mesh->mVertices[i].x;
indices.push_back(face.mIndices[j]); vector.y = mesh->mVertices[i].y;
} vector.z = mesh->mVertices[i].z;
}
v.vertices = vector;
if (mesh->mTextureCoords[0]) {
BarinkEngine::Mesh result;
glm::vec2 texCoord;
result.vertices = vertices; texCoord.x = mesh->mTextureCoords[0][i].x;
result.elements = indices; texCoord.y = mesh->mTextureCoords[0][i].y;
v.uv = texCoord;
return result;
}
out_vertices.push_back(v);
}
}
void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices) {
// 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++) {
out_indices.push_back(face.mIndices[j]);
}
}
} }

View File

@ -0,0 +1,53 @@
#include "Graphics/Renderable.h"
#include "AssetManager/ModelImporter.h"
#include "PerfCounter.h"
BarinkEngine::Renderable::Renderable()
{
/*
VAO.Create();
VAO.Bind();
vertexBuffer.createBuffer();
vertexBuffer.Bind(false);
vertexBuffer.setBufferData(&meshes[0].vertices[0], meshes[0].vertices.size() * sizeof(BarinkEngine::Vertex), false);
elementBuffer.createBuffer();
elementBuffer.Bind(true);
elementBuffer.setBufferData(&meshes[0].elements[0], meshes[0].elements.size() * sizeof(unsigned int), true);
VAO.AttachAttribute(0, 3, sizeof(BarinkEngine::Vertex));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(BarinkEngine::Vertex),(void* )offsetof(BarinkEngine::Vertex, vertices));
glEnableVertexAttribArray(1);
//vertexBuffer.Unbind(false);
VAO.Unbind();
*/
}
BarinkEngine::Renderable::~Renderable()
{
// glDeleteBuffers(1, &UV_id);
}
// Draw call Example !!
/*
VAO.Bind();
elementBuffer.Bind(true);
glActiveTexture(GL_TEXTURE0);
glUniform1i(glGetUniformLocation(shader->id, "Texture"), GL_TEXTURE0);
texture->Bind();
ES->verts = meshes[0].vertices.size();
ES->DC++;
glDrawElements(GL_TRIANGLES, static_cast<unsigned int>(meshes[0].elements.size()), GL_UNSIGNED_INT, NULL);
VAO.Unbind();
*/

View File

@ -1,25 +1,25 @@
#include "Graphics/Renderer.h" #include "Graphics/Renderer.h"
BarinkEngine::Renderer::Renderer() BarinkEngine::Renderer::Renderer()
{ {
models = std::vector<Renderable*>(); models = std::vector<Renderable*>();
} }
BarinkEngine::Renderer::~Renderer() BarinkEngine::Renderer::~Renderer()
{ {
// CleanUp! // CleanUp!
} }
void BarinkEngine::Renderer::Render() void BarinkEngine::Renderer::Render()
{ {
for (auto model : models) { for (auto model : models) {
model->Draw(); //model->Draw();
} }
} }
void BarinkEngine::Renderer::Submit(Renderable* model) void BarinkEngine::Renderer::Submit(Renderable* model)
{ {
models.push_back(model); models.push_back(model);
} }

View File

@ -1,40 +1,40 @@
#include "../Include/Graphics/Texture.h" #include "../Include/Graphics/Texture.h"
#include <glad/glad.h> #include <glad/glad.h>
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
#include "Graphics/stb_image.h" #include "Graphics/stb_image.h"
#include <iostream> #include <iostream>
Texture::Texture(const std::string texturePath) { Texture::Texture(const std::string texturePath) {
int width, height, channels; int width, height, channels;
unsigned char* data = stbi_load(texturePath.c_str(), &width, &height, &channels, 0); unsigned char* data = stbi_load(texturePath.c_str(), &width, &height, &channels, 0);
std::cout << channels << std::endl; std::cout << channels << std::endl;
if (data) { if (data) {
glGenTextures(1, &Id); glGenTextures(1, &Id);
glBindTexture(GL_TEXTURE_2D, Id); glBindTexture(GL_TEXTURE_2D, Id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D); glGenerateMipmap(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} }
else { else {
spdlog::error("Failed to load image (%s)", texturePath ); spdlog::error("Failed to load image (%s)", texturePath );
} }
stbi_image_free(data); stbi_image_free(data);
} }
void Texture::Bind() { void Texture::Bind() {
glBindTexture(GL_TEXTURE_2D, Id); glBindTexture(GL_TEXTURE_2D, Id);
} }
void Texture::Unbind() { void Texture::Unbind() {
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
} }

View File

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

View File

@ -1,11 +1,11 @@
#version 440 core #version 440 core
out vec4 FragColor; out vec4 FragColor;
uniform vec3 Color; uniform vec3 Color;
in vec2 TexCoord; in vec2 TexCoord;
uniform sampler2D Texture; uniform sampler2D Texture;
void main(){ void main(){
FragColor = mix ( texture(Texture, TexCoord), vec4(Color, 1.0f), 0.5f); FragColor = mix ( texture(Texture, TexCoord), vec4(Color, 1.0f), 0.5f);
} }

View File

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

View File

@ -0,0 +1,118 @@
#include "Input/InputManager.h"
BarinkEngine::InputManager InputSystem;
void BarinkEngine::InputManager::PollEvents()
{
for (auto it = windows.begin(); it != windows.end(); ++it) {
auto window = *it;
window->Poll();
}
}
void BarinkEngine::InputManager::KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
Event KeyEvent{};
KeyEvent.name = "KEY";
InputSystem.EmitEvent(KeyEvent);
if (key == GLFW_KEY_A && action == GLFW_PRESS)
{
std::cout << "'a' key was pressed" << std::endl;
}
}
void BarinkEngine::InputManager::CursorPositionCallback(GLFWwindow* window, double x, double y)
{
//std::cout << "Cursor Position x: " << x << ", y: " << y << std::endl;
Event CursorPosUpdate{};
CursorPosUpdate.name = "UPDATE::CURSOR:POSITION";
InputSystem.EmitEvent(CursorPosUpdate);
}
void BarinkEngine::InputManager::CursorEnterCallback(GLFWwindow* window, int entered)
{
if (entered) {
Event mouseEntered {};
mouseEntered.name = "Mouse Entered Window's confines!";
mouseEntered.argc = 0;
InputSystem.EmitEvent(mouseEntered);
}
else {
Event mouseLeft{};
mouseLeft.name = "Mouse Left Window's confines!";
mouseLeft.argc = 0;
InputSystem.EmitEvent(mouseLeft);
}
}
void BarinkEngine::InputManager::MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
{
Event MouseButtonEvent{};
MouseButtonEvent.name = "MOUSEBUTTON";
InputSystem.EmitEvent(MouseButtonEvent);
if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
std::cout << "Right mouse button was pressed!" << std::endl;
}
}
void BarinkEngine::InputManager::ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
{
std::cout << "Scroll: x: " << xoffset << ", y: " << yoffset << std::endl;
Event ScrollEvent{};
ScrollEvent.name = "SCROLL";
InputSystem.EmitEvent(ScrollEvent);
}
void BarinkEngine::InputManager::attach(BarinkWindow* window)
{
windows.push_back(window);
// Attach callbacks
glfwSetKeyCallback(window->windowptr(), KeyCallback);
glfwSetCursorPosCallback(window->windowptr(), CursorPositionCallback);
glfwSetCursorEnterCallback(window->windowptr(), CursorEnterCallback);
glfwSetMouseButtonCallback(window->windowptr(), MouseButtonCallback);
glfwSetScrollCallback(window->windowptr(), ScrollCallback);
this->Subscribe( (EventListener&)(*window));
}
BarinkEngine::InputManager::InputManager() : EventEmitter ()
{
windows = std::vector<BarinkWindow*>();
}

View File

@ -0,0 +1,66 @@
#include "Scene.h"
#include "Scene.h"
#include "Scene/Node.h"
void DeleteSubGraph(Node* tree);
Scene::Scene(const std::string& sceneName)
{
// Create a root node
root = new Group(sceneName);
}
Scene::~Scene()
{
// Delete all nodes in the graph.
DeleteSubGraph(root);
}
Node* SearchInChildren(Node* root, const std::string name ) {
if (root->name == name)
return root;
Node* found = nullptr;
for (auto child : root->children) {
found = SearchInChildren(child, name);
}
return found;
}
Node& Scene::GetSceneNode(std::string name)
{
return *SearchInChildren(root, name);
}
Node& Scene::GetRoot()
{
return *root;
}
void Node::addChild(Node& node)
{
children.push_back(&node);
}
void DeleteSubGraph(Node* tree)
{
if (tree->children.size() == 0) {
delete tree;
return;
}
for (auto child : tree->children) {
if (child->children.size() > 0) {
DeleteSubGraph(child);
}
}
}

View File

@ -0,0 +1,7 @@
#include "Scene/Node.h"
Node::Node(const std::string& name)
: name(name), parent(nullptr), children(std::vector<Node*>()) {}
Group::Group(const std::string& name )
: Node(name), transform(Transform()) {}

View File

@ -0,0 +1,22 @@
#include "Scene/SceneManager.h"
Scene* SceneManager::CreateScene(const std::string& name)
{
/*
Scenes = std::map<std::string, Scene*>();
SceneManager::Scenes[name] = new Scene(name);
*/
return new Scene(name);
}
Scene& SceneManager::GetScene(const std::string& name)
{
return Scene();
//return *SceneManager::Scenes[name];
}
void SceneManager::LoadScene( Scene& scene)
{
//SceneManager::CurrentScene = &scene;
}

View File

@ -0,0 +1,12 @@
#include "Scene/SceneNodeTypes.h"
BarinkEngine::SceneCamera::SceneCamera()
: Group(std::string("Camera")), camera(Camera(glm::vec3(0.0f), glm::vec3(0.0f), 0))
{}
BarinkEngine::SceneObject::SceneObject(std::string name, Renderable* visual)
: Group(name), renderable(visual)
{}
BarinkEngine::SceneObject::~SceneObject()
{}

Binary file not shown.

Binary file not shown.

View File

@ -1,5 +1,35 @@
#include "GUI.h" #include "GUI.h"
void SceneExplorer(Scene& scene, std::string PanelName) {
if (ImGui::Begin(PanelName.c_str())) {
ImGui::ListBoxHeader("##ObjectList");
Node& current = scene.GetRoot();
Node* next = &current;
// Show first node
ImGui::Selectable(next->name.c_str(), true);
ImGui::Indent();
if (next->children.size() != 0) {
for (auto child : next->children)
{
std::string& name = child->name;
ImGui::Selectable(name.c_str(), false);
}
}
ImGui::ListBoxFooter();
}
ImGui::End();
}
void CameraTool(Camera* cam) { void CameraTool(Camera* cam) {
ImGui::Begin("Camera"); ImGui::Begin("Camera");

View File

@ -5,4 +5,5 @@
void CameraTool(Camera* camera); void CameraTool(Camera* camera);
void ScriptingTool(char* code); void ScriptingTool(char* code);
void transformWindow(Transform& transform, std::string PanelName); void transformWindow(Transform& transform, std::string PanelName);
void materialWindow(Material& material, std::string PanelName); void materialWindow(Material& material, std::string PanelName);
void SceneExplorer(Scene& scene, std::string PanelName);

View File

@ -1,4 +1,8 @@
#include "BarinkEngine.h" #include "BarinkEngine.h"
#include "Scene\SceneManager.h"
#include "Scene\SceneNodeTypes.h"
#include "AssetManager/ModelImporter.h"
#include "imgui.h" #include "imgui.h"
#include "GUI.h" #include "GUI.h"
#include "Util.h" #include "Util.h"
@ -7,88 +11,52 @@
* Define globals * Define globals
*/ */
Camera* cam; Camera* cam;
Shader* shader; Shader* shader;
Renderable* Cube;
Material* matCube;
Texture* textureCube;
Renderable* Cube2;
Material* matCube2;
char* code = new char[254]; char* code = new char[254];
const std::string vertexShaderSource = "build/SandboxApplication/Debug/test.vs"; const std::string vertexShaderSource = "build/SandboxApplication/Debug/test.vs";
const std::string fragmentShaderSource = "build/SandboxApplication/Debug/test.fs"; const std::string fragmentShaderSource = "build/SandboxApplication/Debug/test.fs";
BarinkEngine::ModelImporter* MI = new BarinkEngine::ModelImporter();
Scene* Level1;
// BarinkEngine::SceneObject* cube;
/* /*
* Runs once at startup * Runs once at startup
* - USe to initialize the game/sandbox/demo * - USe to initialize the game/sandbox/demo
*/ */
void Start() { void Start() {
// Build a basic test scene
// NOTE: This will later be done through an editor
/* // Create a level and load it as the current level
Building a very basic scene graph std::string levelName("Test Level");
*/ Level1 = SceneManager::CreateScene(levelName);
SceneNode MyCube = SceneNode(); SceneManager::LoadScene(*Level1);
MyCube.name = "MyCube";
SceneNode MyBaby = SceneNode(); // Create a cube node
MyBaby.name = "Baby";
// Load a model
//cube = MI->Import("build/SandboxApplication/Debug/Models/Cube.obj");
//Level1->GetRoot().addChild(*cube);
std::string groupName("Nested-Group");
auto testGroup = new Group(groupName);
Level1->GetRoot().addChild( *testGroup);
SceneNode MySecondCube = SceneNode(); std::string group2Name("Nested-Group2");
MySecondCube.name = "MySecondCube"; auto testGroup2 = new Group(group2Name);
Level1->GetRoot().addChild(*testGroup2);
// Walk scene graph
MyCube.addChild(MyBaby); PrintSceneTree(Level1->GetRoot(),0);
Scene scene = Scene("My awesome Game Scene");
scene.GetRoot().addChild(MyCube);
scene.GetRoot().addChild(MySecondCube);
// Walk scene graph
PrintSceneTree(scene.GetRoot(),0);
shader = new Shader(vertexShaderSource, fragmentShaderSource); shader = new Shader(vertexShaderSource, fragmentShaderSource);
textureCube = new Texture("build/SandboxApplication/Debug/Textures/wall.jpg");
matCube = new Material(*shader);
matCube->Color = glm::vec3(1.0, 0.0, 0.0);
matCube2 = new Material(*shader);
matCube2->Color = glm::vec3(0.0, 1.0f, 0.0);
std::string cubePath = "build/SandboxApplication/Debug/Models/Cube.obj";
std::string lanternPath = "build/SandboxApplication/Debug/Models/Latern.gltf";
/*
* load meshes
*/
Cube = Renderable::Load(lanternPath);
Cube2 = Renderable::Load(cubePath);
Cube->addChild(*Cube2);
Cube->shader = shader;
Cube2->shader = shader;
Cube->texture = textureCube;
Cube2->texture = textureCube;
Cube2->transform.Position = glm::vec3(-9.0f, 0.0f, 0.0f);
Cube->transform.Position = glm::vec3(-8.0f, 0.0f, -2.0f);
cam = new Camera(glm::vec3(0.0f, 1.5f, 0.0f), glm::vec3(0.0f, 0.0f, 0.0f), 90.0f); cam = new Camera(glm::vec3(0.0f, 1.5f, 0.0f), glm::vec3(0.0f, 0.0f, 0.0f), 90.0f);
memset(code, '\0', 254); memset(code, '\0', 254);
} }
@ -103,24 +71,14 @@ void ImmediateGraphicsDraw() {
// at possible GUI elements to use // at possible GUI elements to use
ImGui::ShowDemoWindow(); ImGui::ShowDemoWindow();
// Show internal BarinkEngine stats // Show internal BarinkEngine stats
ShowStats(); ShowStats();
// Show different tooling for this specific sandbox // Show different tooling for this specific sandbox
CameraTool(cam); CameraTool(cam);
ScriptingTool(code); ScriptingTool(code);
transformWindow(Cube->transform, "Transform (Cube)"); SceneExplorer(*Level1, "Scene Explorer");
transformWindow(Cube2->transform, "Transform (Cube2)");
materialWindow(*matCube, "Material Cube");
materialWindow(*matCube2, "Material Cube2");
} }
/* /*
@ -129,29 +87,26 @@ void ImmediateGraphicsDraw() {
*/ */
void Update() void Update()
{ {
/* /*
* NOTE: this needs to move to the renderer * NOTE: this needs to move to the renderer
* Render code should not appear in the sandbox file * Render code should not appear in the sandbox file
*/ */
glm::mat4 projection = glm::perspective(glm::radians(cam->Zoom), (800.0f / 600.0f), 0.001f, 100.0f); //glm::mat4 projection = glm::perspective(glm::radians(cam->Zoom), (800.0f / 600.0f), 0.001f, 100.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
shader->Use(); shader->Use();
shader->setUniformMat4("P", projection); //shader->setUniformMat4("P", projection);
shader->setUniformMat4("M", CalculateModelMat(Cube->transform)); //shader->setUniformMat4("M", CalculateModelMat(cube->transform));
shader->setUniformMat4("V", cam->GetViewMatrix()); shader->setUniformMat4("V", cam->GetViewMatrix());
matCube->Apply();
//cube->renderable->material->Apply();
Cube->Draw();
shader->setUniformMat4("M", CalculateModelMat(Cube2->transform)); //Cube->Draw();
matCube2->Apply();
Cube2->Draw();
} }
/* /*
@ -159,18 +114,6 @@ void Update()
* - Meant for cleanup * - Meant for cleanup
*/ */
void Stop() { void Stop() {
// Cleanup delete MI;
Cube->VAO.Delete();
Cube->elementBuffer.Delete();
Cube2->VAO.Delete();
Cube2->elementBuffer.Delete();
delete Cube2;
delete Cube;
delete matCube;
delete matCube2;
delete shader; delete shader;
} }

View File

@ -1,6 +1,6 @@
#include "Util.h" #include "Util.h"
void PrintSceneTree(SceneNode& node, int depth) { void PrintSceneTree(Node& node, int depth) {
// Indent name based on depth // Indent name based on depth
std::cout << " "; std::cout << " ";
for (int i = 0; i < depth; i++) { for (int i = 0; i < depth; i++) {

View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "BarinkEngine.h" #include "BarinkEngine.h"
void PrintSceneTree(SceneNode& node, int depth); void PrintSceneTree(Node& node, int depth);
glm::mat4 CalculateModelMat(Transform& transform); glm::mat4 CalculateModelMat(Transform& transform);