1 Commits

Author SHA1 Message Date
3c30bf7fb7 Base layout for the input manager 2022-06-19 20:01:31 +02:00
153 changed files with 18562 additions and 19839 deletions

1
.gitattributes vendored
View File

@ -1,2 +1 @@
*.png filter=lfs diff=lfs merge=lfs -text *.png filter=lfs diff=lfs merge=lfs -text
*.webp filter=lfs diff=lfs merge=lfs -text

5
.gitignore vendored
View File

@ -1,11 +1,12 @@
**/build/ build/
**/intermediates/ intermediates/
tools/ tools/
*.make *.make
Makefile Makefile
.vscode/ .vscode/
libs/lua libs/lua
libs/glad libs/glad
Debug/
*.sln *.sln
*.vcxproj *.vcxproj
*.vcxproj.filters *.vcxproj.filters

17
.gitmodules vendored
View File

@ -4,10 +4,12 @@
[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"]
path = libs/tinygltf
url = https://github.com/syoyo/tinygltf.git
[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
@ -20,19 +22,6 @@
[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
[submodule "libs/entt"]
path = libs/entt
url = https://github.com/skypjack/entt.git
[submodule "libs/guizmo"]
path = libs/guizmo
url = https://github.com/CedricGuillemet/ImGuizmo.git
[submodule "libs/yaml-cpp"]
path = libs/yaml-cpp
url = https://git.barink.dev/Nigel/yaml-cpp.git
[submodule "libs/nativefiledialog"]
path = libs/nativefiledialog
url = https://git.barink.dev/Nigel/nativefiledialog.git

6
.vscode/settings.json vendored Normal file
View File

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

View File

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

View File

@ -0,0 +1,25 @@
#include "../Include/EventSystem/EventEmitter.h"
void EventEmitter::Subscribe(EventListener& subscriber)
{
subscribers.push_back(&subscriber);
}
void EventEmitter::Unsubscribe(EventListener& subscriber)
{
subscribers.remove(&subscriber);
}
void EventEmitter::EmitEvent(Event& incident)
{
// Notify all subscribers an event has taken place
for (auto it = subscribers.begin(); it != subscribers.end(); ++it)
{
(*it)->ReceiveEvent(incident);
}
}
EventEmitter::EventEmitter() {
subscribers = std::list<EventListener*>{};
}

View File

@ -0,0 +1,23 @@
#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 {
public:
static std::vector<BarinkEngine::Mesh> Import(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

@ -0,0 +1,26 @@
#pragma once
#include "glm/glm.hpp"
#include "graphics/Shader.h"
#include "graphics/Window.h"
#include "graphics/Texture.h"
#include "graphics/Camera.h"
#include "graphics/Renderable.h"
#include "Graphics/Material.h"
#include "spdlog/spdlog.h"
#include "Input/InputManager.h"
#include "Graphics/Renderer.h"
#include "Graphics/GUI/GUIManager.h"
#include "Scene.h"
#include "PerfCounter.h"
extern void Start();
extern void Update();
extern void ImmediateGraphicsDraw();
extern void Stop();
extern BarinkEngine::InputManager InputSystem;

View File

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

View File

@ -0,0 +1,9 @@
#pragma once
#include <string>
struct Event
{
public:
std::string name;
};

View File

@ -0,0 +1,18 @@
#pragma once
#include "Event.h"
#include "EventListener.h"
class EventEmitter {
public:
void Subscribe (EventListener& subscriber);
void Unsubscribe(EventListener& subscriber);
void EmitEvent(Event& incident);
protected:
std::list<EventListener*> subscribers;
EventEmitter();
};

View File

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

View File

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

View File

@ -0,0 +1,18 @@
#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

@ -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();
};

View File

@ -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;
};

View File

@ -0,0 +1,15 @@
#pragma once
#include "Graphics/Window.h"
class GUIManager {
public:
GUIManager(BarinkWindow* window);
~GUIManager();
void Render();
private:
BarinkWindow* currentwindow;
};

View File

@ -0,0 +1,19 @@
#pragma once
#include <glm/glm.hpp>
#include <string>
#include "Shader.h"
class Material {
public:
Material(const Shader& shader);
void Apply();
glm::vec3 Color;
private:
const Shader& shader;
};

View File

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

View File

@ -0,0 +1,30 @@
#pragma once
#include "BarinkEngine.h"
#include <vector>;
class RenderSurface
{
public:
RenderSurface();
~RenderSurface();
void Draw();
private:
// would normally be a material
// however rendersurface is special and
// thus does not contain a material
Shader* shader;
// Basically a mesh
std::vector<glm::vec3> verts;
std::vector<unsigned int > indices;
Buffer vertexBuffer;
Buffer elementBuffer;
VertexArray VAO;
};

View File

@ -0,0 +1,37 @@
#pragma once
#include <vector>
#include "Mesh.h"
#include "Buffer.h"
#include "Material.h"
#include "Texture.h"
#include "VertexArray.h"
#include "Scene.h"
class Renderable : public SceneNode {
public:
/*
* NOTE: Should combine into a Mesh!!
*/
Buffer vertexBuffer;
Buffer elementBuffer;
//Buffer uv;
VertexArray VAO;
GLuint UV_id;
Material* material;
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,21 @@
#pragma once
#include "Graphics/Renderable.h"
#include <vector>
namespace BarinkEngine {
class Renderer {
public:
Renderer();
~Renderer();
void Render();
void Submit(Renderable* model);
private:
std::vector<Renderable*> models;
};
}

View File

@ -1,13 +1,20 @@
#pragma once #pragma once
namespace YoggieEngine { #include <glad/glad.h>
#include <string>
#include <iostream>
#include <fstream>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
class Shader { class Shader {
private: private:
char* readFile (const char* filePath); char* readFile (const char* filePath);
public: public:
Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath); Shader(const std::string vertexShaderPath, const std::string fragmentShaderPath);
void Use() const; void Use();
void setUniformMat4(std::string uniformName, glm::mat4 matrix4)const; void setUniformMat4(std::string uniformName, glm::mat4 matrix4)const;
void setUniformVec4(std::string uniformName, glm::vec4 vector4)const; void setUniformVec4(std::string uniformName, glm::vec4 vector4)const;
void setUniformVec3(std::string uniformName, glm::vec3 vector3)const; void setUniformVec3(std::string uniformName, glm::vec3 vector3)const;
@ -18,4 +25,3 @@ namespace YoggieEngine {
int id; int id;
}; };
}

View File

@ -0,0 +1,18 @@
#pragma once
#include <spdlog/spdlog.h>
#include <string>
class Texture {
public:
Texture(const std::string texturePath);
void Bind();
void Unbind();
private:
unsigned int Id;
};

View File

@ -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);
};

View File

@ -1,12 +1,14 @@
#pragma once #pragma once
#define GLFW_STATIC #define GLFW_STATIC
#include <iostream> #include <glad/glad.h>
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#include "../Include/EventSystem/EventListener.h"
#include "../EventSystem/Event.h"
#include "../EventSystem/EventListener.h"
namespace YoggieEngine {
class BarinkWindow : EventListener { class BarinkWindow : EventListener {
private: private:
GLFWwindow* window; GLFWwindow* window;
@ -16,6 +18,9 @@ namespace YoggieEngine {
static bool InitGLFW(); static bool InitGLFW();
public: public:
BarinkWindow(const int width, const int height); BarinkWindow(const int width, const int height);
~BarinkWindow(); ~BarinkWindow();
@ -30,4 +35,3 @@ namespace YoggieEngine {
}; };
}

View File

@ -0,0 +1,14 @@
#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

@ -0,0 +1,29 @@
#pragma once
#include <list>
#include "Graphics/Window.h"
#include "EventSystem/EventEmitter.h"
#include "../Include/Input/GLFWInput.h"
#include "BarinkEngine.h"
namespace BarinkEngine {
class InputManager : public EventEmitter {
public:
InputManager();
void PollEvents();
void attach(BarinkWindow* window);
void detach(BarinkWindow* window);
void setupGLFWInput(GLFWwindow* window);
private:
std::list<BarinkWindow*> windows;
};
}

View File

@ -0,0 +1,50 @@
#pragma once
#include <chrono>
#include <imgui.h>
struct EngineStatistics {
uint32_t lastSampleTime;
float frameTime;
uint32_t verts;
uint32_t DC;
uint64_t frames;
uint64_t FPS;
};
extern EngineStatistics* ES;
inline void PerfomanceSamplerInit(){
ES = new EngineStatistics();
ES->frames = 0;
ES->lastSampleTime = 0;
ES->lastSampleTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
}
inline void SamplePerformance(void) {
ES->frames++;
ES->DC = 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 int MilliSecondsPast = now - ES->lastSampleTime;
if (MilliSecondsPast >= 1000) {
ES->frameTime = (float)1000 / ES->frames;
ES->FPS = ES->frames;
ES->frames = 0;
ES->lastSampleTime = now;
}
}
inline void ShowStats() {
ImGui::Begin("Statistics", false, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove);
ImGui::Text("FPS: %i", ES->FPS);
ImGui::Text("Frame Time: %f", ES->frameTime);
ImGui::Text("Verts: %i", ES->verts);
ImGui::Text("Draw Calls: %i", ES->DC);
ImGui::End();
}

View File

@ -0,0 +1,47 @@
#pragma once
#include <string>
#include <vector>
#include "glm/glm.hpp"
/*
* 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 {
public:
SceneNode& GetSceneNode(std::string);
SceneNode& GetRoot();
Scene(std::string SceneName = "Default Scene");
~Scene();
private:
SceneNode* root;
};

View File

@ -0,0 +1,28 @@
#pragma once
#include <string>
extern "C"
{
#include "lauxlib.h"
#include "lua.h"
#include "lualib.h"
}
#include "LuaScriptingManager.h"
/*
class LuaScript {
public:
LuaScript(const std::string&);
void execute(lua_State& l);
private:
std::string filePath;
};
*/

View File

@ -0,0 +1,28 @@
#pragma once
#include <vector>
extern "C"
{
#include "lauxlib.h"
#include "lua.h"
#include "lualib.h"
}
#include "LuaScript.h"
/*
class LuaScriptingManager
{
public:
std::vector<LuaScript*> scripts;
LuaScriptingManager();
void ExecuteLuaString(const std::string&);
private:
lua_State* L;
lua_State& getState();
};*/

View File

@ -0,0 +1,104 @@
#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

@ -0,0 +1,44 @@
#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*>();
}
}

52
BarinkEngine/Scene.cpp Normal file
View File

@ -0,0 +1,52 @@
#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

@ -0,0 +1,11 @@
#include "Scripting/LuaScript.h"
/*
LuaScript::LuaScript(const std::string& path)
: filePath(path) {
}
void LuaScript::execute(lua_State& l)
{
luaL_dofile(&l, filePath.c_str());
}
*/

View File

@ -0,0 +1,18 @@
#include "Scripting/LuaScriptingManager.h"
/*
LuaScriptingManager::LuaScriptingManager()
{
L = luaL_newstate();
luaL_openlibs(L);
}
void LuaScriptingManager::ExecuteLuaString(const std::string& code) {
luaL_dostring(L, code.c_str());
}
lua_State& LuaScriptingManager::getState()
{
return (*L);
}
*/

View File

@ -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);
}

View File

@ -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
);
}

View File

@ -0,0 +1,38 @@
#include "Graphics/GUI/GUIManager.h"
#include "imgui.h"
#include "backends/imgui_impl_opengl3.h"
#include <backends/imgui_impl_glfw.cpp>
GUIManager::GUIManager(BarinkWindow* window)
: currentwindow(window)
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
(void)io;
ImGui::StyleColorsDark();
ImGui_ImplGlfw_InitForOpenGL(currentwindow->windowptr(), true);
ImGui_ImplOpenGL3_Init("#version 440");
ImGui_ImplGlfw_NewFrame();
ImGui_ImplOpenGL3_NewFrame();
}
GUIManager::~GUIManager()
{
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
}
void GUIManager::Render()
{
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
}

View File

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

View File

@ -0,0 +1,80 @@
#include "AssetManager/ModelImporter.h"
std::vector<BarinkEngine::Mesh> ModelImporter::Import(std::string path)
{
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(path.c_str(), 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<unsigned int> indices;
std::vector<BarinkEngine::Vertex> vertices;
// Process vertices
for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
BarinkEngine::Vertex v{};
glm::vec3 vector;
vector.x = mesh->mVertices[i].x;
vector.y = mesh->mVertices[i].y;
vector.z = mesh->mVertices[i].z;
v.vertices = vector;
if (mesh->mTextureCoords[0]) {
glm::vec2 texCoord;
texCoord.x = mesh->mTextureCoords[0][i].x;
texCoord.y = mesh->mTextureCoords[0][i].y;
v.uv = texCoord;
}
vertices.push_back(v);
}
// 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;
}

View File

@ -0,0 +1,46 @@
#include "Graphics/RenderSurface.h";
RenderSurface::RenderSurface(){
shader = new Shader("build/SandboxAppliction/Debug/renderSuface.vs", "build/SandboxApplication/Debug/renderSurface.fs");
verts = std::vector<glm::vec3>{
{-0.5f, 0.5f, 0.0f}, // 0
{-0.5f, -0.5f, 0.0f}, // 1
{0.5f, -0.5f, 0.0f}, // 2
{0.5f, 0.5f, 0.0f}, // 3
};
indices = std::vector<unsigned int>{
0,2,1,
0,3,2
};
VAO.Create();
VAO.Bind();
vertexBuffer.createBuffer();
vertexBuffer.Bind(false);
vertexBuffer.setBufferData(&verts[0], verts.size() * sizeof(glm::vec3), false);
elementBuffer.createBuffer();
elementBuffer.Bind(true);
elementBuffer.setBufferData(&indices[0], indices.size() * sizeof(unsigned int), true);
VAO.AttachAttribute(0, 3, 0);
vertexBuffer.Unbind(false);
VAO.Unbind();
}
RenderSurface::~RenderSurface() {
delete shader;
}
void RenderSurface::Draw() {
}

View File

@ -0,0 +1,62 @@
#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

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

View File

@ -0,0 +1,124 @@
#include "Graphics/Shader.h"
#include "spdlog/spdlog.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) const
{
glUniformMatrix4fv(glGetUniformLocation(id, uniformName.c_str()), 1, GL_FALSE, glm::value_ptr(matrix4));
}
void Shader::setUniformVec4(std::string uniformName, glm::vec4 vector4) const
{
glUniform4fv(glGetUniformLocation(id, uniformName.c_str()), 1, glm::value_ptr(vector4));
}
void Shader::setUniformVec3(std::string uniformName, glm::vec3 vector3) const
{
glUniform3fv(glGetUniformLocation(id, uniformName.c_str()), 1, glm::value_ptr(vector3));
}
void Shader::setUniformVec2(std::string uniformName, glm::vec2 vector2) const
{
glUniform2fv(glGetUniformLocation(id, uniformName.c_str()),1, glm::value_ptr(vector2));
}
void Shader::setUniformFloat(std::string uniformName, float value) const
{
glUniform1f(glGetUniformLocation(id, uniformName.c_str()), value);
}
void Shader::setUniformInt(std::string uniformName, int value) const
{
glUniform1i(glGetUniformLocation(id, uniformName.c_str()), value);
}

View File

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

View File

@ -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);
}

View File

@ -7,5 +7,5 @@ uniform sampler2D Texture;
void main(){ void main(){
FragColor = vec4(color , 1.0f); // mix ( texture(Texture, TexCoord), vec4(Color, 1.0f), 1.0f); FragColor = mix ( texture(Texture, TexCoord), vec4(Color, 1.0f), 0.5f);
} }

View File

@ -0,0 +1,87 @@
#include "Graphics/Window.h"
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <GLFW/glfw3.h>
#include <spdlog/spdlog.h>
#include "../Include/EventSystem/Event.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);
}
// Set vsync off !!
glfwSwapInterval(0);
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);
}
void BarinkWindow::ReceiveEvent(Event& incident)
{
std::cout << "EVENT RECEIVED: " << incident.name << std::endl;
}

83
BarinkEngine/premake5.lua Normal file
View File

@ -0,0 +1,83 @@
project "BarinkEngine"
kind "StaticLib"
buildmessage "Building BarinkEngine"
includedirs {
"Include/",
"../libs/lua/include",
"../libs/spdlog/include",
"../libs/glm",
"../libs/GorillaAudio/include",
"../libs/physx/physx/include",
"../libs/steam-audio/include",
"../libs/assimp/include",
"../libs/glad/include",
"../libs/glfw/include",
"../libs/glew/include",
"../libs/glm",
"../libs/ImGui",
}
links {
-- This needs to fall under the filter as the names can differ on different platforms
"phonon",
"lua54",
"spdlog",
"assimp-vc143-mtd",
"glfw3",
"ImGUI_Opengl3",
}
libdirs {
"../libs/steam-audio/lib/windows-x64",
"../libs/lua",
"../libs/spdlog/build/Release",
"../libs/assimp/lib/Debug",
"../libs/glfw/build/src/Debug",
}
files {
"../libs/glad/src/glad.c",
"./*.cpp",
"./*.h",
"./**/*.cpp",
"./**/*.h"
}
filter { "system:windows"}
prebuildcommands {
-- Copy shaders
"copy graphics\\shaders\\fragment.shader ..\\build\\SandboxApplication\\Debug\\test.fs",
"copy graphics\\shaders\\vertex.shader ..\\build\\SandboxApplication\\Debug\\test.vs",
"copy graphics\\shaders\\RenderSurfaceFrag.shader ..\\build\\SandboxApplication\\Debug\\RenderSurface.fs",
"copy graphics\\shaders\\RenderSurfaceVert.shader ..\\build\\SandboxApplication\\Debug\\RenderSurface.vs"
}
filter { "system:linux" }
prebuildcommands {
-- Copy shaders
"cp graphics/shaders/fragment.shader ../build/SandboxApplication/Debug/test.fs",
"cp graphics/shaders/vertex.shader ../build/SandboxApplication/Debug/test.vs",
"cp graphics/shaders/RenderSurfaceFrag.shader ../build/SandboxApplication/Debug/RenderSurface.fs",
"cp graphics/shaders/RenderSurfaceVert.shader ../build/SandboxApplication/Debug/RenderSurface.vs"
}
include('../ImGui')

View File

@ -1,44 +0,0 @@
project "Editor"
kind "ConsoleApp"
buildmessage "Building editor ..."
links{
"YoggieEngine",
"ImGuizmo",
"yaml-cpp",
"nfd.lib"
}
includedirs{
"../YoggieEngine/build/Debug",
-- I'd prefer if didn't need these..
-- We'll figure that out some time later
incfolder["lua"],
incfolder["spdlog"],
incfolder["glm"],
incfolder["assimp"],
incfolder["glad"],
incfolder["glfw"],
incfolder["imgui"],
incfolder["imguizmo"],
incfolder["entt"],
incfolder["yamlcpp"],
incfolder["nativefiledialog"],
}
libdirs {
staticlib["yoggie"],
staticlib["nativefiledialog"]
}
files {
"../libs/glad/src/glad.c",
"./src/**.h",
"./src/**.cpp"
}

View File

@ -1,10 +0,0 @@
#pragma once
struct EditorContext {
std::shared_ptr<Project> CurrentProject;
Scene MainScene;
EditorContext() = default;
EditorContext(EditorContext& other) = default;
~EditorContext() = default;
};

View File

@ -1,66 +0,0 @@
#include "Project.h"
#include <string>
#include <sstream>
#include <fstream>
#include <iostream>
#include <yaml-cpp/yaml.h>
void Project::SaveProject(std::filesystem::path path, Project& project)
{
YAML::Emitter projectYAML;
projectYAML << YAML::BeginMap;
projectYAML << YAML::Key << "Project" << YAML::Value << project.Name;
projectYAML << YAML::Key << "Directory" << YAML::Value << path.parent_path().u8string();
projectYAML << YAML::EndMap;
std::ofstream projectFile;
projectFile.open(path.u8string());
projectFile << projectYAML.c_str();
projectFile.close();
}
void Project::LoadProject(std::filesystem::path path, std::shared_ptr<Project>& project)
{
std::string YAMLProject;
std::stringstream sstream;
std::ifstream projectFile;
projectFile.open(path.u8string());
sstream << projectFile.rdbuf();
YAMLProject = sstream.str();
projectFile.close();
YAML::Node node = YAML::Load(YAMLProject);
// this is probably not perfect but it seems to work for now
project.reset();
project = std::make_shared<Project>(node.as<Project>());
std::cout << "loading..." << project.get()->Name << std::endl;
}
namespace YAML {
template<>
class convert<Project> {
public:
static bool decode(const Node& node , Project& rhs)
{
if (!node.IsMap())
return false;
rhs.setName(node["Project"].as<std::string>());
rhs.setProjectDirectory(node["Directory"].as<std::string>());
return true;
}
};
}

View File

@ -1,22 +0,0 @@
#pragma once
#include <filesystem>
#include <iostream>
class Project {
public:
Project() = default;
Project(const std::string& name): Name(name){}
~Project() { std::cout << "Unloading project..." << Name << std::endl; }
void setName(std::string& name) { Name = name; }
const std::string& GetName()const { return Name; }
void setProjectDirectory(std::string& path) { ProjectDirectory = std::filesystem::path(path); }
const std::filesystem::path GetProjectDirectory() { return ProjectDirectory; }
static void SaveProject(std::filesystem::path path, Project& project);
static void LoadProject(std::filesystem::path path, std::shared_ptr<Project>& project);
private:
std::string Name;
std::filesystem::path ProjectDirectory;
};

View File

@ -1,69 +0,0 @@
#pragma once
#include "../../YoggieEngine/src/AssetManager/ModelImporter.h"
#include "../../YoggieEngine/src/Graphics/Memory/Framebuffer.h"
#include "../../YoggieEngine/src/PerfCounter.h"
#include "../../YoggieEngine/src/Scene/Entity.h"
#include "Project.h"
class EditorRuntime : public ApplicationRuntime {
public:
EditorRuntime() = default;
void Start() override
{
CurrentProject = std::make_shared<Project>("Random");
framebuffer = new Framebuffer();
// Create a level and load it as the current level
auto importer = ModelImporter();
// Create a cube
Model = importer.Import("build/Debug/Models/Cube.obj");
cube = MainScene.AddEntity("cube");
auto& render3DComponent = cube.AddComponent<Render3DComponent>();
render3DComponent.mesh = *(Model->renderable->mesh);
cube.GetComponent<TransformComponent>().Position = glm::vec3(1.0f, 0.0f, 5.0f);
auto cube2 = MainScene.AddEntity("Cube1");
auto& rendercube2 = cube2.AddComponent<Render3DComponent>();
rendercube2.mesh = *(Model->renderable->mesh);
// create an ambient light source
auto AmbientLight = MainScene.AddEntity("AmbientLight");
auto light = AmbientLight.AddComponent<LightComponent>();
light.Color = glm::vec3(1.0f);
light.Strength = 1.0f;
Selected = (entt::entity)-1;
}
void Update() override
{
}
void FixedUpdate() override
{
}
void Stop() override
{
}
private:
std::shared_ptr<Project> CurrentProject = nullptr;
Scene MainScene;
Framebuffer* framebuffer;
SceneObject* Model;
Entity cube;
entt::entity Selected;
friend class Editor;
};

View File

@ -1,139 +0,0 @@
#pragma once
#include <yaml-cpp/yaml.h>
#include <yaml-cpp/node/type.h>
#include <string>
#include <filesystem>
#include <fstream>
#include "../../YoggieEngine/src/Scene/Entity.h"
void WriteFile(std::string& emitter, std::filesystem::path path)
{
std::cout << "Writing Scene file to: " << path.u8string() << std::endl;
std::ofstream sceneFile;
sceneFile.open(path.u8string());
sceneFile << emitter.c_str();
sceneFile.close();
}
YAML::Emitter& operator<< (YAML::Emitter& emitter, glm::vec3& vector) {
emitter << YAML::Flow << YAML::BeginSeq << vector.x << vector.y << vector.x << YAML::EndSeq;
return emitter;
}
std::string Serialize( Scene& scene) {
YAML::Emitter emitter;
emitter << YAML::BeginMap;
emitter << YAML::Key << "Scene" << YAML::Value << "test-Scene";
emitter << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
scene.getReg().each([&scene, &emitter](auto enttNumber) {
Entity entity = Entity(enttNumber, &scene);
emitter << YAML::BeginMap;
emitter << YAML::Key << "Entity" << YAML::Value << entity.GetComponent<IdentifierComponent>().name;
if (entity.HasComponent<IdentifierComponent>()) {
emitter << YAML::Key << "Ident";
emitter << YAML::BeginMap;
emitter << YAML::Value << entity.GetComponent<IdentifierComponent>().name;
emitter << YAML::EndMap;
}
if (entity.HasComponent<TransformComponent>()) {
emitter << YAML::Key << "Transform" << YAML::Value ;
emitter << YAML::BeginMap;
emitter << YAML::Key << "Position";
emitter << YAML::Value << entity.GetComponent<TransformComponent>().Position;
emitter << YAML::Key << "Rotation";
emitter << YAML::Value << entity.GetComponent<TransformComponent>().Rotation;
emitter << YAML::Key << "Scale";
emitter << YAML::Value << entity.GetComponent<TransformComponent>().Scale;
emitter << YAML::EndMap;
}
if (entity.HasComponent<LightComponent>()) {
emitter << YAML::Key << "Light";
emitter << YAML::Value;
emitter << YAML::BeginMap;
emitter << YAML::Key << "strength";
emitter << YAML::Value << entity.GetComponent<LightComponent>().Strength;
emitter << YAML::Key << "Color";
emitter << YAML::Value << entity.GetComponent<LightComponent>().Color;
emitter << YAML::EndMap;
}
emitter << YAML::EndMap;
});
emitter << YAML::EndSeq;
emitter << YAML::EndMap;
return std::string(emitter.c_str());
}
void SaveScene(std::filesystem::path path, Scene& scene) {
std::string YAMLString = Serialize(scene);
WriteFile(YAMLString, path);
}
void LoadScene(std::filesystem::path path, Scene& scene)
{
auto sceneYAML = YAML::LoadFile(path.u8string());
if (!sceneYAML["Scene"]) {
spdlog::error("Not a scene file!");
return;
}
scene.getReg().clear();
std::string SceneName = sceneYAML["Scene"].as<std::string>();
auto entities = sceneYAML["Entities"];
for (const auto& entity : entities) {
std::string entityID = entity["Ident"].as<std::string>();
YoggieEngine::Entity SE = scene.AddEntity(entityID);
if (entity["Transform"])
{
TransformComponent tc = SE.GetComponent<TransformComponent>();
auto positionNode = entity["Transform"]["Position"];
tc.Position = glm::vec3(positionNode[0].as<float>(), positionNode[1].as<float>(), positionNode[2].as<float>());
auto rotationNode = entity["Transform"]["Rotation"];
tc.Rotation = glm::vec3(rotationNode[0].as<float>(), rotationNode[1].as<float>(), rotationNode[2].as<float>());
auto scaleNode = entity["Transform"]["Scale"];
tc.Scale = glm::vec3(scaleNode[0].as<float>(), scaleNode[1].as<float>(), scaleNode[2].as<float>());
}
if (entity["Light"]) {
LightComponent lc = SE.AddComponent<LightComponent>();
lc.Strength = entity["Light"]["strength"].as<float>();
lc.Color = glm::vec3(entity["Light"]["Color"][0].as<float>(), entity["Light"]["Color"][1].as<float>(), entity["Light"]["Color"][2].as<float>());
}
}
}

View File

@ -1,72 +0,0 @@
#pragma once
#include <string>
#include <imgui.h>
#include <nfd.h>
#include <iostream>
#include <functional>
#include "Project.h"
struct DialogSpec {
const std::string& id;
const std::string& Title;
const std::string& confirmText;
DialogSpec() = default;
};
//classes based on RAII
class Dialog {
public:
Dialog( DialogSpec spec, std::function<void(std::string&)> onConfirm)
: path(nullptr), location() {
if (ImGui::BeginPopupModal(spec.id.c_str(), NULL, ImGuiWindowFlags_NoMove))
{
ImGui::Text(spec.Title.c_str());
ImGui::Separator();
ImGui::LabelText("##Directory", "Directory: %s", location.c_str());
if (ImGui::Button("...")) {
nfdresult_t result = NFD_OpenDialog(NULL, NULL, &path);
switch (result) {
case (NFD_OKAY):
location = std::string(path);
break;
case(NFD_CANCEL):
std::cout << "NFD_CANCEL" << std::endl;
case (NFD_ERROR):
std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
break;
};
}
if (ImGui::Button(spec.confirmText.c_str(), ImVec2(120, 0)))
{
onConfirm(location);
ImGui::CloseCurrentPopup();
}
ImGui::SetItemDefaultFocus();
ImGui::SameLine();
if (ImGui::Button("Cancel", ImVec2(120, 0)))
{
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}
~Dialog() {
delete path;
}
protected :
char* path;
std::string location;
};

View File

@ -1,35 +0,0 @@
#include <stdio.h>
#include "EditorConsole.h"
EditorConsole::EditorConsole()
: Items(ImVector<char*>()), AutoScroll(false), ScrollToBottom(false)
{
AddLog("Hello Editor console!");
}
EditorConsole::~EditorConsole() {
}
void EditorConsole::Draw() {
ImGui::SetNextWindowSize(ImVec2(520, 600), ImGuiCond_FirstUseEver);
for (int i = 0; i < Items.Size; i++)
{
const char* item = Items[i];
ImGui::TextUnformatted(item);
}
}
void EditorConsole::AddLog(const char* fmt, ...) {
char buf[1024];
va_list args;
va_start(args, fmt);
vsnprintf(buf, IM_ARRAYSIZE(buf), fmt, args);
buf[IM_ARRAYSIZE(buf) - 1] = 0;
va_end(args);
Items.push_back(strdup(buf));
}

View File

@ -1,18 +0,0 @@
#pragma once
#include <imgui.h>
class EditorConsole
{
public:
EditorConsole();
~EditorConsole();
void Draw();
void AddLog(const char* fmt, ...);
private:
ImVector<char*> Items;
bool AutoScroll;
bool ScrollToBottom;
};

View File

@ -1,175 +0,0 @@
#include "widgets.h"
#include "EditorConsole.h"
#include <iostream>
#include "../../YoggieEngine/src/Scene/Components.h"
#include "../../YoggieEngine/src/Scene/Entity.h"
class Editor;
void ComponentView(const std::string& componentName, voidFunction func)
{
ImGuiWindowFlags_ window_flags = ImGuiWindowFlags_None;
ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 5.0f);
ImGui::BeginChild(componentName.c_str());
func();
ImGui::EndChild();
ImGui::PopStyleVar();
}
void Inspector(entt::entity ent , Scene& scene) {
ImGui::Begin("Inspector");
static char* names[] = { "Script Component", "Camera Component" };
static float Zoom = 90;
static glm::vec3 Position = glm::vec3(0.0f, 0.0f, 0.0f);
static glm::vec3 Rotation = glm::vec3(0.0f, 0.0f, 0.0f);
if (scene.getReg().valid(ent)) {
Entity entity = Entity(ent, &scene);
if (ImGui::Button("Add Component"))
ImGui::OpenPopup("Component picker");
ImGui::SameLine();
if (ImGui::BeginPopup("Component picker")) {
for (int i = 0; i < IM_ARRAYSIZE(names); i++)
if (ImGui::MenuItem(names[i])) {
std::cout << "Add a " << names[i] << " to "
<< entity.GetComponent<IdentifierComponent>().name << std::endl;
}
ImGui::EndPopup();
}
ImGui::NewLine();
auto component = entity.GetComponent<IdentifierComponent>();
char* buf = new char(component.name.size());
strcpy(buf, component.name.c_str());
ImGui::InputText("Name:",buf , sizeof(buf), ImGuiInputTextFlags_ReadOnly);
if (entity.HasComponent<TransformComponent>()) {
auto& transform = entity.GetComponent<TransformComponent>();
if (ImGui::CollapsingHeader("Transform", ImGuiTreeNodeFlags_DefaultOpen)) {
ImGui::DragFloat3("Position", glm::value_ptr(transform.Position), 0.01f);
ImGui::DragFloat3("Rotation", glm::value_ptr(transform.Rotation), 0.01f);
ImGui::DragFloat3("Scale", glm::value_ptr(transform.Scale), 0.01f, 0.0f);
}
}
if (entity.HasComponent<Render3DComponent>()) {
auto& render3d = entity.GetComponent<Render3DComponent>();
if (ImGui::CollapsingHeader("Render3D", ImGuiTreeNodeFlags_DefaultOpen)) {
ImGui::ColorEdit3("Colour", glm::value_ptr(render3d.color));
}
}
if (entity.HasComponent<LightComponent>()) {
auto& light = entity.GetComponent<LightComponent>();
if (ImGui::CollapsingHeader("Light", ImGuiTreeNodeFlags_DefaultOpen)) {
ImGui::DragFloat("Strength", &light.Strength, 0.001f);
ImGui::ColorEdit3("Colour", glm::value_ptr(light.Color));
}
}
if (entity.HasComponent <CameraComponent>()) {
auto& camera = entity.GetComponent<CameraComponent>();
ComponentView("Camera", [] {
ImGui::SliderFloat("Zoom", &Zoom, 10, 190);
ImGui::InputFloat3("Position:", &Position[0]);
ImGui::InputFloat3("Rotation:", &Rotation[0]);
});
}
if (entity.HasComponent<ScriptComponent>()) {
ComponentView("Scripting", [] {
ImGui::LabelText("##--", "Hello scripting");
});
}
}
ImGui::End();
}
void SceneExplorer(entt::entity& selected, Scene& scene )
{
ImGui::Begin("Scene Explorer");
scene.getReg().each([&](entt::entity enttNumber) {
Entity entity = Entity(enttNumber, &scene);
auto id = entity.GetComponent<IdentifierComponent>();
if (ImGui::Selectable(id.name.c_str(), enttNumber == selected )) {
selected = enttNumber;
}
});
ImGui::End();
}
void Viewport(Framebuffer& framebuffer) {
unsigned int viewportWindowFlags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar ;
ImGui::Begin("Viewport", false, viewportWindowFlags);
ImGui::Image((void*)(intptr_t)framebuffer.GetColourAttachment(), ImVec2{ (float)800,(float)600 });
ImGuizmo::SetDrawlist();
ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, ImGui::GetWindowWidth(), ImGui::GetWindowHeight());
ImGuizmo::Enable(true);
auto cam = glm::mat4(1.0f);
auto eye = glm::vec3(0.0f);
auto center = glm::vec3(0.0f);
auto up = glm::vec3(0.0f, 1.0f, 0.0f);
auto view = glm::lookAt(eye, center, up);
glm::mat4 projection = glm::perspective(glm::radians(90.0f), (800.0f / 600.0f), 0.001f, 100.0f);
auto transformMatrix = glm::mat4(1.0f);
ImGuizmo::Manipulate(glm::value_ptr(view), glm::value_ptr(projection), ImGuizmo::TRANSLATE, ImGuizmo::WORLD, glm::value_ptr(transformMatrix));
//ImGuizmo::Manipulate(glm::value_ptr(static_cam), glm::value_ptr(static_projection), ImGuizmo::TRANSLATE, ImGuizmo::WORLD, glm::value_ptr(trans));
ImGuizmo::ViewManipulate(glm::value_ptr(cam), 8.0f, ImVec2{ 0.0f,0.0f }, ImVec2{ 128.0f,128.0f }, 0x10101010);
ImGui::End();
}
void GamePort(Framebuffer& framebuffer)
{
unsigned int viewportWindowFlags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar;
ImGui::Begin("Game", false, viewportWindowFlags);
ImGui::Image((void*)(intptr_t)framebuffer.GetColourAttachment(), ImVec2{ (float)800, (float)600 });
ImGui::End();
}
void Settings() {
ImGui::Begin("Settings");
ImGui::LabelText("##title-settings", "Fine grain control over your engine... ");
ImGui::End();
}
auto console = EditorConsole();
void Console() {
ImGui::Begin("Console", false);
console.Draw();
ImGui::End();
}
void AssetsFinder() {
ImGui::Begin("Asset-Finder", false);
ImGui::Dummy(ImVec2{ 128, 128 });
ImGui::End();
}

View File

@ -1,28 +0,0 @@
#pragma once
#include <glm/glm.hpp>
#include <imgui.h>
#include <string>
#include <entt/entt.hpp>
#include <entt/entity/fwd.hpp>
#include "../../libs/guizmo/ImGuizmo.h"
#include "../../YoggieEngine/src/YoggieEngine.h"
typedef void ( *voidFunction ) (void);
using namespace YoggieEngine;
void ComponentView(const std::string& componentName, voidFunction func);
void Inspector(entt::entity entity, Scene& scene);
void SceneExplorer(entt::entity& selected, Scene& scene);
void Viewport(Framebuffer& framebuffer);
void GamePort(Framebuffer& framebuffer);
void Settings();
void Console();
void AssetsFinder();

View File

@ -1,270 +0,0 @@
#include <imgui.h>
#include <backends/imgui_impl_opengl3.h>
#include <backends/imgui_impl_glfw.h>
#include <ImGuizmo.h>
#include <nfd.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "UI/Widgets.h"
#include "Project.h"
#include "SceneSerializer.h"
#include "EditorContext.h"
#include "SceneRuntime.h"
const unsigned int MS_PER_UPDATE = 2;
class Editor : public Application {
public:
Editor() : Application("Editor") {}
void Run() override
{
BarinkWindow mainWindow = BarinkWindow(1200, 700);
InputSystem = new InputManager();
renderer = new Renderer();
InputSystem->attach(&mainWindow);
InitImGui(mainWindow);
activeRuntime.Start();
double previous = glfwGetTime();
double lag = 0.0;
renderer->Prepare(activeRuntime.MainScene);
while (!mainWindow.WindowShouldClose())
{
double current = glfwGetTime();
double elapsed = current - previous;
previous = current;
lag += elapsed;
InputSystem->PollEvents();
while (lag >= MS_PER_UPDATE)
{
activeRuntime.Update();
lag -= MS_PER_UPDATE;
}
renderer->Render(activeRuntime.framebuffer, activeRuntime.MainScene);
ImGuiBegin();
RenderGUI();
ImGuiEnd();
mainWindow.SwapBuffers();
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
}
activeRuntime.Stop();
delete InputSystem;
delete renderer;
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
}
void InitImGui(BarinkWindow& window )
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_::ImGuiConfigFlags_ViewportsEnable;
io.ConfigFlags |= ImGuiConfigFlags_::ImGuiConfigFlags_DockingEnable;
io.Fonts->AddFontFromFileTTF("build/Debug/Fonts/Roboto-Regular.ttf", 18);
ImGui::StyleColorsDark();
ImGui_ImplGlfw_InitForOpenGL(window.windowptr(), true);
ImGui_ImplOpenGL3_Init("#version 440");
}
void ImGuiBegin() {
ImGui_ImplGlfw_NewFrame();
ImGui_ImplOpenGL3_NewFrame();
ImGui::NewFrame();
ImGuizmo::SetOrthographic(true);
ImGuizmo::BeginFrame();
}
void ImGuiEnd() {
ImGui::EndFrame();
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
{
GLFWwindow* last_context = glfwGetCurrentContext();
ImGui::UpdatePlatformWindows();
ImGui::RenderPlatformWindowsDefault();
glfwMakeContextCurrent(last_context);
}
}
void RenderGUI() {
ImGui::DockSpaceOverViewport(ImGui::GetMainViewport());
// Show a menu bar
ImGui::BeginMainMenuBar();
if (ImGui::BeginMenu("Application")) {
if (ImGui::MenuItem("Load Project"))
{
nfdresult_t result = NFD_OpenDialog({ "yproj" }, NULL, &path);
switch (result) {
case(NFD_OKAY):
Project::LoadProject(path, activeRuntime.CurrentProject);
break;
case(NFD_CANCEL):
break;
case(NFD_ERROR):
std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
break;
}
}
if (ImGui::MenuItem("Save project as...")) {
nfdresult_t result = NFD_SaveDialog({ "yproj" }, NULL, &savePath);
switch (result) {
case(NFD_OKAY):
std::cout << "Save as: " << savePath << std::endl;
Project::SaveProject(savePath, *activeRuntime.CurrentProject.get());
break;
case(NFD_CANCEL):
break;
case(NFD_ERROR):
std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
break;
}
}
if (ImGui::MenuItem("Preferences"))
{
}
if (ImGui::MenuItem("Exit"))
{
// TODO: Exit application
}
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Scene")) {
if (ImGui::MenuItem("Save scene"))
{
nfdresult_t result = NFD_SaveDialog({ "yscene" }, NULL, &scenePath);
switch (result) {
case(NFD_OKAY):
SaveScene(scenePath, activeRuntime.MainScene);
break;
case(NFD_CANCEL):
break;
case(NFD_ERROR):
std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
break;
}
}
if (ImGui::MenuItem("Load scene"))
{
auto result = NFD_OpenDialog({ "yscene" }, NULL, &openScenePath);
switch (result) {
case (NFD_OKAY):
LoadScene(openScenePath, activeRuntime.MainScene);
break;
case(NFD_CANCEL):
break;
case(NFD_ERROR):
std::cout << "NFD_Error: " << NFD_GetError() << std::endl;
break;
}
}
if (ImGui::MenuItem("Add Entity")) {
activeRuntime.MainScene.AddEntity("New Entity");
}
ImGui::EndMenu();
}
ImGui::EndMainMenuBar();
ImGui::Begin("ProjectInfo");
ImGui::Text("Project: %s", activeRuntime.CurrentProject.get()->GetName().c_str());
ImGui::Text("Directory: %s", activeRuntime.CurrentProject.get()->GetProjectDirectory().u8string().c_str());
ImGui::End();
//ShowStats();
Viewport(*activeRuntime.framebuffer);
GamePort(*activeRuntime.framebuffer);
SceneExplorer(activeRuntime.Selected, activeRuntime.MainScene);
Inspector(activeRuntime.Selected, activeRuntime.MainScene);
Settings();
AssetsFinder();
Console();
ImGui::ShowDemoWindow();
ImGui::ShowMetricsWindow();
}
private:
EditorContext context;
EditorRuntime activeRuntime ;
char* path = nullptr;
char* savePath = nullptr;
char* scenePath = nullptr;
char* openScenePath = nullptr;
};
int main (int argc , char* argv[]) {
Editor().Run();
}

View File

@ -1,26 +0,0 @@
# Yoggie Engine features
## Features
**NOTE** __Not in any particular order__
- Rendering
- OpenGL
- Vulkan
- Logging
- Different for debug and release
- Different per OS
- Physics
- PhysX
- Alternative for non-nvidia stuff?!
- Basic Entity Component system
- Graphical scripting ??
- Scripting support ( idk what language)
- LUA
- Configuration options
- JSON
- LUA
- YAML

View File

@ -1,4 +1,4 @@
project "ImGui" project "ImGUI_Opengl3"
kind "StaticLib" kind "StaticLib"
includedirs { includedirs {

View File

@ -1,19 +0,0 @@
project "ImGuizmo"
kind "StaticLib"
includedirs {
"../libs/glfw/include",
"../libs/ImGui",
"../libs/guizmo"
}
files {
"../libs/guizmo/*.cpp",
}
libdirs{
"../libs/ImGui",
"../libs/glad"
}
include("../ImGui")

BIN
Manuals/GLSL.std.450.pdf Normal file

Binary file not shown.

BIN
Manuals/SPIRV.pdf Normal file

Binary file not shown.

View File

@ -1,16 +1,54 @@
# Yoggie Engine # BarinkEngine
```
,---,. ,-. ,---,.
,' .' \ ,--, ,--/ /| ,' .' | ,--,
,---.' .' | __ ,-,--.'| ,---,,--. :/ |,---.' | ,---, ,--.'| ,---,
| | |: | ,' ,'/ /| |, ,-+-. / : : ' / | | .' ,-+-. / | ,----._,| |, ,-+-. / |
: : : / ,--.--. ' | |' `--'_ ,--.'|' | ' / : : |-,,--.'|' |/ / ' `--'_ ,--.'|' | ,---.
: | ; / \| | ,,' ,'| | | ,"' ' | : : | ;/| | ,"' | : ,' ,'| | | ,"' | / \
| : .--. .-. ' : / ' | | | | / | | | \ | : .| | / | | | .\ ' | | | | / | |/ / |
| | . |\__\/: . | | ' | | : | | | | ' : |. \| | |-| | | | . ; '; | | : | | | | . ' / |
' : '; |," .--.; ; : | ' : |__| | | |/| | ' \ ' : ;/| | | |/' . . ' : |__| | | |/' ; /|
| | | ;/ / ,. | , ; | | '.'| | |--' ' : |--'| | | | |--' `---`-'| | | '.'| | |--' ' | / |
| : /; : .' ---' ; : | |/ ; |,' | : .| |/ .'__/\_: ; : | |/ | : |
| | ,' | , .-./ | , /'---' '--' | | ,' '---' | : | , /'---' \ \ /
`----' `--`---' ---`-' `----' \ \ / ---`-' `----'
`--`-'
```
<img src="Screenshots/Yoggie.webp" width="400" ></img> ## Features
**NOTE** __Not in any particular order__
- Rendering
- OpenGL
- Vulkan
- Logging
- Different for debug and release
- Different per OS
- Physics
- PhysX
- Alternative for non-nvidia stuff?!
- Basic Entity Component system
- Graphical scripting ??
- Scripting support ( idk what language)
- LUA
- Configuration options
- JSON
- LUA
- others ?!?!?
## Screenshots ## Screenshots
<img src="Screenshots/screen1.png" width="300"></img> \ <img src="Screenshots/screen1.png" width="300"></img>
<img src="Screenshots/screen2.png" width="300"></img> \ <img src="Screenshots/screen2.png" width="300"></img>
<img src="Screenshots/YoggieEditor.png" width="300"></img>
## Planning ## Planning
see [TODO](docs/TODO.md) \ see [TODO](docs/TODO.md)
see [Features](Features.md)
_NOTE:_ _NOTE:_
The planning is moving away from markdown in favor The planning is moving away from markdown in favor

View File

@ -1,39 +0,0 @@
project "Runtime"
kind "ConsoleApp"
buildmessage "Building the runtime ..."
links{
"YoggieEngine"
}
includedirs{
"./../YoggieEngine/src",
-- I'd prefer if didn't need these..
-- We'll figure that out some time later
"./../libs/lua/include",
"./../libs/spdlog/include",
"./../libs/glm",
"./../libs/GorillaAudio/include",
"./../libs/assimp/include",
"./../libs/glad/include",
"./../libs/glfw/include",
"./../libs/tinygltf",
"./../libs/glew/include",
"./../libs/glm",
"./../libs/ImGui",
"./include"
}
libdirs {
'./../YoggieEngine/build/Debug'
}
files {
"./src/*.h",
"./src/*.cpp"
}

View File

@ -1,6 +0,0 @@
#include <iostream>
int main()
{
std::cout << "Welcome to the runtime!" << std::endl;
}

View File

@ -1,40 +0,0 @@
project "SandboxApp"
kind "ConsoleApp"
buildmessage "Building SandboxApp ..."
links{
"YoggieEngine"
}
includedirs{
"./../YoggieEngine/Include",
-- I'd prefer if didn't need these..
-- We'll figure that out some time later
"./../libs/lua/include",
"./../libs/spdlog/include",
"./../libs/glm",
"./../libs/GorillaAudio/include",
"./../libs/assimp/include",
"./../libs/glad/include",
"./../libs/glfw/include",
"./../libs/tinygltf",
"./../libs/glew/include",
"./../libs/glm",
"./../libs/ImGui",
"../libs/entt/src",
}
libdirs {
'./../YoggieEngine/build/Debug'
}
files {
"./src/*.h",
"./src/*.cpp"
}

View File

@ -1,87 +0,0 @@
#include "GUI.h"
void SceneExplorer(const std::string& PanelName) {
ImGui::Begin(PanelName.c_str());
//if (ImGui::ListBoxHeader("##ObjectList")) {
//Node& current = scene.GetRoot();
//Node* next = &current;
// Show first node
//ImGui::Selectable(next->name.c_str(), true);
// ImGui::Selectable("Scene Node", 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() {
static float Zoom = 0;
static glm::vec3 Position = glm::vec3(0.0f, 0.0f, 0.0f);
static glm::vec3 Rotation = glm::vec3(0.0f, 0.0f, 0.0f);
ImGui::Begin("Camera");
ImGui::SliderFloat("Zoom:", &Zoom, 10, 190);
ImGui::InputFloat3("Position:", &Position[0]);
ImGui::InputFloat3("Rotation:", &Rotation[0]);
ImGui::End();
}
void ScriptingTool(char* code) {
ImGui::Begin("Scripting");
ImGui::Text("Lua Code");
ImGui::InputTextMultiline("##", code, 255);
bool runCode = ImGui::Button("Run");
ImGui::End();
}
void SceneView(Framebuffer& framebuffer ) {
ImGui::Begin("Viewport");
ImGui::Image((void*)(intptr_t)framebuffer.GetColourAttachment(), ImVec2{800, 600});
ImGui::End();
}
/*
* void transformWindow(Transform& transform, std::string PanelName) {
ImGui::Begin(PanelName.c_str());
ImGui::InputFloat3("Position:", (float*)&transform.Position[0]);
ImGui::InputFloat3("Rotation:", (float*)&transform.Rotation[0]);
ImGui::InputFloat3("Scale:", (float*)&transform.Scale[0]);
ImGui::End();
}
*/
void materialWindow(Material& material, std::string PanelName) {
ImGui::Begin(PanelName.c_str());
ImGui::ColorPicker3("Color:", &material.Color[0]);
ImGui::End();
}

View File

@ -1,11 +0,0 @@
#pragma once
#include "imgui.h"
#include "../../YoggieEngine/src/BarinkEngine.h"
#include "../../YoggieEngine/src/Graphics/Memory/Framebuffer.h"
void CameraTool();
void ScriptingTool(char* code);
///void transformWindow(Transform& transform, std::string PanelName);
void materialWindow(Material& material, std::string PanelName);
void SceneExplorer(const std::string& PanelName);
void SceneView(Framebuffer& framebuffer);

View File

@ -1,123 +0,0 @@
#include <imgui.h>
#include "GUI.h"
#include "Util.h"
#include <entt/entt.hpp>
#include "../../YoggieEngine/src/BarinkEngine.h"
#include "../../YoggieEngine/src/Scene/Components.h"
#include "../../YoggieEngine/src/Scene/Scene.h"
#include "../../YoggieEngine/src/Scene/Entity.h"
#include "../../YoggieEngine/src/AssetManager/ModelImporter.h"
#include "../../YoggieEngine/src/PerfCounter.h"
/*
* Define globals
*/
Scene scene;
BarinkEngine::Renderable* renderable;
BarinkEngine::SceneObject* object;
Entity cube;
/*
* Runs once at startup
* - USe to initialize the game/sandbox/demo
*/
void Start() {
auto importer = BarinkEngine::ModelImporter();
// Load in asset(S)
object = importer.Import("build/Debug/Models/Cube.obj");
renderable = object->renderable;
// Add Entities to the scene
cube = scene.AddEntity("cube");
auto& render3DComponent = cube.AddComponent<BarinkEngine::Render3DComponent>();
render3DComponent.mesh = *renderable->mesh;
cube.GetComponent<BarinkEngine::TransformComponent>()
.transform = glm::rotate(glm::mat4(1.0f), 32.0f, glm::vec3(0.5f,1.0f,0.0f));
// Create a second cube
auto cube2 = scene.AddEntity("Cube2");
auto& cube2Render = cube2.AddComponent<BarinkEngine::Render3DComponent>();
cube2Render.mesh = *renderable->mesh;
cube2Render.color = glm::vec3(0.0f, 1.0f, 0.0f);
auto& cube2Trans = cube2.GetComponent<BarinkEngine::TransformComponent>();
cube2Trans.transform = glm::translate( glm::mat4(1.0f), glm::vec3(1.0f,0.0f, 5.0f));
// Create a light
auto AmbientLight = scene.AddEntity("AmbientLight");
AmbientLight.AddComponent<BarinkEngine::LightComponent>();
renderer.Prepare(scene);
}
/*
* Runs every frame
* - Use to draw Immediate mode graphics (Not meant for HUD's )
*/
void ImmediateGraphicsDraw()
{
// Show internal BarinkEngine stats
EngineInstrumentation::ShowStats();
ImGui::Begin("Scene view");
auto group = scene.getReg().view<BarinkEngine::IdentifierComponent>();
group.each([](auto entity, BarinkEngine::IdentifierComponent& identifier) {
ImGui::Text("%s", identifier.name.c_str());
});
ImGui::End();
ImGui::ShowMetricsWindow();
ImGui::Begin("Settings");
auto& a = cube.GetComponent<BarinkEngine::Render3DComponent>();
auto& b = cube.GetComponent<BarinkEngine::TransformComponent>();
ImGui::DragFloat3("Color", &a.color[0], 0.01f, 0.0f, 1.0f);
ImGui::DragFloat3("Position", &b.transform[3][0], 0.01f, 0.0f, 16.0f);
auto l = scene.getReg().view<BarinkEngine::LightComponent>();
l.each([](auto entity, BarinkEngine::LightComponent& light) {
ImGui::Text("Lighting");
ImGui::SliderFloat("Intensity", &light.Strength, 0.0f, 1.0f);
ImGui::SliderFloat3("l-Color", &light.Color[0], 0.0f, 1.0f);
});
ImGui::End();
}
/*
* Runs every frame
* - Meant for game logic ( non-physics related)
*/
void Update()
{
}
void Render()
{
renderer.Render(scene);
}
/*
* Runs at the end of the program
* - Meant for cleanup
*/
void Stop()
{
}

View File

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

View File

@ -0,0 +1,41 @@
#include "GUI.h"
void CameraTool(Camera* cam) {
ImGui::Begin("Camera");
ImGui::SliderFloat("Zoom:", &cam->Zoom, 10, 190);
ImGui::InputFloat3("Position:", &cam->Position[0]);
ImGui::InputFloat3("Rotation:", &cam->Rotation[0]);
ImGui::End();
}
void ScriptingTool(char* code) {
ImGui::Begin("Scripting");
ImGui::InputTextMultiline("Lua Script", code, 255);
bool runCode = ImGui::Button("Run");
ImGui::End();
}
void transformWindow(Transform& transform, std::string PanelName) {
ImGui::Begin(PanelName.c_str());
ImGui::InputFloat3("Position:", (float*)&transform.Position[0]);
ImGui::InputFloat3("Rotation:", (float*)&transform.Rotation[0]);
ImGui::InputFloat3("Scale:", (float*)&transform.Scale[0]);
ImGui::End();
}
void materialWindow(Material& material, std::string PanelName) {
ImGui::Begin(PanelName.c_str());
ImGui::ColorPicker3("Color:", &material.Color[0]);
ImGui::End();
}

8
SandboxApplication/GUI.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
#include "imgui.h"
#include <BarinkEngine.h>
void CameraTool(Camera* camera);
void ScriptingTool(char* code);
void transformWindow(Transform& transform, std::string PanelName);
void materialWindow(Material& material, std::string PanelName);

View File

@ -0,0 +1,176 @@
#include "BarinkEngine.h"
#include "imgui.h"
#include "GUI.h"
#include "Util.h"
/*
* Define globals
*/
Camera* cam;
Shader* shader;
Renderable* Cube;
Material* matCube;
Texture* textureCube;
Renderable* Cube2;
Material* matCube2;
char* code = new char[254];
const std::string vertexShaderSource = "build/SandboxApplication/Debug/test.vs";
const std::string fragmentShaderSource = "build/SandboxApplication/Debug/test.fs";
/*
* Runs once at startup
* - USe to initialize the game/sandbox/demo
*/
void Start() {
/*
Building a very basic scene graph
*/
SceneNode MyCube = SceneNode();
MyCube.name = "MyCube";
SceneNode MyBaby = SceneNode();
MyBaby.name = "Baby";
SceneNode MySecondCube = SceneNode();
MySecondCube.name = "MySecondCube";
MyCube.addChild(MyBaby);
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);
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);
memset(code, '\0', 254);
}
/*
* Runs every frame
* - Use to draw Immediate mode graphics (Not meant for HUD's )
*/
void ImmediateGraphicsDraw() {
ImGui::NewFrame();
// Show ImGui demo such that I can easily look
// at possible GUI elements to use
ImGui::ShowDemoWindow();
// Show internal BarinkEngine stats
ShowStats();
// Show different tooling for this specific sandbox
CameraTool(cam);
ScriptingTool(code);
transformWindow(Cube->transform, "Transform (Cube)");
transformWindow(Cube2->transform, "Transform (Cube2)");
materialWindow(*matCube, "Material Cube");
materialWindow(*matCube2, "Material Cube2");
}
/*
* Runs every frame
* - Meant for game logic ( non-physics related)
*/
void Update()
{
/*
* NOTE: this needs to move to the renderer
* 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);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
shader->Use();
shader->setUniformMat4("P", projection);
shader->setUniformMat4("M", CalculateModelMat(Cube->transform));
shader->setUniformMat4("V", cam->GetViewMatrix());
matCube->Apply();
Cube->Draw();
shader->setUniformMat4("M", CalculateModelMat(Cube2->transform));
matCube2->Apply();
Cube2->Draw();
}
/*
* Runs at the end of the program
* - Meant for cleanup
*/
void Stop() {
// Cleanup
Cube->VAO.Delete();
Cube->elementBuffer.Delete();
Cube2->VAO.Delete();
Cube2->elementBuffer.Delete();
delete Cube2;
delete Cube;
delete matCube;
delete matCube2;
delete shader;
}

View File

@ -1,7 +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++) {
@ -31,5 +30,3 @@ glm::mat4 CalculateModelMat(Transform& transform) {
return tran * rot * scale; return tran * rot * scale;
} }
*/

View File

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

BIN
Screenshots/Yoggie.webp (Stored with Git LFS)

Binary file not shown.

BIN
Screenshots/YoggieEditor.png (Stored with Git LFS)

Binary file not shown.

View File

@ -11,7 +11,7 @@
<input type="checkbox"></input> Basic Textures \ <input type="checkbox"></input> Basic Textures \
<input type="checkbox" checked></input> Link GLEW or GLAD \ <input type="checkbox" checked></input> Link GLEW or GLAD \
<input type="checkbox" checked></input> Work on basic logging \ <input type="checkbox" checked></input> Work on basic logging \
<input type="checkbox" checked></input> Input handling \ <input type="checkbox"></input> Input handling \
<input type="checkbox"></input> More shader work \ <input type="checkbox"></input> More shader work \
<input type="checkbox" checked></input> Load FBX model files \ <input type="checkbox" checked></input> Load FBX model files \
<input type="checkbox"></input> Basic Physics \ <input type="checkbox"></input> Basic Physics \
@ -21,6 +21,5 @@
## Resources ## Resources
https://renderdoc.org/ \ https://renderdoc.org/
https://api.projectchrono.org/tutorial_table_of_content_chrono.html \ https://api.projectchrono.org/tutorial_table_of_content_chrono.html
https://github.com/epezent/implot -- Useful when displaying graphs of any kind \

View File

@ -1,73 +0,0 @@
project "YoggieEngine"
kind "StaticLib"
pchheader "YoggieEngine.h"
pchsource "src/YoggieEngine.cpp"
buildmessage "Building Yoggie Engine"
disablewarnings{
"4099" -- Ignore the missing debug signals for GLFW warning
}
includedirs {
"./src",
"../libs/spdlog/include",
"../libs/glm",
"../libs/glfw/include",
"../libs/glew/include",
"../libs/glad/include",
"../libs/assimp/include",
"../libs/entt/src",
"../libs/physx/physx/include",
"../libs/lua/include",
"../libs/GorillaAudio/include",
"../libs/steam-audio/include",
"../libs/ImGui",
}
links {
-- This needs to fall under the filter as the names can differ on different platforms
"phonon",
"lua54",
"spdlog",
"assimp-vc143-mtd",
"glfw3",
"ImGui",
}
libdirs {
"../libs/steam-audio/lib/windows-x64",
"../libs/lua",
"../libs/spdlog/build/Release",
"../libs/assimp/lib/Debug",
"../libs/glfw/build/src/Debug",
}
files {
"./src/**.cpp",
"./src/**.h"
}
prebuildcommands
{
ok,err = os.copyfile("YoggieEngine/src/Graphics/shaders/*" ,"SandboxApp/build/Debug/")
}
postbuildcommands
{
ok,err = os.copyfile("YoggieEngine/build/Debug/intermediates/YoggieEngine.pch", "YoggieEngine/build/Debug/YoggieEngine.pch")
}

View File

@ -1,17 +0,0 @@
#include <YoggieEngine.h>
#include "Application.h"
namespace YoggieEngine {
Application::Application(const std::string& name )
: m_AppName(name)
{
EngineInstrumentation::PerfomanceSamplerInit();
}
void Application::Run() {
std::cout << "No run function implemented!";
}
}

View File

@ -1,33 +0,0 @@
#pragma once
#include "YoggieEngine.h"
namespace YoggieEngine {
// forward declaration
class InputManager;
class Application {
public:
Application(const std::string& name);
virtual void Run();
protected:
std::string m_AppName;
Renderer* renderer = nullptr;
InputManager* InputSystem = nullptr;
friend class ApplicationRuntime;
};
class ApplicationRuntime {
public:
virtual void Start() = 0;
virtual void Update() = 0;
virtual void FixedUpdate() = 0;
virtual void Stop() = 0;
};
};

View File

@ -1,102 +0,0 @@
#include <YoggieEngine.h>
#include "ModelImporter.h"
namespace YoggieEngine {
SceneObject* ModelImporter::Import(const std::string path)
{
SceneObject* root = new SceneObject(std::string(path), nullptr);
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
aiNode* currentNode = scene->mRootNode;
std::vector<Mesh> meshes = processNode(currentNode, scene);
std::cout << "[DEBUG]: Loaded " << meshes.size() << " meshes!" << std::endl;
// create a renderable (per mesh ?? )
root->renderable = new Renderable();
root->renderable->mesh = new Mesh(meshes[0]);
return root;
}
std::vector<Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene)
{
std::vector<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;
}
Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene) {
std::vector<unsigned int> indices;
std::vector<Vertex> vertices;
ProcessVertices(mesh, vertices);
ProcessIndices(mesh, indices);
Mesh result;
result.vertices = vertices;
result.elements = indices;
return result;
}
void ProcessVertices(aiMesh* mesh, std::vector<Vertex>& out_vertices) {
// Process vertices
for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
Vertex v{};
glm::vec3 vector;
vector.x = mesh->mVertices[i].x;
vector.y = mesh->mVertices[i].y;
vector.z = mesh->mVertices[i].z;
v.vertices = vector;
if (mesh->mTextureCoords[0]) {
glm::vec2 texCoord;
texCoord.x = mesh->mTextureCoords[0][i].x;
texCoord.y = mesh->mTextureCoords[0][i].y;
v.uv = texCoord;
}
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

@ -1,31 +0,0 @@
#pragma once
#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "../Graphics/Primitives/Mesh.h"
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <string>
#include "../Scene/TransformTree/SceneNodeTypes.h"
namespace YoggieEngine {
void ProcessVertices(aiMesh* mesh, std::vector<Vertex>& out_vertices);
void ProcessIndices(aiMesh* mesh, std::vector<unsigned int>& out_indices);
class ModelImporter {
public:
SceneObject* Import(const std::string path);
private:
static Mesh ModelImporter::processMesh(aiMesh* mesh, const aiScene* scene);
static std::vector<Mesh> ModelImporter::processNode(aiNode* node, const aiScene* scene);
};
}

View File

@ -1,12 +0,0 @@
#pragma once
namespace YoggieEngine {
struct Event
{
public:
std::string name;
int argc;
void** argv;
};
}

View File

@ -1,28 +0,0 @@
#include <YoggieEngine.h>
#include "EventEmitter.h"
namespace YoggieEngine {
void EventEmitter::Subscribe(EventListener& subscriber)
{
subscribers.push_back(&subscriber);
}
void EventEmitter::Unsubscribe(EventListener& subscriber)
{
subscribers.remove(&subscriber);
}
void EventEmitter::EmitEvent(Event& incident)
{
// Notify all subscribers an event has taken place
for (auto it = subscribers.begin(); it != subscribers.end(); ++it)
{
(*it)->ReceiveEvent(incident);
}
}
EventEmitter::EventEmitter() {
subscribers = std::list<EventListener*>{};
}
}

View File

@ -1,16 +0,0 @@
#pragma once
namespace YoggieEngine{
class EventEmitter {
public:
void Subscribe(EventListener& subscriber);
void Unsubscribe(EventListener& subscriber);
protected:
std::list<EventListener*> subscribers;
void EmitEvent(Event& incident);
EventEmitter();
};
}

Some files were not shown because too many files have changed in this diff Show More