riyyi
/
inferno
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Engine: Run clang-format

master
Riyyi 2 years ago
parent
3da83e9cea
commit
b72da1278d
69 changed files with 4296 additions and 4160 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 292
      src/inferno/application.cpp
  2. 80
      src/inferno/application.h
  3. 112
      src/inferno/assert.h
  4. 40
      src/inferno/component/cameracomponent.h
  5. 20
      src/inferno/component/luascriptcomponent.h
  6. 43
      src/inferno/component/nativescriptcomponent.h
  7. 8
      src/inferno/component/spritecomponent.h
  8. 16
      src/inferno/component/tagcomponent.h
  9. 36
      src/inferno/component/textareacomponent.h
  10. 76
      src/inferno/component/transformcomponent.cpp
  11. 22
      src/inferno/component/transformcomponent.h
  12. 63
      src/inferno/event/applicationevent.h
  13. 92
      src/inferno/event/joystickevent.h
  14. 124
      src/inferno/event/keyevent.h
  15. 198
      src/inferno/event/mouseevent.h
  16. 74
      src/inferno/io/file.cpp
  17. 88
      src/inferno/io/file.h
  18. 134
      src/inferno/io/gltffile.cpp
  19. 14
      src/inferno/io/gltffile.h
  20. 136
      src/inferno/io/input.cpp
  21. 56
      src/inferno/io/input.h
  22. 526
      src/inferno/io/log.cpp
  23. 264
      src/inferno/io/log.h
  24. 256
      src/inferno/keycodes.cpp
  25. 2
      src/inferno/keycodes.h
  26. 581
      src/inferno/render/buffer.cpp
  27. 208
      src/inferno/render/buffer.h
  28. 80
      src/inferno/render/context.cpp
  29. 20
      src/inferno/render/context.h
  30. 237
      src/inferno/render/font.cpp
  31. 86
      src/inferno/render/font.h
  32. 10
      src/inferno/render/framebuffer.h
  33. 18
      src/inferno/render/gltf.cpp
  34. 56
      src/inferno/render/gltf.h
  35. 675
      src/inferno/render/renderer.cpp
  36. 276
      src/inferno/render/renderer.h
  37. 446
      src/inferno/render/shader.cpp
  38. 114
      src/inferno/render/shader.h
  39. 242
      src/inferno/render/texture.cpp
  40. 90
      src/inferno/render/texture.h
  41. 212
      src/inferno/scene/scene.cpp
  42. 126
      src/inferno/scene/scene.h
  43. 224
      src/inferno/script/cameracontroller.cpp
  44. 38
      src/inferno/script/cameracontroller.h
  45. 128
      src/inferno/script/luascript.cpp
  46. 54
      src/inferno/script/luascript.h
  47. 38
      src/inferno/script/nativescript.h
  48. 209
      src/inferno/script/registration.cpp
  49. 98
      src/inferno/script/registration.h
  50. 146
      src/inferno/settings.cpp
  51. 38
      src/inferno/settings.h
  52. 86
      src/inferno/singleton.h
  53. 127
      src/inferno/system/camerasystem.cpp
  54. 28
      src/inferno/system/camerasystem.h
  55. 26
      src/inferno/system/rendersystem.cpp
  56. 18
      src/inferno/system/rendersystem.h
  57. 126
      src/inferno/system/scriptsystem.cpp
  58. 30
      src/inferno/system/scriptsystem.h
  59. 168
      src/inferno/system/textareasystem.cpp
  60. 26
      src/inferno/system/textareasystem.h
  61. 46
      src/inferno/system/transformsystem.cpp
  62. 18
      src/inferno/system/transformsystem.h
  63. 10
      src/inferno/time.cpp
  64. 8
      src/inferno/time.h
  65. 22
      src/inferno/util/integer.h
  66. 10
      src/inferno/util/json.h
  67. 18
      src/inferno/util/string.h
  68. 393
      src/inferno/window.cpp
  69. 74
      src/inferno/window.h

292
src/inferno/application.cpp
Unescape View File

@ -25,196 +25,196 @@
namespace Inferno {
Application::Application(s)
{
// Initialize
Application::Application(s)
{
// Initialize
Settings::initialize();
m_window = std::make_unique<Window>();
m_window->setEventCallback(NF_BIND_EVENT(Application::onEvent));
Input::initialize();
RenderCommand::initialize();
m_scene = std::make_shared<Scene>();
m_scene->initialize();
Settings::initialize();
// Load assets
m_window = std::make_unique<Window>();
m_window->setEventCallback(NF_BIND_EVENT(Application::onEvent));
m_font = FontManager::the().load("assets/fnt/dejavu-sans");
Input::initialize();
RenderCommand::initialize();
// auto bla = GlTFFile::read("assets/gltf/box.glb");
// success() << "@" << bla.first.get() << "@";
// auto bla2 = GlTFFile::read("assets/gltf/boxtextured.glb");
// info() << "@" << bla2.first.get() << "@";
// auto bla3 = GlTFFile::read("assets/gltf/guinea-pig-cage-fleece.glb");
// warn() << "@" << bla3.first.get() << "@";
m_scene = std::make_shared<Scene>();
m_scene->initialize();
// Gltf model = Gltf("assets/gltf/box.glb");
// Load assets
// Gltf model = Gltf("assets/gltf/animatedmorphcube.glb");
// Gltf model = Gltf("assets/gltf/reciprocatingsaw.glb");
m_font = FontManager::the().load("assets/fnt/dejavu-sans");
// Gltf model = Gltf("assets/gltf/triangle-without-indices.gltf");
}
// auto bla = GlTFFile::read("assets/gltf/box.glb");
// success() << "@" << bla.first.get() << "@";
// auto bla2 = GlTFFile::read("assets/gltf/boxtextured.glb");
// info() << "@" << bla2.first.get() << "@";
// auto bla3 = GlTFFile::read("assets/gltf/guinea-pig-cage-fleece.glb");
// warn() << "@" << bla3.first.get() << "@";
Application::~Application()
{
m_scene->destroy();
// Gltf model = Gltf("assets/gltf/box.glb");
FontManager::destroy();
RendererCharacter::destroy();
Renderer2D::destroy();
RenderCommand::destroy();
TextureManager::destroy();
ShaderManager::destroy();
// Input::destroy();
// Gltf model = Gltf("assets/gltf/animatedmorphcube.glb");
// Gltf model = Gltf("assets/gltf/reciprocatingsaw.glb");
Settings::destroy();
}
// Gltf model = Gltf("assets/gltf/triangle-without-indices.gltf");
}
Application::~Application()
{
m_scene->destroy();
int Application::run()
{
dbg() << "Application startup";
FontManager::destroy();
RendererCharacter::destroy();
Renderer2D::destroy();
RenderCommand::destroy();
TextureManager::destroy();
ShaderManager::destroy();
// Input::destroy();
std::array<CharacterVertex, Renderer::vertexPerQuad> character;
Settings::destroy();
}
// character.at(0).quad.textureCoordinates = { 0.0f, 0.0f }; // bottom left
// character.at(1).quad.textureCoordinates = { 1.0f, 0.0f };
// character.at(2).quad.textureCoordinates = { 1.0f, 1.0f }; // top right
// character.at(3).quad.textureCoordinates = { 0.0f, 1.0f };
int Application::run()
{
dbg() << "Application startup";
auto f = FontManager::the().get("assets/fnt/dejavu-sans");
auto c = f->get('5');
// dbg() << c->position << " " << c->size;
std::array<CharacterVertex, Renderer::vertexPerQuad> character;
uint32_t textureWidth = f->texture()->width();
uint32_t textureHeight = f->texture()->height();
VERIFY(textureWidth == textureHeight, "Invalid font texture!");
// character.at(0).quad.textureCoordinates = { 0.0f, 0.0f }; // bottom left
// character.at(1).quad.textureCoordinates = { 1.0f, 0.0f };
// character.at(2).quad.textureCoordinates = { 1.0f, 1.0f }; // top right
// character.at(3).quad.textureCoordinates = { 0.0f, 1.0f };
float quadWidth = (c->size.x / (float)textureWidth) - 0.04; // @Todo something wrong with the width
float quadHeight = c->size.y / (float)textureHeight;
auto f = FontManager::the().get("assets/fnt/dejavu-sans");
auto c = f->get('5');
// dbg() << c->position << " " << c->size;
character.at(0).quad.position = { -quadWidth, -quadHeight, 0.0f }; // bottom left
character.at(1).quad.position = { quadWidth, -quadHeight, 0.0f }; // bottom right
character.at(2).quad.position = { quadWidth, quadHeight, 0.0f }; // top right
character.at(3).quad.position = { -quadWidth, quadHeight, 0.0f }; // top left
uint32_t textureWidth = f->texture()->width();
uint32_t textureHeight = f->texture()->height();
VERIFY(textureWidth == textureHeight, "Invalid font texture!");
glm::vec2 x {
1 - (textureWidth - c->position.x) / (float)textureWidth,
1 - (textureWidth - c->position.x - c->size.x) / (float)textureWidth
};
glm::vec2 y {
(textureHeight - c->position.y - c->size.y) / (float)textureHeight,
(textureHeight - c->position.y) / (float)textureHeight
};
// dbg() < y;
float quadWidth = (c->size.x / (float)textureWidth) - 0.04; // @Todo something wrong with the width
float quadHeight = c->size.y / (float)textureHeight;
character.at(0).quad.textureCoordinates = { x.x, y.x };
character.at(1).quad.textureCoordinates = { x.y, y.x };
character.at(2).quad.textureCoordinates = { x.y, y.y };
character.at(3).quad.textureCoordinates = { x.x, y.y };
character.at(0).quad.position = { -quadWidth, -quadHeight, 0.0f }; // bottom left
character.at(1).quad.position = { quadWidth, -quadHeight, 0.0f }; // bottom right
character.at(2).quad.position = { quadWidth, quadHeight, 0.0f }; // top right
character.at(3).quad.position = { -quadWidth, quadHeight, 0.0f }; // top left
// pos
// texcoords
//
// width
// edge
// borderwidth
// borderedge
// bordercolor
// offset
glm::vec2 x {
1 - (textureWidth - c->position.x) / (float)textureWidth,
1 - (textureWidth - c->position.x - c->size.x) / (float)textureWidth
};
glm::vec2 y {
(textureHeight - c->position.y - c->size.y) / (float)textureHeight,
(textureHeight - c->position.y) / (float)textureHeight
};
// dbg() < y;
while (!m_window->shouldClose()) {
character.at(0).quad.textureCoordinates = { x.x, y.x };
character.at(1).quad.textureCoordinates = { x.y, y.x };
character.at(2).quad.textureCoordinates = { x.y, y.y };
character.at(3).quad.textureCoordinates = { x.x, y.y };
float time = Time::time();
float deltaTime = time - m_lastFrameTime;
m_lastFrameTime = time;
// dbg() << "Frametime " << deltaTime * 1000 << "ms";
// pos
// texcoords
//
// width
// edge
// borderwidth
// borderedge
// bordercolor
// offset
// Update
while (!m_window->shouldClose()) {
Input::update();
m_window->update();
m_scene->update(deltaTime);
float time = Time::time();
float deltaTime = time - m_lastFrameTime;
m_lastFrameTime = time;
// dbg() << "Frametime " << deltaTime * 1000 << "ms";
// Render
// Update
RenderCommand::clearColor({ 0.2f, 0.3f, 0.3f, 1.0f });
RenderCommand::clear();
Input::update();
m_window->update();
m_scene->update(deltaTime);
Renderer2D::the().beginScene(m_scene->cameraProjectionView()); // camera, lights, environment
RendererCharacter::the().beginScene();
m_scene->render();
// RendererCharacter::the().drawCharacter(character, f->texture());
// Render
Renderer2D::the().endScene();
RendererCharacter::the().endScene();
RenderCommand::clearColor({ 0.2f, 0.3f, 0.3f, 1.0f });
RenderCommand::clear();
m_window->render();
}
Renderer2D::the().beginScene(m_scene->cameraProjectionView()); // camera, lights, environment
RendererCharacter::the().beginScene();
dbg() << "Application shutdown";
m_scene->render();
// RendererCharacter::the().drawCharacter(character, f->texture());
return m_status;
}
Renderer2D::the().endScene();
RendererCharacter::the().endScene();
void Application::onEvent(Event& e)
{
EventDispatcher dispatcher(e);
dispatcher.dispatch<WindowCloseEvent>(NF_BIND_EVENT(Application::onWindowClose));
dispatcher.dispatch<WindowResizeEvent>(NF_BIND_EVENT(Application::onWindowResize));
dispatcher.dispatch<KeyPressEvent>(NF_BIND_EVENT(Application::onKeyPress));
dispatcher.dispatch<MousePositionEvent>(NF_BIND_EVENT(Application::onMousePosition));
}
m_window->render();
}
bool Application::onWindowClose(WindowCloseEvent& e)
{
// Suppress unused warning
(void)e;
dbg() << "Application shutdown";
info() << "WindowCloseEvent triggered";
infoln("{}Event triggered", e.toString());
return m_status;
}
m_window->setShouldClose(true);
void Application::onEvent(Event& e)
{
EventDispatcher dispatcher(e);
dispatcher.dispatch<WindowCloseEvent>(NF_BIND_EVENT(Application::onWindowClose));
dispatcher.dispatch<WindowResizeEvent>(NF_BIND_EVENT(Application::onWindowResize));
dispatcher.dispatch<KeyPressEvent>(NF_BIND_EVENT(Application::onKeyPress));
dispatcher.dispatch<MousePositionEvent>(NF_BIND_EVENT(Application::onMousePosition));
}
return true;
}
bool Application::onWindowClose(WindowCloseEvent& e)
{
// Suppress unused warning
(void)e;
bool Application::onWindowResize(WindowResizeEvent& e)
{
// Suppress unused warning
(void)e;
info() << "WindowCloseEvent triggered";
infoln("{}Event triggered", e.toString());
infoln("WindowResizeEvent {}x{} triggered", e.getWidth(), e.getHeight());
m_window->setShouldClose(true);
RenderCommand::setViewport(0, 0, e.getWidth(), e.getHeight());
return true;
}
return true;
}
bool Application::onWindowResize(WindowResizeEvent& e)
{
// Suppress unused warning
(void)e;
bool Application::onKeyPress(KeyPressEvent& e)
{
// Suppress unused warning
(void)e;
infoln("WindowResizeEvent {}x{} triggered", e.getWidth(), e.getHeight());
infoln("KeyPressEvent {} ({}) triggered",
Input::getKeyName(e.getKey()),
e.getKey());
RenderCommand::setViewport(0, 0, e.getWidth(), e.getHeight());
return true;
// Stop the main loop on 'Escape' keypress
if (e.getKey() == keyCode("GLFW_KEY_ESCAPE")) {
m_window->setShouldClose(true);
}
bool Application::onKeyPress(KeyPressEvent& e)
{
// Suppress unused warning
(void)e;
infoln("KeyPressEvent {} ({}) triggered",
Input::getKeyName(e.getKey()),
e.getKey());
// Stop the main loop on 'Escape' keypress
if (e.getKey() == keyCode("GLFW_KEY_ESCAPE")) {
m_window->setShouldClose(true);
}
return true;
}
return true;
}
bool Application::onMousePosition(MousePositionEvent& e)
{
return Input::onMousePosition(e);
}
bool Application::onMousePosition(MousePositionEvent& e)
{
return Input::onMousePosition(e);
}
} // namespace Inferno

80
src/inferno/application.h
Unescape View File

@ -6,46 +6,46 @@
namespace Inferno {
class Event;
class Font;
class KeyPressEvent;
class MousePositionEvent;
class Scene;
class Window;
class WindowCloseEvent;
class WindowResizeEvent;
class Application : public ruc::Singleton<Application> {
public:
Application(s);
virtual ~Application();
int run();
void onEvent(Event& e);
bool onWindowClose(WindowCloseEvent& e);
bool onWindowResize(WindowResizeEvent& e);
bool onKeyPress(KeyPressEvent& e);
bool onMousePosition(MousePositionEvent& e);
inline void setStatus(int status) { m_status = status; }
inline Window& getWindow() const { return *m_window; }
private:
int m_status { 0 };
float m_lastFrameTime { 0.0f };
std::unique_ptr<Window> m_window;
std::shared_ptr<Scene> m_scene;
//
std::shared_ptr<Font> m_font;
//
};
// To be defined in the game
extern Application& createApplication();
class Event;
class Font;
class KeyPressEvent;
class MousePositionEvent;
class Scene;
class Window;
class WindowCloseEvent;
class WindowResizeEvent;
class Application : public ruc::Singleton<Application> {
public:
Application(s);
virtual ~Application();
int run();
void onEvent(Event& e);
bool onWindowClose(WindowCloseEvent& e);
bool onWindowResize(WindowResizeEvent& e);
bool onKeyPress(KeyPressEvent& e);
bool onMousePosition(MousePositionEvent& e);
inline void setStatus(int status) { m_status = status; }
inline Window& getWindow() const { return *m_window; }
private:
int m_status { 0 };
float m_lastFrameTime { 0.0f };
std::unique_ptr<Window> m_window;
std::shared_ptr<Scene> m_scene;
//
std::shared_ptr<Font> m_font;
//
};
// To be defined in the game
extern Application& createApplication();
} // namespace Inferno

112
src/inferno/assert.h
Unescape View File

@ -33,7 +33,7 @@
#endif
// ##__VA_ARGS__ is a non-standard GCC extension, C++20 introduces __VA_OPT__
// https://stackoverflow.com/questions/52891546/what-does-va-args-mean
// https://stackoverflow.com/questions/52891546/what-does-va-args-mean
#define ASSERT(expr, ...) (static_cast<bool>(expr) ? (void)0 : Inferno::__assert_fail(#expr, __FILE__, __LINE__, FUNCTION_MACRO, ##__VA_ARGS__))
#define ASSERT_NOT_REACHED() ASSERT(false)
#else
@ -51,63 +51,63 @@ inline void __crash()
asm volatile("int $0x03");
}
// FIXME: Doesnt print to stderr
#ifdef NF_ENABLE_ASSERTS
template<typename... P>
inline void __assert_fail(const char* assertion, const char* file, uint32_t line, const char* function, P&&... parameters)
{
(void)function;
// Get the line that caused the error
std::ifstream source(file);
std::string content;
if (source.is_open()) {
for (uint32_t i = 0; std::getline(source, content); ++i) {
if (i == line - 1) {
break;
}
}
}
// Replace tab indentation with spaces
size_t tabs = content.find_first_not_of('\t');
if (tabs > 0 && tabs < content.size()) {
content = std::string(tabs * 4, ' ') + content.substr(tabs);
}
// Find the assertion in the line
size_t column = content.find_first_of(assertion);
size_t assertionLength = strlen(assertion);
if (column == std::string::npos) {
column = content.find_first_not_of(' ');
assertionLength = content.length() - column;
}
// Error message
dbgln(false, "\033[0;1m{}:{}:{}: ", file, line, column + 1);
dangerln(false, "error: ");
dbgln(false, "assertion failed");
if (sizeof...(P) > 0) {
dbgln(false, ": ");
dbgln(Log::None, false, std::forward<P>(parameters)...);
// FIXME: Doesnt print to stderr
#ifdef NF_ENABLE_ASSERTS
template<typename... P>
inline void __assert_fail(const char* assertion, const char* file, uint32_t line, const char* function, P&&... parameters)
{
(void)function;
// Get the line that caused the error
std::ifstream source(file);
std::string content;
if (source.is_open()) {
for (uint32_t i = 0; std::getline(source, content); ++i) {
if (i == line - 1) {
break;
}
// Code line
dbgln("\n {} | {}\033[31;1m{}\033[0m{}", line,
content.substr(0, column), // Whitespace at front
content.substr(column, assertionLength), // Error portion
content.substr(column + assertionLength)); // Rest of the line
// Arrow pointer
dbgln(" {} | {}\033[31;1m^{}\033[0m",
std::string(std::to_string(line).length(), ' '), // Line number spacing
std::string(column, ' '), // Content spacing
std::string(assertionLength - 1, '~')); // Arrow pointer
fflush(stdout); // FIXME: stdout is buffered, strerr is not so wouldnt need this
CRASH();
}
#endif
}
// Replace tab indentation with spaces
size_t tabs = content.find_first_not_of('\t');
if (tabs > 0 && tabs < content.size()) {
content = std::string(tabs * 4, ' ') + content.substr(tabs);
}
// Find the assertion in the line
size_t column = content.find_first_of(assertion);
size_t assertionLength = strlen(assertion);
if (column == std::string::npos) {
column = content.find_first_not_of(' ');
assertionLength = content.length() - column;
}
// Error message
dbgln(false, "\033[0;1m{}:{}:{}: ", file, line, column + 1);
dangerln(false, "error: ");
dbgln(false, "assertion failed");
if (sizeof...(P) > 0) {
dbgln(false, ": ");
dbgln(Log::None, false, std::forward<P>(parameters)...);
}
// Code line
dbgln("\n {} | {}\033[31;1m{}\033[0m{}", line,
content.substr(0, column), // Whitespace at front
content.substr(column, assertionLength), // Error portion
content.substr(column + assertionLength)); // Rest of the line
// Arrow pointer
dbgln(" {} | {}\033[31;1m^{}\033[0m",
std::string(std::to_string(line).length(), ' '), // Line number spacing
std::string(column, ' '), // Content spacing
std::string(assertionLength - 1, '~')); // Arrow pointer
fflush(stdout); // FIXME: stdout is buffered, strerr is not so wouldnt need this
CRASH();
}
#endif
} // namespace Inferno
// https://github.com/scottt/debugbreak

40
src/inferno/component/cameracomponent.h
Unescape View File

@ -5,25 +5,25 @@
namespace Inferno {
enum CameraType {
Orthographic,
Perspective,
};
struct CameraComponent {
CameraType type = CameraType::Perspective;
// Orthographic
float zoomLevel = 1.0f;
glm::vec3 rotateAxis { 0.0f, 0.0f, 1.0f };
// Perspective
float fov = 90.0f;
float pitch = 0.0f;
float yaw = -90.0f;
glm::vec3 up { 0.0f, 1.0f, 0.0f };
glm::mat4 projection { 1.0f }; // Identity matrix
};
enum CameraType {
Orthographic,
Perspective,
};
struct CameraComponent {
CameraType type = CameraType::Perspective;
// Orthographic
float zoomLevel = 1.0f;
glm::vec3 rotateAxis { 0.0f, 0.0f, 1.0f };
// Perspective
float fov = 90.0f;
float pitch = 0.0f;
float yaw = -90.0f;
glm::vec3 up { 0.0f, 1.0f, 0.0f };
glm::mat4 projection { 1.0f }; // Identity matrix
};
} // namespace Inferno

20
src/inferno/component/luascriptcomponent.h
Unescape View File

@ -5,15 +5,17 @@
namespace Inferno {
class LuaScript;
class LuaScript;
struct LuaScriptComponent {
LuaScript* instance { nullptr };
std::string path;
struct LuaScriptComponent {
LuaScript* instance { nullptr };
std::string path;
// Dont allow manually setting instance during construction
LuaScriptComponent() {}
LuaScriptComponent(const std::string& path)
: path(std::move(path)) {}
};
// Dont allow manually setting instance during construction
LuaScriptComponent() {}
LuaScriptComponent(const std::string& path)
: path(std::move(path))
{
}
};
} // namespace Inferno

43
src/inferno/component/nativescriptcomponent.h
Unescape View File

@ -6,26 +6,27 @@
namespace Inferno {
struct NativeScriptComponent {
NativeScript* instance { nullptr };
NativeScript* (*initialize)();
// Dont allow manually setting instance during construction
NativeScriptComponent() {}
template<typename T>
void bind()
{
VERIFY(instance == nullptr, "NativeScript already bound");
initialize = []() { return static_cast<NativeScript*>(new T()); };
}
void destroy() {
VERIFY(instance, "Attempting to destroy an uninitialized NativeScript");
delete instance;
instance = nullptr;
}
};
struct NativeScriptComponent {
NativeScript* instance { nullptr };
NativeScript* (*initialize)();
// Dont allow manually setting instance during construction
NativeScriptComponent() {}
template<typename T>
void bind()
{
VERIFY(instance == nullptr, "NativeScript already bound");
initialize = []() { return static_cast<NativeScript*>(new T()); };
}
void destroy()
{
VERIFY(instance, "Attempting to destroy an uninitialized NativeScript");
delete instance;
instance = nullptr;
}
};
} // namespace Inferno

8
src/inferno/component/spritecomponent.h
Unescape View File

@ -8,9 +8,9 @@
namespace Inferno {
struct SpriteComponent {
glm::vec4 color { 1.0f };
std::shared_ptr<Texture> texture;
};
struct SpriteComponent {
glm::vec4 color { 1.0f };
std::shared_ptr<Texture> texture;
};
} // namespace Inferno

16
src/inferno/component/tagcomponent.h
Unescape View File

@ -5,14 +5,16 @@
namespace Inferno {
struct TagComponent {
std::string tag;
struct TagComponent {
std::string tag;
TagComponent() = default;
TagComponent(const std::string& tag)
: tag(std::move(tag)) {}
TagComponent() = default;
TagComponent(const std::string& tag)
: tag(std::move(tag))
{
}
operator const std::string&() const { return tag; }
};
operator const std::string&() const { return tag; }
};
} // namespace Inferno

36
src/inferno/component/textareacomponent.h
Unescape View File

@ -8,22 +8,28 @@
namespace Inferno {
struct TextAreaComponent {
std::string content { "" };
std::string font { "" };
uint32_t fontSize { 0 };
uint32_t width { 0 };
uint32_t lines { 0 };
struct TextAreaComponent {
std::string content { "" };
std::string font { "" };
uint32_t fontSize { 0 };
uint32_t width { 0 };
uint32_t lines { 0 };
TextAreaComponent() {}
TextAreaComponent(const std::string& content, const std::string& font,
uint32_t fontSize, uint32_t width, uint32_t lines)
: content(std::move(content)), font(std::move(font)), fontSize(fontSize), width(width), lines(lines) {}
TextAreaComponent() {}
TextAreaComponent(const std::string& content, const std::string& font,
uint32_t fontSize, uint32_t width, uint32_t lines)
: content(std::move(content))
, font(std::move(font))
, fontSize(fontSize)
, width(width)
, lines(lines)
{
}
// booleans?
// glm::vec4 outlineColor { 1.0f, 1.0f, 1.0f, 1.0f };
// glow?
// float dropShadow { 0.0f };
};
// booleans?
// glm::vec4 outlineColor { 1.0f, 1.0f, 1.0f, 1.0f };
// glow?
// float dropShadow { 0.0f };
};
} // namespace Inferno

76
src/inferno/component/transformcomponent.cpp
Unescape View File

@ -2,46 +2,46 @@
namespace Inferno {
const LogStream& operator<<(const LogStream& stream, const glm::vec2& value)
{
return stream << "{ "
<< (value.x >= 0.0f ? " " : "") << value.x << ", "
<< (value.y >= 0.0f ? " " : "") << value.y
<< " }";
}
const LogStream& operator<<(const LogStream& stream, const glm::vec3& value)
{
return stream << "{ "
<< (value.x >= 0.0f ? " " : "") << value.x << ", "
<< (value.y >= 0.0f ? " " : "") << value.y << ", "
<< (value.z >= 0.0f ? " " : "") << value.z
<< " }";
}
const LogStream& operator<<(const LogStream& stream, const glm::vec2& value)
{
return stream << "{ "
<< (value.x >= 0.0f ? " " : "") << value.x << ", "
<< (value.y >= 0.0f ? " " : "") << value.y
<< " }";
}
const LogStream& operator<<(const LogStream& stream, const glm::vec4& value)
{
return stream << "{ "
<< (value.x >= 0.0f ? " " : "") << value.x << ", "
<< (value.y >= 0.0f ? " " : "") << value.y << ", "
<< (value.z >= 0.0f ? " " : "") << value.z << ", "
<< (value.w >= 0.0f ? " " : "") << value.w
<< " }";
}
const LogStream& operator<<(const LogStream& stream, const glm::vec3& value)
{
return stream << "{ "
<< (value.x >= 0.0f ? " " : "") << value.x << ", "
<< (value.y >= 0.0f ? " " : "") << value.y << ", "
<< (value.z >= 0.0f ? " " : "") << value.z
<< " }";
}
const LogStream& operator<<(const LogStream& stream, const glm::mat4& value)
{
return stream << "mat4 "
<< value[0] << "\n " << value[1] << "\n "
<< value[2] << "\n " << value[3];
}
const LogStream& operator<<(const LogStream& stream, const glm::vec4& value)
{
return stream << "{ "
<< (value.x >= 0.0f ? " " : "") << value.x << ", "
<< (value.y >= 0.0f ? " " : "") << value.y << ", "
<< (value.z >= 0.0f ? " " : "") << value.z << ", "
<< (value.w >= 0.0f ? " " : "") << value.w
<< " }";
}
const LogStream& operator<<(const LogStream& stream, const TransformComponent& value)
{
return stream << "transform "
<< value.translate << " t\n "
<< value.rotate << " r\n "
<< value.scale << " s";
}
const LogStream& operator<<(const LogStream& stream, const glm::mat4& value)
{
return stream << "mat4 "
<< value[0] << "\n " << value[1] << "\n "
<< value[2] << "\n " << value[3];
}
const LogStream& operator<<(const LogStream& stream, const TransformComponent& value)
{
return stream << "transform "
<< value.translate << " t\n "
<< value.rotate << " r\n "
<< value.scale << " s";
}
} // namespace Inferno

22
src/inferno/component/transformcomponent.h
Unescape View File

@ -7,18 +7,18 @@
namespace Inferno {
struct TransformComponent {
glm::vec3 translate { 0.0f, 0.0f, 0.0f };
glm::vec3 rotate { 0.0f, 0.0f, 0.0f } ;
glm::vec3 scale { 1.0f, 1.0f, 1.0f };
glm::mat4 transform { 1.0f }; // Identity matrix
};
struct TransformComponent {
glm::vec3 translate { 0.0f, 0.0f, 0.0f };
glm::vec3 rotate { 0.0f, 0.0f, 0.0f };
glm::vec3 scale { 1.0f, 1.0f, 1.0f };
glm::mat4 transform { 1.0f }; // Identity matrix
};
// -----------------------------------------
const LogStream& operator<<(const LogStream& stream, const glm::vec2& value);
const LogStream& operator<<(const LogStream& stream, const glm::vec3& value);
const LogStream& operator<<(const LogStream& stream, const glm::vec4& value);
const LogStream& operator<<(const LogStream& stream, const glm::mat4& value);
const LogStream& operator<<(const LogStream& stream, const TransformComponent& value);
const LogStream& operator<<(const LogStream& stream, const glm::vec2& value);
const LogStream& operator<<(const LogStream& stream, const glm::vec3& value);
const LogStream& operator<<(const LogStream& stream, const glm::vec4& value);
const LogStream& operator<<(const LogStream& stream, const glm::mat4& value);
const LogStream& operator<<(const LogStream& stream, const TransformComponent& value);
} // namespace Inferno

63
src/inferno/event/applicationevent.h
Unescape View File

@ -6,34 +6,37 @@
namespace Inferno {
class WindowCloseEvent : public Event {
public:
EVENT_CLASS_TYPE(WindowClose)
EVENT_CLASS_CATEGORY(ApplicationEventCategory)
};
class WindowResizeEvent : public Event {
public:
WindowResizeEvent(int width, int height) :
m_width(width), m_height(height) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "WindowResize: " << m_width << "x" << m_height;
return ss.str();
}
// -----------------------------------------
inline int getWidth() const { return m_width; }
inline int getHeight() const { return m_height; }
EVENT_CLASS_TYPE(WindowResize)
EVENT_CLASS_CATEGORY(ApplicationEventCategory)
private:
int m_width;
int m_height;
};
class WindowCloseEvent : public Event {
public:
EVENT_CLASS_TYPE(WindowClose)
EVENT_CLASS_CATEGORY(ApplicationEventCategory)
};
class WindowResizeEvent : public Event {
public:
WindowResizeEvent(int width, int height)
: m_width(width)
, m_height(height)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "WindowResize: " << m_width << "x" << m_height;
return ss.str();
}
// -----------------------------------------
inline int getWidth() const { return m_width; }
inline int getHeight() const { return m_height; }
EVENT_CLASS_TYPE(WindowResize)
EVENT_CLASS_CATEGORY(ApplicationEventCategory)
private:
int m_width;
int m_height;
};
} // namespace Inferno

92
src/inferno/event/joystickevent.h
Unescape View File

@ -6,48 +6,54 @@
namespace Inferno {
class JoystickEvent : public Event {
public:
inline int getID() const { return m_id; }
EVENT_CLASS_CATEGORY(InputEventCategory | JoystickEventCatergory)
protected:
JoystickEvent(int id) :
m_id(id) {}
private:
int m_id;
};
class JoystickConnectedEvent : public JoystickEvent {
public:
JoystickConnectedEvent(int id) :
JoystickEvent(id) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "JoystickConnected: " << getID();
return ss.str();
}
EVENT_CLASS_TYPE(JoystickConnected)
};
class JoystickDisconnectedEvent : public JoystickEvent {
public:
JoystickDisconnectedEvent(int id) :
JoystickEvent(id) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "JoystickDisconnected: " << getID();
return ss.str();
}
EVENT_CLASS_TYPE(JoystickDisconnected)
};
class JoystickEvent : public Event {
public:
inline int getID() const { return m_id; }
EVENT_CLASS_CATEGORY(InputEventCategory | JoystickEventCatergory)
protected:
JoystickEvent(int id)
: m_id(id)
{
}
private:
int m_id;
};
class JoystickConnectedEvent : public JoystickEvent {
public:
JoystickConnectedEvent(int id)
: JoystickEvent(id)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "JoystickConnected: " << getID();
return ss.str();
}
EVENT_CLASS_TYPE(JoystickConnected)
};
class JoystickDisconnectedEvent : public JoystickEvent {
public:
JoystickDisconnectedEvent(int id)
: JoystickEvent(id)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "JoystickDisconnected: " << getID();
return ss.str();
}
EVENT_CLASS_TYPE(JoystickDisconnected)
};
} // namespace Inferno

124
src/inferno/event/keyevent.h
Unescape View File

@ -6,63 +6,71 @@
namespace Inferno {
class KeyEvent : public Event {
public:
inline int getKey() const { return m_key; }
EVENT_CLASS_CATEGORY(InputEventCategory | KeyEventCategory)
protected:
KeyEvent(int key) :
m_key(key) {}
private:
int m_key;
};
class KeyPressEvent : public KeyEvent {
public:
KeyPressEvent(int key) :
KeyEvent(key) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "KeyPress: " << getKey();
return ss.str();
}
EVENT_CLASS_TYPE(KeyPress)
};
class KeyReleaseEvent : public KeyEvent {
public:
KeyReleaseEvent(int key) :
KeyEvent(key) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "KeyRelease: " << getKey();
return ss.str();
}
EVENT_CLASS_TYPE(KeyPress)
};
class KeyRepeatEvent : public KeyEvent {
public:
KeyRepeatEvent(int key) :
KeyEvent(key) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "KeyRepeat: " << getKey();
return ss.str();
}
EVENT_CLASS_TYPE(KeyPress)
};
class KeyEvent : public Event {
public:
inline int getKey() const { return m_key; }
EVENT_CLASS_CATEGORY(InputEventCategory | KeyEventCategory)
protected:
KeyEvent(int key)
: m_key(key)
{
}
private:
int m_key;
};
class KeyPressEvent : public KeyEvent {
public:
KeyPressEvent(int key)
: KeyEvent(key)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "KeyPress: " << getKey();
return ss.str();
}
EVENT_CLASS_TYPE(KeyPress)
};
class KeyReleaseEvent : public KeyEvent {
public:
KeyReleaseEvent(int key)
: KeyEvent(key)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "KeyRelease: " << getKey();
return ss.str();
}
EVENT_CLASS_TYPE(KeyPress)
};
class KeyRepeatEvent : public KeyEvent {
public:
KeyRepeatEvent(int key)
: KeyEvent(key)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "KeyRepeat: " << getKey();
return ss.str();
}
EVENT_CLASS_TYPE(KeyPress)
};
} // namespace Inferno

198
src/inferno/event/mouseevent.h
Unescape View File

@ -6,98 +6,110 @@
namespace Inferno {
class MouseButtonEvent : public Event {
public:
inline int getButton() const { return m_button; }
EVENT_CLASS_CATEGORY(InputEventCategory | MouseEventCategory | MouseButtonEventCategory)
protected:
MouseButtonEvent(int button) :
m_button(button) {}
private:
int m_button;
};
class MouseButtonPressEvent : public MouseButtonEvent {
public:
MouseButtonPressEvent(int button) :
MouseButtonEvent(button) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MouseButtonPressed: " << getButton();
return ss.str();
}
EVENT_CLASS_TYPE(MouseButtonPress)
};
class MouseButtonReleaseEvent : public MouseButtonEvent {
public:
MouseButtonReleaseEvent(int button) :
MouseButtonEvent(button) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MouseButtonReleased: " << getButton();
return ss.str();
}
EVENT_CLASS_TYPE(MouseButtonRelease)
};
class MousePositionEvent : public Event {
public:
MousePositionEvent(float xPos, float yPos) :
m_xPos(xPos), m_yPos(yPos) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MousePosition: " << m_xPos << "x" << m_yPos;
return ss.str();
}
// -----------------------------------------
inline float getXPos() const { return m_xPos; }
inline float getYPos() const { return m_yPos; }
EVENT_CLASS_TYPE(MousePosition)
EVENT_CLASS_CATEGORY(InputEventCategory | MouseEventCategory)
private:
float m_xPos;
float m_yPos;
};
class MouseScrollEvent : public Event {
public:
MouseScrollEvent(float xOffset, float yOffset) :
m_xOffset(xOffset), m_yOffset(yOffset) {}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MouseScroll: " << m_xOffset << ":" << m_yOffset;
return ss.str();
}
// -----------------------------------------
inline float getXOffset() const { return m_xOffset; }
inline float getYOffset() const { return m_yOffset; }
EVENT_CLASS_TYPE(MouseScroll)
EVENT_CLASS_CATEGORY(InputEventCategory | MouseEventCategory)
private:
float m_xOffset;
float m_yOffset;
};
class MouseButtonEvent : public Event {
public:
inline int getButton() const { return m_button; }
EVENT_CLASS_CATEGORY(InputEventCategory | MouseEventCategory | MouseButtonEventCategory)
protected:
MouseButtonEvent(int button)
: m_button(button)
{
}
private:
int m_button;
};
class MouseButtonPressEvent : public MouseButtonEvent {
public:
MouseButtonPressEvent(int button)
: MouseButtonEvent(button)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MouseButtonPressed: " << getButton();
return ss.str();
}
EVENT_CLASS_TYPE(MouseButtonPress)
};
class MouseButtonReleaseEvent : public MouseButtonEvent {
public:
MouseButtonReleaseEvent(int button)
: MouseButtonEvent(button)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MouseButtonReleased: " << getButton();
return ss.str();
}
EVENT_CLASS_TYPE(MouseButtonRelease)
};
class MousePositionEvent : public Event {
public:
MousePositionEvent(float xPos, float yPos)
: m_xPos(xPos)
, m_yPos(yPos)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MousePosition: " << m_xPos << "x" << m_yPos;
return ss.str();
}
// -----------------------------------------
inline float getXPos() const { return m_xPos; }
inline float getYPos() const { return m_yPos; }
EVENT_CLASS_TYPE(MousePosition)
EVENT_CLASS_CATEGORY(InputEventCategory | MouseEventCategory)
private:
float m_xPos;
float m_yPos;
};
class MouseScrollEvent : public Event {
public:
MouseScrollEvent(float xOffset, float yOffset)
: m_xOffset(xOffset)
, m_yOffset(yOffset)
{
}
virtual std::string toString() const override
{
std::stringstream ss;
ss << "MouseScroll: " << m_xOffset << ":" << m_yOffset;
return ss.str();
}
// -----------------------------------------
inline float getXOffset() const { return m_xOffset; }
inline float getYOffset() const { return m_yOffset; }
EVENT_CLASS_TYPE(MouseScroll)
EVENT_CLASS_CATEGORY(InputEventCategory | MouseEventCategory)
private:
float m_xOffset;
float m_yOffset;
};
} // namespace Inferno

74
src/inferno/io/file.cpp
Unescape View File

@ -7,42 +7,42 @@
namespace Inferno {
std::shared_ptr<char[]> File::raw(const std::string& path)
{
// Create input stream object and open file
std::ifstream file(path);
VERIFY(file.is_open(), "File could not open '{}'", path);
// Get length of the file
int32_t length = File::length(path, file);
// Allocate memory filled with zeros
auto buffer = std::shared_ptr<char[]>(new char[length + 1]);
// Fill buffer with file contents
file.read(buffer.get(), length);
file.close();
// Null termination
buffer[length] = '\0';
return buffer;
}
std::string File::read(const std::string &path)
{
// Create string from the buffer and return
return std::string(raw(path).get());
}
int32_t File::length(const std::string& path, std::ifstream& file)
{
file.seekg(0, std::ios::end);
int32_t length = file.tellg();
file.seekg(0, std::ios::beg);
VERIFY(length != -1, "File could not determine length '{}'", path);
return length;
}
std::shared_ptr<char[]> File::raw(const std::string& path)
{
// Create input stream object and open file
std::ifstream file(path);
VERIFY(file.is_open(), "File could not open '{}'", path);
// Get length of the file
int32_t length = File::length(path, file);
// Allocate memory filled with zeros
auto buffer = std::shared_ptr<char[]>(new char[length + 1]);
// Fill buffer with file contents
file.read(buffer.get(), length);
file.close();
// Null termination
buffer[length] = '\0';
return buffer;
}
std::string File::read(const std::string& path)
{
// Create string from the buffer and return
return std::string(raw(path).get());
}
int32_t File::length(const std::string& path, std::ifstream& file)
{
file.seekg(0, std::ios::end);
int32_t length = file.tellg();
file.seekg(0, std::ios::beg);
VERIFY(length != -1, "File could not determine length '{}'", path);
return length;
}
} // namespace Inferno

88
src/inferno/io/file.h
Unescape View File

@ -11,52 +11,52 @@
namespace Inferno {
class File {
public:
static std::shared_ptr<char[]> raw(const std::string& path);
static std::string read(const std::string& path);
static int32_t length(const std::string& path, std::ifstream& file);
template<typename T>
static bool ioRead(T* t, const std::string& path)
{
std::ifstream file(path);
VERIFY(file.is_open(), "File could not open '{}'", path);
if (!file.is_open()) {
return false;
}
try {
file >> *t;
}
catch (...) {
return false;
}
return true;
class File {
public:
static std::shared_ptr<char[]> raw(const std::string& path);
static std::string read(const std::string& path);
static int32_t length(const std::string& path, std::ifstream& file);
template<typename T>
static bool ioRead(T* t, const std::string& path)
{
std::ifstream file(path);
VERIFY(file.is_open(), "File could not open '{}'", path);
if (!file.is_open()) {
return false;
}
template<typename T>
static bool ioWrite(T* t, const std::string& path)
{
std::ofstream file (path);
VERIFY(file.is_open(), "File could not open! {}", path);
if (!file.is_open()) {
return false;
}
try {
// Write file with single tabs, nicely formatted
file << std::setfill ('\t') << std::setw(1) << *t << std::endl;
}
catch (...) {
return false;
}
return true;
try {
file >> *t;
}
};
catch (...) {
return false;
}
return true;
}
template<typename T>
static bool ioWrite(T* t, const std::string& path)
{
std::ofstream file(path);
VERIFY(file.is_open(), "File could not open! {}", path);
if (!file.is_open()) {
return false;
}
try {
// Write file with single tabs, nicely formatted
file << std::setfill('\t') << std::setw(1) << *t << std::endl;
}
catch (...) {
return false;
}
return true;
}
};
} // namespace Inferno

134
src/inferno/io/gltffile.cpp
Unescape View File

@ -12,93 +12,93 @@
namespace Inferno {
std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> GltfFile::read(const std::string& path)
{
std::string extension = path.substr(path.find_first_of("."));
if (extension.compare(".glb") == 0) {
return glb(path);
}
else if (extension.compare(".gltf") == 0) {
return { File::raw(path), nullptr };
}
VERIFY(false, "GltfFile unknown file extension!");
return {};
std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> GltfFile::read(const std::string& path)
{
std::string extension = path.substr(path.find_first_of("."));
if (extension.compare(".glb") == 0) {
return glb(path);
}
else if (extension.compare(".gltf") == 0) {
return { File::raw(path), nullptr };
}
std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> GltfFile::glb(const std::string& path)
{
// Create input stream object and open file
std::ifstream glb(path, std::ios::in | std::ios::binary);
VERIFY(glb.is_open(), "GltfFile could not open '{}'", path);
VERIFY(false, "GltfFile unknown file extension!");
return {};
}
constexpr uint32_t size = 4;
constexpr uint32_t header = 12;
constexpr uint32_t json = 27; // Minimum valid glTF has an asset property with version specifier
std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> GltfFile::glb(const std::string& path)
{
// Create input stream object and open file
std::ifstream glb(path, std::ios::in | std::ios::binary);
VERIFY(glb.is_open(), "GltfFile could not open '{}'", path);
// Get the actual length of the file
uint32_t length = static_cast<uint32_t>(File::length(path, glb));
VERIFY(length > header + json, "GltfFile too small to be valid '{}'", path);
constexpr uint32_t size = 4;
constexpr uint32_t header = 12;
constexpr uint32_t json = 27; // Minimum valid glTF has an asset property with version specifier
// Read header
// Get the actual length of the file
uint32_t length = static_cast<uint32_t>(File::length(path, glb));
VERIFY(length > header + json, "GltfFile too small to be valid '{}'", path);
char magic[size];
char version[size];
char fileLength[size];
// Read header
glb.read(magic, size);
glb.seekg(size * 1);
glb.read(version, size);
glb.seekg(size * 2);
glb.read(fileLength, size);
char magic[size];
char version[size];
char fileLength[size];
// Validate header
glb.read(magic, size);
glb.seekg(size * 1);
glb.read(version, size);
glb.seekg(size * 2);
glb.read(fileLength, size);
uint32_t magicInt = *reinterpret_cast<uint32_t*>(magic);
VERIFY(magicInt == 0x46546c67, "Gltf invalid header magic '{}'", magic);
// Validate header
uint32_t versionInt = *reinterpret_cast<uint32_t*>(version);
VERIFY(versionInt == 2, "Gltf unsupported version '{}'", versionInt);
uint32_t magicInt = *reinterpret_cast<uint32_t*>(magic);
VERIFY(magicInt == 0x46546c67, "Gltf invalid header magic '{}'", magic);
uint32_t fileLengthInt = *reinterpret_cast<uint32_t*>(fileLength);
VERIFY(fileLengthInt == length, "Gltf file and reported byte size mismatch '{}' '{}'", length, fileLengthInt);
uint32_t versionInt = *reinterpret_cast<uint32_t*>(version);
VERIFY(versionInt == 2, "Gltf unsupported version '{}'", versionInt);
// Read JSON data
auto jsonChunk = readChunk(glb, header, 0x4e4f534a);
VERIFY(jsonChunk.second >= json, "Gltf file invalid JSON content length '{}'", jsonChunk.second);
uint32_t fileLengthInt = *reinterpret_cast<uint32_t*>(fileLength);
VERIFY(fileLengthInt == length, "Gltf file and reported byte size mismatch '{}' '{}'", length, fileLengthInt);
// Read binary data
auto binaryChunk = readChunk(glb, header + size * 2 + jsonChunk.second, 0x004e4942);
// Read JSON data
auto jsonChunk = readChunk(glb, header, 0x4e4f534a);
VERIFY(jsonChunk.second >= json, "Gltf file invalid JSON content length '{}'", jsonChunk.second);
glb.close();
// Read binary data
auto binaryChunk = readChunk(glb, header + size * 2 + jsonChunk.second, 0x004e4942);
return { jsonChunk.first, binaryChunk.first };
}
glb.close();
std::pair<std::shared_ptr<char[]>, uint32_t> GltfFile::readChunk(std::ifstream& ifstream, uint32_t offset, uint32_t type)
{
constexpr uint32_t size = 4;
return { jsonChunk.first, binaryChunk.first };
}
char chunkLength[size];
char chunkType[size];
std::pair<std::shared_ptr<char[]>, uint32_t> GltfFile::readChunk(std::ifstream& ifstream, uint32_t offset, uint32_t type)
{
constexpr uint32_t size = 4;
ifstream.seekg(offset);
ifstream.read(chunkLength, size);
ifstream.seekg(offset + size * 1);
ifstream.read(chunkType, size);
char chunkLength[size];
char chunkType[size];
uint32_t chunkTypeInt = *reinterpret_cast<uint32_t*>(chunkType);
VERIFY(chunkTypeInt == type, "Gltf invalid chunk type '{}' != '{}'", chunkType, intToHex(type));
ifstream.seekg(offset);
ifstream.read(chunkLength, size);
ifstream.seekg(offset + size * 1);
ifstream.read(chunkType, size);
uint32_t chunkLengthInt = *reinterpret_cast<uint32_t*>(chunkLength);
// Allocate memory filled with zeros
std::shared_ptr<char[]> chunkData(new char[chunkLengthInt + 1]);
ifstream.seekg(offset + size * 2);
ifstream.read(chunkData.get(), chunkLengthInt);
chunkData.get()[chunkLengthInt] = '\0';
uint32_t chunkTypeInt = *reinterpret_cast<uint32_t*>(chunkType);
VERIFY(chunkTypeInt == type, "Gltf invalid chunk type '{}' != '{}'", chunkType, intToHex(type));
return { chunkData, chunkLengthInt };
}
uint32_t chunkLengthInt = *reinterpret_cast<uint32_t*>(chunkLength);
// Allocate memory filled with zeros
std::shared_ptr<char[]> chunkData(new char[chunkLengthInt + 1]);
ifstream.seekg(offset + size * 2);
ifstream.read(chunkData.get(), chunkLengthInt);
chunkData.get()[chunkLengthInt] = '\0';
return { chunkData, chunkLengthInt };
}
} // namespace Inferno

14
src/inferno/io/gltffile.h
Unescape View File

@ -7,13 +7,13 @@
namespace Inferno {
class GltfFile {
public:
static std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> read(const std::string& path);
class GltfFile {
public:
static std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> read(const std::string& path);
private:
static std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> glb(const std::string& path);
static std::pair<std::shared_ptr<char[]>, uint32_t> readChunk(std::ifstream& ifstream, uint32_t offset, uint32_t type);
};
private:
static std::pair<std::shared_ptr<char[]>, std::shared_ptr<char[]>> glb(const std::string& path);
static std::pair<std::shared_ptr<char[]>, uint32_t> readChunk(std::ifstream& ifstream, uint32_t offset, uint32_t type);
};
} // namespace Inferno

136
src/inferno/io/input.cpp
Unescape View File

@ -8,85 +8,85 @@
namespace Inferno {
bool Input::m_firstMousePos = true;
float Input::m_xPosLast = 0.0f;
float Input::m_yPosLast = 0.0f;
float Input::m_xOffset = 0.0f;
float Input::m_yOffset = 0.0f;
void Input::initialize()
{
// Set cursor in the middle of the screen
m_xPosLast = Application::the().getWindow().getWidth() / 2.0f;
m_yPosLast = Application::the().getWindow().getHeight() / 2.0f;
info() << "Input initialized";
}
bool Input::m_firstMousePos = true;
float Input::m_xPosLast = 0.0f;
float Input::m_yPosLast = 0.0f;
float Input::m_xOffset = 0.0f;
float Input::m_yOffset = 0.0f;
void Input::initialize()
{
// Set cursor in the middle of the screen
m_xPosLast = Application::the().getWindow().getWidth() / 2.0f;
m_yPosLast = Application::the().getWindow().getHeight() / 2.0f;
info() << "Input initialized";
}
void Input::update()
{
// Stop infinite mouse movement
m_xOffset = 0.0f;
m_yOffset = 0.0f;
}
void Input::update()
{
// Stop infinite mouse movement
m_xOffset = 0.0f;
m_yOffset = 0.0f;
}
bool Input::onMousePosition(MousePositionEvent& e)
{
// Prevent weird jump on first cursor window enter
if(m_firstMousePos) {
m_firstMousePos = false;
m_xPosLast = e.getXPos();
m_yPosLast = e.getYPos();
}
m_xOffset = e.getXPos() - m_xPosLast;
// Reversed since y-coordinates range from bottom to top
m_yOffset = m_yPosLast - e.getYPos();
bool Input::onMousePosition(MousePositionEvent& e)
{
// Prevent weird jump on first cursor window enter
if (m_firstMousePos) {
m_firstMousePos = false;
m_xPosLast = e.getXPos();
m_yPosLast = e.getYPos();
return true;
}
bool Input::isKeyPressed(int key)
{
GLFWwindow* w = Application::the().getWindow().getWindow();
return glfwGetKey(w, key) == GLFW_PRESS;
}
m_xOffset = e.getXPos() - m_xPosLast;
// Reversed since y-coordinates range from bottom to top
m_yOffset = m_yPosLast - e.getYPos();
m_xPosLast = e.getXPos();
m_yPosLast = e.getYPos();
bool Input::isMouseButtonPressed(int button)
{
GLFWwindow* w = Application::the().getWindow().getWindow();
return glfwGetMouseButton(w, button) == GLFW_PRESS;
}
return true;
}
std::pair<float, float> Input::getMousePosition()
{
GLFWwindow* w = Application::the().getWindow().getWindow();
double xPos;
double yPos;
glfwGetCursorPos(w, &xPos, &yPos);
return { (float)xPos, (float)yPos };
}
bool Input::isKeyPressed(int key)
{
GLFWwindow* w = Application::the().getWindow().getWindow();
return glfwGetKey(w, key) == GLFW_PRESS;
}
float Input::getMouseX()
{
return getMousePosition().first;
}
bool Input::isMouseButtonPressed(int button)
{
GLFWwindow* w = Application::the().getWindow().getWindow();
return glfwGetMouseButton(w, button) == GLFW_PRESS;
}
float Input::getMouseY()
{
return getMousePosition().second;
}
std::pair<float, float> Input::getMousePosition()
{
GLFWwindow* w = Application::the().getWindow().getWindow();
double xPos;
double yPos;
glfwGetCursorPos(w, &xPos, &yPos);
return { (float)xPos, (float)yPos };
}
const char* Input::getKeyName(int key)
{
return glfwGetKeyName(key, getKeyScancode(key));
}
float Input::getMouseX()
{
return getMousePosition().first;
}
int Input::getKeyScancode(int key)
{
return glfwGetKeyScancode(key);
}
float Input::getMouseY()
{
return getMousePosition().second;
}
const char* Input::getKeyName(int key)
{
return glfwGetKeyName(key, getKeyScancode(key));
}
int Input::getKeyScancode(int key)
{
return glfwGetKeyScancode(key);
}
} // namespace Inferno

56
src/inferno/io/input.h
Unescape View File

@ -4,33 +4,33 @@
namespace Inferno {
class MousePositionEvent;
class Input {
public:
static void initialize();
static void update();
static bool onMousePosition(MousePositionEvent& e);
static bool isKeyPressed(int key);
static bool isMouseButtonPressed(int button);
static std::pair<float, float> getMousePosition();
static float getMouseX();
static float getMouseY();
static const char* getKeyName(int key);
static int getKeyScancode(int key);
static inline float getXOffset() { return m_xOffset; }
static inline float getYOffset() { return m_yOffset; }
private:
static bool m_firstMousePos;
static float m_xPosLast;
static float m_yPosLast;
static float m_xOffset;
static float m_yOffset;
};
class MousePositionEvent;
class Input {
public:
static void initialize();
static void update();
static bool onMousePosition(MousePositionEvent& e);
static bool isKeyPressed(int key);
static bool isMouseButtonPressed(int button);
static std::pair<float, float> getMousePosition();
static float getMouseX();
static float getMouseY();
static const char* getKeyName(int key);
static int getKeyScancode(int key);
static inline float getXOffset() { return m_xOffset; }
static inline float getYOffset() { return m_yOffset; }
private:
static bool m_firstMousePos;
static float m_xPosLast;
static float m_yPosLast;
static float m_xOffset;
static float m_yOffset;
};
} // namespace Inferno

526
src/inferno/io/log.cpp
Unescape View File

@ -11,311 +11,311 @@
namespace Inferno {
BufferedLogStream::~BufferedLogStream()
{
// Free buffer memory
if (m_capacity > sizeof(m_buffer.stack)) {
free(m_buffer.heap);
}
BufferedLogStream::~BufferedLogStream()
{
// Free buffer memory
if (m_capacity > sizeof(m_buffer.stack)) {
free(m_buffer.heap);
}
}
void BufferedLogStream::grow(size_t bytes) const
{
// Bitwise & ~ example, we use 127 as binary starts at 0
// 0b001111111 127 ~
// 0b100000100 260 &
// -----------
// 0b110000000 384
// 0b100000100 260 &
// -----------
// 0b100000000 256
// Buffer is increased in chunks of 128 bytes
size_t newCapacity = (m_count + bytes + BUFFER_SIZE - 1) & ~(BUFFER_SIZE - 1);
unsigned char* newBuffer = static_cast<unsigned char*>(malloc(newCapacity));
// Copy the non-heap data into the new buffer
if (m_capacity <= sizeof(m_buffer.stack)) {
memcpy(newBuffer, m_buffer.stack, m_count);
}
// Copy old heap-buffer data into the new buffer, free old heap-buffer
else if (m_buffer.heap) {
memcpy(newBuffer, m_buffer.heap, m_count);
free(m_buffer.heap);
}
m_buffer.heap = newBuffer;
m_capacity = newCapacity;
}
// -----------------------------------------
void BufferedLogStream::grow(size_t bytes) const
{
// Bitwise & ~ example, we use 127 as binary starts at 0
// 0b001111111 127 ~
// 0b100000100 260 &
// -----------
// 0b110000000 384
// 0b100000100 260 &
// -----------
// 0b100000000 256
DebugLogStream::~DebugLogStream()
{
if (m_type != Log::None) {
const char* clear = "\033[0m";
write(clear, strlen(clear));
}
// Buffer is increased in chunks of 128 bytes
size_t newCapacity = (m_count + bytes + BUFFER_SIZE - 1) & ~(BUFFER_SIZE - 1);
if (m_newline) {
char newline = '\n';
write(&newline, 1);
}
unsigned char* newBuffer = static_cast<unsigned char*>(malloc(newCapacity));
fwrite(buffer(), 1, count(), stdout);
// Copy the non-heap data into the new buffer
if (m_capacity <= sizeof(m_buffer.stack)) {
memcpy(newBuffer, m_buffer.stack, m_count);
}
void DebugLogStream::color() const
{
const char* color = "";
if (m_type == Log::Info) {
color = "\x1B[34m";
}
else if (m_type == Log::Warn) {
color = "\x1B[33m";
}
else if (m_type == Log::Danger) {
color = "\x1B[31m";
}
else if (m_type == Log::Success) {
color = "\x1B[32m";
}
else if (m_type == Log::Comment) {
color = "\x1B[37m";
}
write(color, strlen(color));
// Copy old heap-buffer data into the new buffer, free old heap-buffer
else if (m_buffer.heap) {
memcpy(newBuffer, m_buffer.heap, m_count);
free(m_buffer.heap);
}
// -----------------------------------------
StringLogStream::~StringLogStream()
{
char terminator = '\0';
write(&terminator, 1);
*m_fill = std::string(reinterpret_cast<char*>(buffer()));
}
m_buffer.heap = newBuffer;
m_capacity = newCapacity;
}
// -----------------------------------------
const LogStream& operator<<(const LogStream& stream, const char* value)
{
if (value == nullptr) {
stream.write("(null)", 6);
return stream;
}
stream.write(value, strlen(value));
return stream;
}
const LogStream& operator<<(const LogStream& stream, const unsigned char* value)
{
if (value == nullptr) {
stream.write("(null)", 6);
return stream;
}
stream.write(value, strlen((const char*)value));
return stream;
}
const LogStream& operator<<(const LogStream& stream, const std::string& value)
{
stream.write(value.c_str(), value.length());
return stream;
}
const LogStream& operator<<(const LogStream& stream, const std::string_view& value)
{
stream.write(value.data(), value.length());
return stream;
}
const LogStream& operator<<(const LogStream& stream, char value)
{
stream.write(&value, 1);
return stream;
}
const LogStream& operator<<(const LogStream& stream, unsigned char value)
{
stream.write(&value, 1);
return stream;
}
const LogStream& operator<<(const LogStream& stream, int value)
{
// return stream << std::to_string(value);
char buffer[32];
snprintf(buffer, sizeof(buffer), "%d", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, long int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%ld", value);
return stream << buffer;
DebugLogStream::~DebugLogStream()
{
if (m_type != Log::None) {
const char* clear = "\033[0m";
write(clear, strlen(clear));
}
const LogStream& operator<<(const LogStream& stream, long long int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%lld", value);
return stream << buffer;
if (m_newline) {
char newline = '\n';
write(&newline, 1);
}
const LogStream& operator<<(const LogStream& stream, unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%u", value);
return stream << buffer;
}
fwrite(buffer(), 1, count(), stdout);
}
const LogStream& operator<<(const LogStream& stream, long unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%lu", value);
return stream << buffer;
}
void DebugLogStream::color() const
{
const char* color = "";
const LogStream& operator<<(const LogStream& stream, long long unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%llu", value);
return stream << buffer;
if (m_type == Log::Info) {
color = "\x1B[34m";
}
const LogStream& operator<<(const LogStream& stream, double value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%.4f", value);
return stream << buffer;
else if (m_type == Log::Warn) {
color = "\x1B[33m";
}
const LogStream& operator<<(const LogStream& stream, float value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%.4f", value);
return stream << buffer;
else if (m_type == Log::Danger) {
color = "\x1B[31m";
}
const LogStream& operator<<(const LogStream& stream, const void* value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%p", value);
return stream << buffer;
else if (m_type == Log::Success) {
color = "\x1B[32m";
}
const LogStream& operator<<(const LogStream& stream, bool value)
{
return stream << (value ? "true": "false");
else if (m_type == Log::Comment) {
color = "\x1B[37m";
}
const LogStream& operator<<(const LogStream& stream, Log value)
{
switch (value) {
case Log::None:
return stream << "Log";
case Log::Info:
return stream << "Info";
case Log::Warn:
return stream << "Warn";
case Log::Danger:
return stream << "Danger";
case Log::Success:
return stream << "Success";
case Log::Comment:
return stream << "Comment";
default:
VERIFY_NOT_REACHED();
return stream;
}
}
write(color, strlen(color));
}
// -----------------------------------------
DebugLogStream dbg()
{
return {};
}
DebugLogStream dbg(bool newline)
{
return DebugLogStream(newline);
}
DebugLogStream info()
{
return DebugLogStream(Log::Info);
}
DebugLogStream warn()
{
return DebugLogStream(Log::Warn);
}
StringLogStream::~StringLogStream()
{
char terminator = '\0';
write(&terminator, 1);
*m_fill = std::string(reinterpret_cast<char*>(buffer()));
}
DebugLogStream danger()
{
return DebugLogStream(Log::Danger);
}
DebugLogStream success()
{
return DebugLogStream(Log::Success);
}
// -----------------------------------------
DebugLogStream comment()
{
return DebugLogStream(Log::Comment);
const LogStream& operator<<(const LogStream& stream, const char* value)
{
if (value == nullptr) {
stream.write("(null)", 6);
return stream;
}
DebugLogStream info(bool newline)
{
return DebugLogStream(Log::Info, newline);
}
stream.write(value, strlen(value));
return stream;
}
DebugLogStream warn(bool newline)
{
return DebugLogStream(Log::Warn, newline);
const LogStream& operator<<(const LogStream& stream, const unsigned char* value)
{
if (value == nullptr) {
stream.write("(null)", 6);
return stream;
}
DebugLogStream danger(bool newline)
{
return DebugLogStream(Log::Danger, newline);
stream.write(value, strlen((const char*)value));
return stream;
}
const LogStream& operator<<(const LogStream& stream, const std::string& value)
{
stream.write(value.c_str(), value.length());
return stream;
}
const LogStream& operator<<(const LogStream& stream, const std::string_view& value)
{
stream.write(value.data(), value.length());
return stream;
}
const LogStream& operator<<(const LogStream& stream, char value)
{
stream.write(&value, 1);
return stream;
}
const LogStream& operator<<(const LogStream& stream, unsigned char value)
{
stream.write(&value, 1);
return stream;
}
const LogStream& operator<<(const LogStream& stream, int value)
{
// return stream << std::to_string(value);
char buffer[32];
snprintf(buffer, sizeof(buffer), "%d", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, long int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%ld", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, long long int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%lld", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%u", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, long unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%lu", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, long long unsigned int value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%llu", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, double value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%.4f", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, float value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%.4f", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, const void* value)
{
char buffer[32];
snprintf(buffer, sizeof(buffer), "%p", value);
return stream << buffer;
}
const LogStream& operator<<(const LogStream& stream, bool value)
{
return stream << (value ? "true" : "false");
}
const LogStream& operator<<(const LogStream& stream, Log value)
{
switch (value) {
case Log::None:
return stream << "Log";
case Log::Info:
return stream << "Info";
case Log::Warn:
return stream << "Warn";
case Log::Danger:
return stream << "Danger";
case Log::Success:
return stream << "Success";
case Log::Comment:
return stream << "Comment";
default:
VERIFY_NOT_REACHED();
return stream;
}
}
DebugLogStream success(bool newline)
{
return DebugLogStream(Log::Success, newline);
}
// -----------------------------------------
DebugLogStream comment(bool newline)
{
return DebugLogStream(Log::Comment, newline);
}
DebugLogStream dbg()
{
return {};
}
DebugLogStream dbg(bool newline)
{
return DebugLogStream(newline);
}
DebugLogStream info()
{
return DebugLogStream(Log::Info);
}
DebugLogStream warn()
{
return DebugLogStream(Log::Warn);
}
DebugLogStream danger()
{
return DebugLogStream(Log::Danger);
}
DebugLogStream success()
{
return DebugLogStream(Log::Success);
}
DebugLogStream comment()
{
return DebugLogStream(Log::Comment);
}
DebugLogStream info(bool newline)
{
return DebugLogStream(Log::Info, newline);
}
DebugLogStream warn(bool newline)
{
return DebugLogStream(Log::Warn, newline);
}
DebugLogStream danger(bool newline)
{
return DebugLogStream(Log::Danger, newline);
}
DebugLogStream success(bool newline)
{
return DebugLogStream(Log::Success, newline);
}
DebugLogStream comment(bool newline)
{
return DebugLogStream(Log::Comment, newline);
}
// -----------------------------------------
void dbgln(Log type, bool newline)
{
(void)type, DebugLogStream(newline);
}
void dbgln(Log type, bool newline)
{
(void)type, DebugLogStream(newline);
}
void dbgln(Log type, bool newline, const char* format)
{
DebugLogStream(type, newline) << format;
}
void dbgln(Log type, bool newline, const char* format)
{
DebugLogStream(type, newline) << format;
}
// -----------------------------------------
StringLogStream str(std::string* fill)
{
return StringLogStream(fill);
}
StringLogStream str(std::string* fill)
{
return StringLogStream(fill);
}
} // namespace Inferno

264
src/inferno/io/log.h
Unescape View File

@ -10,148 +10,164 @@
namespace Inferno {
enum class Log {
None,
Info,
Warn,
Danger,
Success,
Comment,
};
enum class Log {
None,
Info,
Warn,
Danger,
Success,
Comment,
};
// -----------------------------------------
class LogStream {
public:
LogStream() {}
virtual ~LogStream() {}
class LogStream {
public:
LogStream() {}
virtual ~LogStream() {}
virtual void write(const char* characters, int length) const = 0;
virtual void write(const unsigned char* characters, int length) const = 0;
};
virtual void write(const char* characters, int length) const = 0;
virtual void write(const unsigned char* characters, int length) const = 0;
};
// -----------------------------------------
class BufferedLogStream : public LogStream {
public:
BufferedLogStream() {}
virtual ~BufferedLogStream();
class BufferedLogStream : public LogStream {
public:
BufferedLogStream() {}
virtual ~BufferedLogStream();
inline virtual void write(const char* characters, int length) const override
{
write(reinterpret_cast<const unsigned char*>(characters), length);
}
inline virtual void write(const unsigned char* characters, int length) const override
{
size_t newSize = m_count + length;
if (newSize > m_capacity) {
grow(length);
}
inline virtual void write(const char* characters, int length) const override
{
write(reinterpret_cast<const unsigned char*>(characters), length);
}
// Append to buffer
memcpy(buffer() + m_count, characters, length);
inline virtual void write(const unsigned char* characters, int length) const override
{
size_t newSize = m_count + length;
m_count = newSize;
if (newSize > m_capacity) {
grow(length);
}
protected:
inline unsigned char* buffer() const
{
if (m_capacity <= sizeof(m_buffer.stack)) {
return m_buffer.stack;
}
// Append to buffer
memcpy(buffer() + m_count, characters, length);
return m_buffer.heap;
m_count = newSize;
}
protected:
inline unsigned char* buffer() const
{
if (m_capacity <= sizeof(m_buffer.stack)) {
return m_buffer.stack;
}
inline bool empty() const { return m_count == 0; }
inline size_t count() const { return m_count; }
return m_buffer.heap;
}
inline bool empty() const { return m_count == 0; }
inline size_t count() const { return m_count; }
private:
void grow(size_t bytes) const;
private:
void grow(size_t bytes) const;
mutable size_t m_count { 0 };
mutable size_t m_capacity { BUFFER_SIZE };
union {
mutable unsigned char* heap { nullptr };
mutable unsigned char stack[BUFFER_SIZE];
} m_buffer;
};
mutable size_t m_count { 0 };
mutable size_t m_capacity { BUFFER_SIZE };
union {
mutable unsigned char* heap { nullptr };
mutable unsigned char stack[BUFFER_SIZE];
} m_buffer;
};
// -----------------------------------------
class DebugLogStream final : public BufferedLogStream {
public:
DebugLogStream()
: m_newline(true), m_type(Log::None) {}
DebugLogStream(bool newline)
: m_newline(newline), m_type(Log::None) {}
DebugLogStream(Log type)
: m_newline(true), m_type(type) { color(); }
DebugLogStream(Log type, bool newline)
: m_newline(newline), m_type(type) { color(); }
virtual ~DebugLogStream() override;
void color() const;
private:
bool m_newline;
Log m_type;
};
class DebugLogStream final : public BufferedLogStream {
public:
DebugLogStream()
: m_newline(true)
, m_type(Log::None)
{
}
DebugLogStream(bool newline)
: m_newline(newline)
, m_type(Log::None)
{
}
DebugLogStream(Log type)
: m_newline(true)
, m_type(type)
{
color();
}
DebugLogStream(Log type, bool newline)
: m_newline(newline)
, m_type(type)
{
color();
}
virtual ~DebugLogStream() override;
void color() const;
private:
bool m_newline;
Log m_type;
};
// -----------------------------------------
class StringLogStream final : public BufferedLogStream {
public:
StringLogStream(std::string* fill)
: m_fill(fill) {}
virtual ~StringLogStream() override;
class StringLogStream final : public BufferedLogStream {
public:
StringLogStream(std::string* fill)
: m_fill(fill)
{
}
virtual ~StringLogStream() override;
private:
std::string* m_fill { nullptr };
};
private:
std::string* m_fill { nullptr };
};
// -----------------------------------------
const LogStream& operator<<(const LogStream& stream, const char* value);
const LogStream& operator<<(const LogStream& stream, const unsigned char* value);
const LogStream& operator<<(const LogStream& stream, const std::string& value);
const LogStream& operator<<(const LogStream& stream, const std::string_view& value);
const LogStream& operator<<(const LogStream& stream, char value);
const LogStream& operator<<(const LogStream& stream, unsigned char value);
const LogStream& operator<<(const LogStream& stream, int value);
const LogStream& operator<<(const LogStream& stream, long int value);
const LogStream& operator<<(const LogStream& stream, long long int value);
const LogStream& operator<<(const LogStream& stream, unsigned int value);
const LogStream& operator<<(const LogStream& stream, long unsigned int value);
const LogStream& operator<<(const LogStream& stream, long long unsigned int value);
const LogStream& operator<<(const LogStream& stream, double value);
const LogStream& operator<<(const LogStream& stream, float value);
const LogStream& operator<<(const LogStream& stream, const void* value);
const LogStream& operator<<(const LogStream& stream, bool value);
const LogStream& operator<<(const LogStream& stream, Log value);
const LogStream& operator<<(const LogStream& stream, const char* value);
const LogStream& operator<<(const LogStream& stream, const unsigned char* value);
const LogStream& operator<<(const LogStream& stream, const std::string& value);
const LogStream& operator<<(const LogStream& stream, const std::string_view& value);
const LogStream& operator<<(const LogStream& stream, char value);
const LogStream& operator<<(const LogStream& stream, unsigned char value);
const LogStream& operator<<(const LogStream& stream, int value);
const LogStream& operator<<(const LogStream& stream, long int value);
const LogStream& operator<<(const LogStream& stream, long long int value);
const LogStream& operator<<(const LogStream& stream, unsigned int value);
const LogStream& operator<<(const LogStream& stream, long unsigned int value);
const LogStream& operator<<(const LogStream& stream, long long unsigned int value);
const LogStream& operator<<(const LogStream& stream, double value);
const LogStream& operator<<(const LogStream& stream, float value);
const LogStream& operator<<(const LogStream& stream, const void* value);
const LogStream& operator<<(const LogStream& stream, bool value);
const LogStream& operator<<(const LogStream& stream, Log value);
// -----------------------------------------
DebugLogStream dbg();
DebugLogStream info();
DebugLogStream warn();
DebugLogStream danger();
DebugLogStream success();
DebugLogStream comment();
DebugLogStream dbg();
DebugLogStream info();
DebugLogStream warn();
DebugLogStream danger();
DebugLogStream success();
DebugLogStream comment();
DebugLogStream dbg(bool newline);
DebugLogStream info(bool newline);
DebugLogStream warn(bool newline);
DebugLogStream danger(bool newline);
DebugLogStream success(bool newline);
DebugLogStream comment(bool newline);
DebugLogStream dbg(bool newline);
DebugLogStream info(bool newline);
DebugLogStream warn(bool newline);
DebugLogStream danger(bool newline);
DebugLogStream success(bool newline);
DebugLogStream comment(bool newline);
// -----------------------------------------
// clang-format off
// clang-format off
template<typename... P> void dbgln(const char* format, P&&... parameters) { dbgln(Log::None, true, format, std::forward<P>(parameters)...); }
template<typename... P> void infoln(const char* format, P&&... parameters) { dbgln(Log::Info, true, format, std::forward<P>(parameters)...); }
template<typename... P> void warnln(const char* format, P&&... parameters) { dbgln(Log::Warn, true, format, std::forward<P>(parameters)...); }
@ -193,32 +209,32 @@ namespace Inferno {
template<typename... P> void dangerln(bool newline, const std::string_view& format, P&&... parameters) { dbgln(Log::Danger, newline, format.data(), std::forward<P>(parameters)...); }
template<typename... P> void successln(bool newline, const std::string_view& format, P&&... parameters) { dbgln(Log::Success, newline, format.data(), std::forward<P>(parameters)...); }
template<typename... P> void commentln(bool newline, const std::string_view& format, P&&... parameters) { dbgln(Log::Comment, newline, format.data(), std::forward<P>(parameters)...); }
// clang-format on
// clang-format on
// -----------------------------------------
void dbgln(Log type, bool newline);
void dbgln(Log type, bool newline, const char* format);
void dbgln(Log type, bool newline);
void dbgln(Log type, bool newline, const char* format);
// https://en.cppreference.com/w/cpp/language/parameter_pack#Example
template<typename T, typename... P>
void dbgln(Log type, bool newline, const char* format, T value, P&&... parameters)
{
std::string_view view { format };
// https://en.cppreference.com/w/cpp/language/parameter_pack#Example
template<typename T, typename... P>
void dbgln(Log type, bool newline, const char* format, T value, P&&... parameters)
{
std::string_view view { format };
for(uint32_t i = 0; format[i] != '\0'; i++) {
for (uint32_t i = 0; format[i] != '\0'; i++) {
if (format[i] == '{' && format[i + 1] == '}') {
DebugLogStream(type, false) << view.substr(0, i) << value;
dbgln(type, newline, format + i + 2, parameters...);
return;
}
if (format[i] == '{' && format[i + 1] == '}') {
DebugLogStream(type, false) << view.substr(0, i) << value;
dbgln(type, newline, format + i + 2, parameters...);
return;
}
}
// possible c++17 improvent https://riptutorial.com/cplusplus/example/3208/iterating-over-a-parameter-pack
}
// possible c++17 improvent https://riptutorial.com/cplusplus/example/3208/iterating-over-a-parameter-pack
// -----------------------------------------
StringLogStream str(std::string* fill);
StringLogStream str(std::string* fill);
} // namespace Inferno

256
src/inferno/keycodes.cpp
Unescape View File

@ -8,136 +8,136 @@
namespace Inferno {
static std::unordered_map<std::string, int> keys ({
{ MAP_KEY(GLFW_KEY_UNKNOWN) },
{ MAP_KEY(GLFW_KEY_SPACE) },
{ MAP_KEY(GLFW_KEY_APOSTROPHE) },
{ MAP_KEY(GLFW_KEY_COMMA) },
{ MAP_KEY(GLFW_KEY_MINUS) },
{ MAP_KEY(GLFW_KEY_PERIOD) },
{ MAP_KEY(GLFW_KEY_SLASH) },
{ MAP_KEY(GLFW_KEY_0) },
{ MAP_KEY(GLFW_KEY_1) },
{ MAP_KEY(GLFW_KEY_2) },
{ MAP_KEY(GLFW_KEY_3) },
{ MAP_KEY(GLFW_KEY_4) },
{ MAP_KEY(GLFW_KEY_5) },
{ MAP_KEY(GLFW_KEY_6) },
{ MAP_KEY(GLFW_KEY_7) },
{ MAP_KEY(GLFW_KEY_8) },
{ MAP_KEY(GLFW_KEY_9) },
{ MAP_KEY(GLFW_KEY_SEMICOLON) },
{ MAP_KEY(GLFW_KEY_EQUAL) },
{ MAP_KEY(GLFW_KEY_A) },
{ MAP_KEY(GLFW_KEY_B) },
{ MAP_KEY(GLFW_KEY_C) },
{ MAP_KEY(GLFW_KEY_D) },
{ MAP_KEY(GLFW_KEY_E) },
{ MAP_KEY(GLFW_KEY_F) },
{ MAP_KEY(GLFW_KEY_G) },
{ MAP_KEY(GLFW_KEY_H) },
{ MAP_KEY(GLFW_KEY_I) },
{ MAP_KEY(GLFW_KEY_J) },
{ MAP_KEY(GLFW_KEY_K) },
{ MAP_KEY(GLFW_KEY_L) },
{ MAP_KEY(GLFW_KEY_M) },
{ MAP_KEY(GLFW_KEY_N) },
{ MAP_KEY(GLFW_KEY_O) },
{ MAP_KEY(GLFW_KEY_P) },
{ MAP_KEY(GLFW_KEY_Q) },
{ MAP_KEY(GLFW_KEY_R) },
{ MAP_KEY(GLFW_KEY_S) },
{ MAP_KEY(GLFW_KEY_T) },
{ MAP_KEY(GLFW_KEY_U) },
{ MAP_KEY(GLFW_KEY_V) },
{ MAP_KEY(GLFW_KEY_W) },
{ MAP_KEY(GLFW_KEY_X) },
{ MAP_KEY(GLFW_KEY_Y) },
{ MAP_KEY(GLFW_KEY_Z) },
{ MAP_KEY(GLFW_KEY_LEFT_BRACKET) },
{ MAP_KEY(GLFW_KEY_BACKSLASH) },
{ MAP_KEY(GLFW_KEY_RIGHT_BRACKET) },
{ MAP_KEY(GLFW_KEY_GRAVE_ACCENT) },
{ MAP_KEY(GLFW_KEY_WORLD_1) },
{ MAP_KEY(GLFW_KEY_WORLD_2) },
{ MAP_KEY(GLFW_KEY_ESCAPE) },
{ MAP_KEY(GLFW_KEY_ENTER) },
{ MAP_KEY(GLFW_KEY_TAB) },
{ MAP_KEY(GLFW_KEY_BACKSPACE) },
{ MAP_KEY(GLFW_KEY_INSERT) },
{ MAP_KEY(GLFW_KEY_DELETE) },
{ MAP_KEY(GLFW_KEY_RIGHT) },
{ MAP_KEY(GLFW_KEY_LEFT) },
{ MAP_KEY(GLFW_KEY_DOWN) },
{ MAP_KEY(GLFW_KEY_UP) },
{ MAP_KEY(GLFW_KEY_PAGE_UP) },
{ MAP_KEY(GLFW_KEY_PAGE_DOWN) },
{ MAP_KEY(GLFW_KEY_HOME) },
{ MAP_KEY(GLFW_KEY_END) },
{ MAP_KEY(GLFW_KEY_CAPS_LOCK) },
{ MAP_KEY(GLFW_KEY_SCROLL_LOCK) },
{ MAP_KEY(GLFW_KEY_NUM_LOCK) },
{ MAP_KEY(GLFW_KEY_PRINT_SCREEN) },
{ MAP_KEY(GLFW_KEY_PAUSE) },
{ MAP_KEY(GLFW_KEY_F1) },
{ MAP_KEY(GLFW_KEY_F2) },
{ MAP_KEY(GLFW_KEY_F3) },
{ MAP_KEY(GLFW_KEY_F4) },
{ MAP_KEY(GLFW_KEY_F5) },
{ MAP_KEY(GLFW_KEY_F6) },
{ MAP_KEY(GLFW_KEY_F7) },
{ MAP_KEY(GLFW_KEY_F8) },
{ MAP_KEY(GLFW_KEY_F9) },
{ MAP_KEY(GLFW_KEY_F10) },
{ MAP_KEY(GLFW_KEY_F11) },
{ MAP_KEY(GLFW_KEY_F12) },
{ MAP_KEY(GLFW_KEY_F13) },
{ MAP_KEY(GLFW_KEY_F14) },
{ MAP_KEY(GLFW_KEY_F15) },
{ MAP_KEY(GLFW_KEY_F16) },
{ MAP_KEY(GLFW_KEY_F17) },
{ MAP_KEY(GLFW_KEY_F18) },
{ MAP_KEY(GLFW_KEY_F19) },
{ MAP_KEY(GLFW_KEY_F20) },
{ MAP_KEY(GLFW_KEY_F21) },
{ MAP_KEY(GLFW_KEY_F22) },
{ MAP_KEY(GLFW_KEY_F23) },
{ MAP_KEY(GLFW_KEY_F24) },
{ MAP_KEY(GLFW_KEY_F25) },
{ MAP_KEY(GLFW_KEY_KP_0) },
{ MAP_KEY(GLFW_KEY_KP_1) },
{ MAP_KEY(GLFW_KEY_KP_2) },
{ MAP_KEY(GLFW_KEY_KP_3) },
{ MAP_KEY(GLFW_KEY_KP_4) },
{ MAP_KEY(GLFW_KEY_KP_5) },
{ MAP_KEY(GLFW_KEY_KP_6) },
{ MAP_KEY(GLFW_KEY_KP_7) },
{ MAP_KEY(GLFW_KEY_KP_8) },
{ MAP_KEY(GLFW_KEY_KP_9) },
{ MAP_KEY(GLFW_KEY_KP_DECIMAL) },
{ MAP_KEY(GLFW_KEY_KP_DIVIDE) },
{ MAP_KEY(GLFW_KEY_KP_MULTIPLY) },
{ MAP_KEY(GLFW_KEY_KP_SUBTRACT) },
{ MAP_KEY(GLFW_KEY_KP_ADD) },
{ MAP_KEY(GLFW_KEY_KP_ENTER) },
{ MAP_KEY(GLFW_KEY_KP_EQUAL) },
{ MAP_KEY(GLFW_KEY_LEFT_SHIFT) },
{ MAP_KEY(GLFW_KEY_LEFT_CONTROL) },
{ MAP_KEY(GLFW_KEY_LEFT_ALT) },
{ MAP_KEY(GLFW_KEY_LEFT_SUPER) },
{ MAP_KEY(GLFW_KEY_RIGHT_SHIFT) },
{ MAP_KEY(GLFW_KEY_RIGHT_CONTROL) },
{ MAP_KEY(GLFW_KEY_RIGHT_ALT) },
{ MAP_KEY(GLFW_KEY_RIGHT_SUPER) },
{ MAP_KEY(GLFW_KEY_MENU) },
});
static std::unordered_map<std::string, int> keys({
{ MAP_KEY(GLFW_KEY_UNKNOWN) },
{ MAP_KEY(GLFW_KEY_SPACE) },
{ MAP_KEY(GLFW_KEY_APOSTROPHE) },
{ MAP_KEY(GLFW_KEY_COMMA) },
{ MAP_KEY(GLFW_KEY_MINUS) },
{ MAP_KEY(GLFW_KEY_PERIOD) },
{ MAP_KEY(GLFW_KEY_SLASH) },
{ MAP_KEY(GLFW_KEY_0) },
{ MAP_KEY(GLFW_KEY_1) },
{ MAP_KEY(GLFW_KEY_2) },
{ MAP_KEY(GLFW_KEY_3) },
{ MAP_KEY(GLFW_KEY_4) },
{ MAP_KEY(GLFW_KEY_5) },
{ MAP_KEY(GLFW_KEY_6) },
{ MAP_KEY(GLFW_KEY_7) },
{ MAP_KEY(GLFW_KEY_8) },
{ MAP_KEY(GLFW_KEY_9) },
{ MAP_KEY(GLFW_KEY_SEMICOLON) },
{ MAP_KEY(GLFW_KEY_EQUAL) },
{ MAP_KEY(GLFW_KEY_A) },
{ MAP_KEY(GLFW_KEY_B) },
{ MAP_KEY(GLFW_KEY_C) },
{ MAP_KEY(GLFW_KEY_D) },
{ MAP_KEY(GLFW_KEY_E) },
{ MAP_KEY(GLFW_KEY_F) },
{ MAP_KEY(GLFW_KEY_G) },
{ MAP_KEY(GLFW_KEY_H) },
{ MAP_KEY(GLFW_KEY_I) },
{ MAP_KEY(GLFW_KEY_J) },
{ MAP_KEY(GLFW_KEY_K) },
{ MAP_KEY(GLFW_KEY_L) },
{ MAP_KEY(GLFW_KEY_M) },
{ MAP_KEY(GLFW_KEY_N) },
{ MAP_KEY(GLFW_KEY_O) },
{ MAP_KEY(GLFW_KEY_P) },
{ MAP_KEY(GLFW_KEY_Q) },
{ MAP_KEY(GLFW_KEY_R) },
{ MAP_KEY(GLFW_KEY_S) },
{ MAP_KEY(GLFW_KEY_T) },
{ MAP_KEY(GLFW_KEY_U) },
{ MAP_KEY(GLFW_KEY_V) },
{ MAP_KEY(GLFW_KEY_W) },
{ MAP_KEY(GLFW_KEY_X) },
{ MAP_KEY(GLFW_KEY_Y) },
{ MAP_KEY(GLFW_KEY_Z) },
{ MAP_KEY(GLFW_KEY_LEFT_BRACKET) },
{ MAP_KEY(GLFW_KEY_BACKSLASH) },
{ MAP_KEY(GLFW_KEY_RIGHT_BRACKET) },
{ MAP_KEY(GLFW_KEY_GRAVE_ACCENT) },
{ MAP_KEY(GLFW_KEY_WORLD_1) },
{ MAP_KEY(GLFW_KEY_WORLD_2) },
{ MAP_KEY(GLFW_KEY_ESCAPE) },
{ MAP_KEY(GLFW_KEY_ENTER) },
{ MAP_KEY(GLFW_KEY_TAB) },
{ MAP_KEY(GLFW_KEY_BACKSPACE) },
{ MAP_KEY(GLFW_KEY_INSERT) },
{ MAP_KEY(GLFW_KEY_DELETE) },
{ MAP_KEY(GLFW_KEY_RIGHT) },
{ MAP_KEY(GLFW_KEY_LEFT) },
{ MAP_KEY(GLFW_KEY_DOWN) },
{ MAP_KEY(GLFW_KEY_UP) },
{ MAP_KEY(GLFW_KEY_PAGE_UP) },
{ MAP_KEY(GLFW_KEY_PAGE_DOWN) },
{ MAP_KEY(GLFW_KEY_HOME) },
{ MAP_KEY(GLFW_KEY_END) },
{ MAP_KEY(GLFW_KEY_CAPS_LOCK) },
{ MAP_KEY(GLFW_KEY_SCROLL_LOCK) },
{ MAP_KEY(GLFW_KEY_NUM_LOCK) },
{ MAP_KEY(GLFW_KEY_PRINT_SCREEN) },
{ MAP_KEY(GLFW_KEY_PAUSE) },
{ MAP_KEY(GLFW_KEY_F1) },
{ MAP_KEY(GLFW_KEY_F2) },
{ MAP_KEY(GLFW_KEY_F3) },
{ MAP_KEY(GLFW_KEY_F4) },
{ MAP_KEY(GLFW_KEY_F5) },
{ MAP_KEY(GLFW_KEY_F6) },
{ MAP_KEY(GLFW_KEY_F7) },
{ MAP_KEY(GLFW_KEY_F8) },
{ MAP_KEY(GLFW_KEY_F9) },
{ MAP_KEY(GLFW_KEY_F10) },
{ MAP_KEY(GLFW_KEY_F11) },
{ MAP_KEY(GLFW_KEY_F12) },
{ MAP_KEY(GLFW_KEY_F13) },
{ MAP_KEY(GLFW_KEY_F14) },
{ MAP_KEY(GLFW_KEY_F15) },
{ MAP_KEY(GLFW_KEY_F16) },
{ MAP_KEY(GLFW_KEY_F17) },
{ MAP_KEY(GLFW_KEY_F18) },
{ MAP_KEY(GLFW_KEY_F19) },
{ MAP_KEY(GLFW_KEY_F20) },
{ MAP_KEY(GLFW_KEY_F21) },
{ MAP_KEY(GLFW_KEY_F22) },
{ MAP_KEY(GLFW_KEY_F23) },
{ MAP_KEY(GLFW_KEY_F24) },
{ MAP_KEY(GLFW_KEY_F25) },
{ MAP_KEY(GLFW_KEY_KP_0) },
{ MAP_KEY(GLFW_KEY_KP_1) },
{ MAP_KEY(GLFW_KEY_KP_2) },
{ MAP_KEY(GLFW_KEY_KP_3) },
{ MAP_KEY(GLFW_KEY_KP_4) },
{ MAP_KEY(GLFW_KEY_KP_5) },
{ MAP_KEY(GLFW_KEY_KP_6) },
{ MAP_KEY(GLFW_KEY_KP_7) },
{ MAP_KEY(GLFW_KEY_KP_8) },
{ MAP_KEY(GLFW_KEY_KP_9) },
{ MAP_KEY(GLFW_KEY_KP_DECIMAL) },
{ MAP_KEY(GLFW_KEY_KP_DIVIDE) },
{ MAP_KEY(GLFW_KEY_KP_MULTIPLY) },
{ MAP_KEY(GLFW_KEY_KP_SUBTRACT) },
{ MAP_KEY(GLFW_KEY_KP_ADD) },
{ MAP_KEY(GLFW_KEY_KP_ENTER) },
{ MAP_KEY(GLFW_KEY_KP_EQUAL) },
{ MAP_KEY(GLFW_KEY_LEFT_SHIFT) },
{ MAP_KEY(GLFW_KEY_LEFT_CONTROL) },
{ MAP_KEY(GLFW_KEY_LEFT_ALT) },
{ MAP_KEY(GLFW_KEY_LEFT_SUPER) },
{ MAP_KEY(GLFW_KEY_RIGHT_SHIFT) },
{ MAP_KEY(GLFW_KEY_RIGHT_CONTROL) },
{ MAP_KEY(GLFW_KEY_RIGHT_ALT) },
{ MAP_KEY(GLFW_KEY_RIGHT_SUPER) },
{ MAP_KEY(GLFW_KEY_MENU) },
});
// -----------------------------------------
int keyCode(const char* name)
{
VERIFY(keys.find(name) != keys.end(), "keyCode could not find '{}'", name);
return keys.at(name);
}
int keyCode(const char* name)
{
VERIFY(keys.find(name) != keys.end(), "keyCode could not find '{}'", name);
return keys.at(name);
}
} // namespace Inferno

2
src/inferno/keycodes.h
Unescape View File

@ -4,6 +4,6 @@
namespace Inferno {
int keyCode(const char* name);
int keyCode(const char* name);
}

581
src/inferno/render/buffer.cpp
Unescape View File

@ -1,298 +1,379 @@
#include "glad/glad.h"
#include "ruc/meta/assert.h"
#include "inferno/core.h"
#include "inferno/io/log.h"
#include "inferno/render/buffer.h"
#include "ruc/meta/assert.h"
namespace Inferno {
// -----------------------------------------
BufferElement::BufferElement(BufferElementType type, std::string name, bool normalized) :
m_type(type),
m_name(name),
m_size(BufferElement::getTypeSize(type)),
m_normalized(normalized)
{
}
uint32_t BufferElement::getTypeSize() const
{
return BufferElement::getTypeSize(m_type);
}
uint32_t BufferElement::getTypeCount() const
{
return BufferElement::getTypeCount(m_type);
}
uint32_t BufferElement::getTypeGL() const
{
return BufferElement::getTypeGL(m_type);
}
uint32_t BufferElement::getTypeSize(const BufferElementType type)
{
switch (type) {
case BufferElementType::None: return 0;
case BufferElementType::Bool: return sizeof(bool);
case BufferElementType::Bool2: return sizeof(bool) * 2;
case BufferElementType::Bool3: return sizeof(bool) * 3;
case BufferElementType::Bool4: return sizeof(bool) * 4;
case BufferElementType::Int: return sizeof(int32_t);
case BufferElementType::Int2: return sizeof(int32_t) * 2;
case BufferElementType::Int3: return sizeof(int32_t) * 3;
case BufferElementType::Int4: return sizeof(int32_t) * 4;
case BufferElementType::Uint: return sizeof(uint32_t);
case BufferElementType::Uint2: return sizeof(uint32_t) * 2;
case BufferElementType::Uint3: return sizeof(uint32_t) * 3;
case BufferElementType::Uint4: return sizeof(uint32_t) * 4;
case BufferElementType::Float: return sizeof(float);
case BufferElementType::Vec2: return sizeof(float) * 2;
case BufferElementType::Vec3: return sizeof(float) * 3;
case BufferElementType::Vec4: return sizeof(float) * 4;
case BufferElementType::Double: return sizeof(double);
case BufferElementType::Double2: return sizeof(double);
case BufferElementType::Double3: return sizeof(double);
case BufferElementType::Double4: return sizeof(double);
case BufferElementType::Mat2: return sizeof(float) * 2 * 2;
case BufferElementType::Mat3: return sizeof(float) * 3 * 3;
case BufferElementType::Mat4: return sizeof(float) * 4 * 4;
case BufferElementType::DoubleMat2: return sizeof(double) * 2 * 2;
case BufferElementType::DoubleMat3: return sizeof(double) * 3 * 3;
case BufferElementType::DoubleMat4: return sizeof(double) * 4 * 4;
};
VERIFY(false, "BufferElement unknown BufferElementType size!");
BufferElement::BufferElement(BufferElementType type, std::string name, bool normalized)
: m_type(type)
, m_name(name)
, m_size(BufferElement::getTypeSize(type))
, m_normalized(normalized)
{
}
uint32_t BufferElement::getTypeSize() const
{
return BufferElement::getTypeSize(m_type);
}
uint32_t BufferElement::getTypeCount() const
{
return BufferElement::getTypeCount(m_type);
}
uint32_t BufferElement::getTypeGL() const
{
return BufferElement::getTypeGL(m_type);
}
uint32_t BufferElement::getTypeSize(const BufferElementType type)
{
switch (type) {
case BufferElementType::None:
return 0;
}
uint32_t BufferElement::getTypeCount(const BufferElementType type)
{
switch (type) {
case BufferElementType::None: return 0;
case BufferElementType::Bool: return 1;
case BufferElementType::Bool2: return 2;
case BufferElementType::Bool3: return 3;
case BufferElementType::Bool4: return 4;
case BufferElementType::Int: return 1;
case BufferElementType::Int2: return 2;
case BufferElementType::Int3: return 3;
case BufferElementType::Int4: return 4;
case BufferElementType::Uint: return 1;
case BufferElementType::Uint2: return 2;
case BufferElementType::Uint3: return 3;
case BufferElementType::Uint4: return 4;
case BufferElementType::Float: return 1;
case BufferElementType::Vec2: return 2;
case BufferElementType::Vec3: return 3;
case BufferElementType::Vec4: return 4;
case BufferElementType::Double: return 1;
case BufferElementType::Double2: return 2;
case BufferElementType::Double3: return 3;
case BufferElementType::Double4: return 4;
case BufferElementType::Mat2: return 2 * 2;
case BufferElementType::Mat3: return 3 * 3;
case BufferElementType::Mat4: return 4 * 4;
case BufferElementType::DoubleMat2: return 2 * 2;
case BufferElementType::DoubleMat3: return 3 * 3;
case BufferElementType::DoubleMat4: return 4 * 4;
};
VERIFY(false, "BufferElement unknown BufferElementType count!");
case BufferElementType::Bool:
return sizeof(bool);
case BufferElementType::Bool2:
return sizeof(bool) * 2;
case BufferElementType::Bool3:
return sizeof(bool) * 3;
case BufferElementType::Bool4:
return sizeof(bool) * 4;
case BufferElementType::Int:
return sizeof(int32_t);
case BufferElementType::Int2:
return sizeof(int32_t) * 2;
case BufferElementType::Int3:
return sizeof(int32_t) * 3;
case BufferElementType::Int4:
return sizeof(int32_t) * 4;
case BufferElementType::Uint:
return sizeof(uint32_t);
case BufferElementType::Uint2:
return sizeof(uint32_t) * 2;
case BufferElementType::Uint3:
return sizeof(uint32_t) * 3;
case BufferElementType::Uint4:
return sizeof(uint32_t) * 4;
case BufferElementType::Float:
return sizeof(float);
case BufferElementType::Vec2:
return sizeof(float) * 2;
case BufferElementType::Vec3:
return sizeof(float) * 3;
case BufferElementType::Vec4:
return sizeof(float) * 4;
case BufferElementType::Double:
return sizeof(double);
case BufferElementType::Double2:
return sizeof(double);
case BufferElementType::Double3:
return sizeof(double);
case BufferElementType::Double4:
return sizeof(double);
case BufferElementType::Mat2:
return sizeof(float) * 2 * 2;
case BufferElementType::Mat3:
return sizeof(float) * 3 * 3;
case BufferElementType::Mat4:
return sizeof(float) * 4 * 4;
case BufferElementType::DoubleMat2:
return sizeof(double) * 2 * 2;
case BufferElementType::DoubleMat3:
return sizeof(double) * 3 * 3;
case BufferElementType::DoubleMat4:
return sizeof(double) * 4 * 4;
};
VERIFY(false, "BufferElement unknown BufferElementType size!");
return 0;
}
uint32_t BufferElement::getTypeCount(const BufferElementType type)
{
switch (type) {
case BufferElementType::None:
return 0;
}
uint32_t BufferElement::getTypeGL(const BufferElementType type)
{
switch (type) {
case BufferElementType::None: return GL_NONE;
case BufferElementType::Bool: return GL_BOOL;
case BufferElementType::Bool2: return GL_BOOL;
case BufferElementType::Bool3: return GL_BOOL;
case BufferElementType::Bool4: return GL_BOOL;
case BufferElementType::Int: return GL_INT;
case BufferElementType::Int2: return GL_INT;
case BufferElementType::Int3: return GL_INT;
case BufferElementType::Int4: return GL_INT;
case BufferElementType::Uint: return GL_UNSIGNED_INT;
case BufferElementType::Uint2: return GL_UNSIGNED_INT;
case BufferElementType::Uint3: return GL_UNSIGNED_INT;
case BufferElementType::Uint4: return GL_UNSIGNED_INT;
case BufferElementType::Float: return GL_FLOAT;
case BufferElementType::Vec2: return GL_FLOAT;
case BufferElementType::Vec3: return GL_FLOAT;
case BufferElementType::Vec4: return GL_FLOAT;
case BufferElementType::Double: return GL_DOUBLE;
case BufferElementType::Double2: return GL_DOUBLE;
case BufferElementType::Double3: return GL_DOUBLE;
case BufferElementType::Double4: return GL_DOUBLE;
case BufferElementType::Mat2: return GL_FLOAT;
case BufferElementType::Mat3: return GL_FLOAT;
case BufferElementType::Mat4: return GL_FLOAT;
case BufferElementType::DoubleMat2: return GL_DOUBLE;
case BufferElementType::DoubleMat3: return GL_DOUBLE;
case BufferElementType::DoubleMat4: return GL_DOUBLE;
};
VERIFY(false, "BufferElement unknown BufferElementType GL!");
return 0;
}
case BufferElementType::Bool:
return 1;
case BufferElementType::Bool2:
return 2;
case BufferElementType::Bool3:
return 3;
case BufferElementType::Bool4:
return 4;
case BufferElementType::Int:
return 1;
case BufferElementType::Int2:
return 2;
case BufferElementType::Int3:
return 3;
case BufferElementType::Int4:
return 4;
case BufferElementType::Uint:
return 1;
case BufferElementType::Uint2:
return 2;
case BufferElementType::Uint3:
return 3;
case BufferElementType::Uint4:
return 4;
case BufferElementType::Float:
return 1;
case BufferElementType::Vec2:
return 2;
case BufferElementType::Vec3:
return 3;
case BufferElementType::Vec4:
return 4;
case BufferElementType::Double:
return 1;
case BufferElementType::Double2:
return 2;
case BufferElementType::Double3:
return 3;
case BufferElementType::Double4:
return 4;
case BufferElementType::Mat2:
return 2 * 2;
case BufferElementType::Mat3:
return 3 * 3;
case BufferElementType::Mat4:
return 4 * 4;
case BufferElementType::DoubleMat2:
return 2 * 2;
case BufferElementType::DoubleMat3:
return 3 * 3;
case BufferElementType::DoubleMat4:
return 4 * 4;
};
VERIFY(false, "BufferElement unknown BufferElementType count!");
return 0;
}
uint32_t BufferElement::getTypeGL(const BufferElementType type)
{
switch (type) {
case BufferElementType::None:
return GL_NONE;
case BufferElementType::Bool:
return GL_BOOL;
case BufferElementType::Bool2:
return GL_BOOL;
case BufferElementType::Bool3:
return GL_BOOL;
case BufferElementType::Bool4:
return GL_BOOL;
case BufferElementType::Int:
return GL_INT;
case BufferElementType::Int2:
return GL_INT;
case BufferElementType::Int3:
return GL_INT;
case BufferElementType::Int4:
return GL_INT;
case BufferElementType::Uint:
return GL_UNSIGNED_INT;
case BufferElementType::Uint2:
return GL_UNSIGNED_INT;
case BufferElementType::Uint3:
return GL_UNSIGNED_INT;
case BufferElementType::Uint4:
return GL_UNSIGNED_INT;
case BufferElementType::Float:
return GL_FLOAT;
case BufferElementType::Vec2:
return GL_FLOAT;
case BufferElementType::Vec3:
return GL_FLOAT;
case BufferElementType::Vec4:
return GL_FLOAT;
case BufferElementType::Double:
return GL_DOUBLE;
case BufferElementType::Double2:
return GL_DOUBLE;
case BufferElementType::Double3:
return GL_DOUBLE;
case BufferElementType::Double4:
return GL_DOUBLE;
case BufferElementType::Mat2:
return GL_FLOAT;
case BufferElementType::Mat3:
return GL_FLOAT;
case BufferElementType::Mat4:
return GL_FLOAT;
case BufferElementType::DoubleMat2:
return GL_DOUBLE;
case BufferElementType::DoubleMat3:
return GL_DOUBLE;
case BufferElementType::DoubleMat4:
return GL_DOUBLE;
};
VERIFY(false, "BufferElement unknown BufferElementType GL!");
return 0;
}
// -----------------------------------------
BufferLayout::BufferLayout(const std::initializer_list<BufferElement>& elements)
: m_elements(elements)
{
calculateOffsetsAndStride();
}
void BufferLayout::calculateOffsetsAndStride()
{
m_stride = 0;
for (auto& element : m_elements) {
element.setOffset(m_stride);
m_stride += element.getSize();
}
BufferLayout::BufferLayout(const std::initializer_list<BufferElement>& elements)
: m_elements(elements)
{
calculateOffsetsAndStride();
}
void BufferLayout::calculateOffsetsAndStride()
{
m_stride = 0;
for (auto& element : m_elements) {
element.setOffset(m_stride);
m_stride += element.getSize();
}
}
// -----------------------------------------
VertexBuffer::VertexBuffer(size_t size)
{
glGenBuffers(1, &m_id);
bind();
VertexBuffer::VertexBuffer(size_t size)
{
glGenBuffers(1, &m_id);
bind();
// Reserve data on the GPU
glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_DYNAMIC_DRAW);
// Reserve data on the GPU
glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_DYNAMIC_DRAW);
unbind();
}
unbind();
}
VertexBuffer::VertexBuffer(float* vertices, size_t size)
{
glGenBuffers(1, &m_id);
bind();
VertexBuffer::VertexBuffer(float* vertices, size_t size)
{
glGenBuffers(1, &m_id);
bind();
// Upload data to the GPU
glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
// Upload data to the GPU
glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
unbind();
}
unbind();
}
VertexBuffer::~VertexBuffer()
{
glDeleteBuffers(1, &m_id);
}
VertexBuffer::~VertexBuffer()
{
glDeleteBuffers(1, &m_id);
}
void VertexBuffer::bind() const
{
glBindBuffer(GL_ARRAY_BUFFER, m_id);
}
void VertexBuffer::bind() const
{
glBindBuffer(GL_ARRAY_BUFFER, m_id);
}
void VertexBuffer::unbind() const
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void VertexBuffer::unbind() const
{
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void VertexBuffer::uploadData(const void* data, uint32_t size)
{
bind();
void VertexBuffer::uploadData(const void* data, uint32_t size)
{
bind();
// Upload data to the GPU
glBufferSubData(GL_ARRAY_BUFFER, 0, size, data);
// Upload data to the GPU
glBufferSubData(GL_ARRAY_BUFFER, 0, size, data);
unbind();
}
unbind();
}
// -----------------------------------------
IndexBuffer::IndexBuffer(uint32_t* indices, size_t size) :
m_count(size / sizeof(uint32_t))
{
glCreateBuffers(1, &m_id);
bind();
IndexBuffer::IndexBuffer(uint32_t* indices, size_t size)
: m_count(size / sizeof(uint32_t))
{
glCreateBuffers(1, &m_id);
bind();
// Upload data to the GPU
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, indices, GL_STATIC_DRAW);
// Upload data to the GPU
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, indices, GL_STATIC_DRAW);
unbind();
}
unbind();
}
IndexBuffer::~IndexBuffer()
{
glDeleteBuffers(1, &m_id);
}
IndexBuffer::~IndexBuffer()
{
glDeleteBuffers(1, &m_id);
}
void IndexBuffer::bind() const
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_id);
}
void IndexBuffer::bind() const
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_id);
}
void IndexBuffer::unbind() const
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
void IndexBuffer::unbind() const
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
// -----------------------------------------
VertexArray::VertexArray()
{
glCreateVertexArrays(1, &m_id);
VertexArray::VertexArray()
{
glCreateVertexArrays(1, &m_id);
}
VertexArray::~VertexArray()
{
glDeleteVertexArrays(1, &m_id);
}
void VertexArray::bind() const
{
glBindVertexArray(m_id);
}
void VertexArray::unbind() const
{
glBindVertexArray(0);
}
void VertexArray::addVertexBuffer(std::shared_ptr<VertexBuffer> vertexBuffer)
{
const auto& layout = vertexBuffer->getLayout();
VERIFY(layout.getElements().size(), "VertexBuffer has no layout");
bind();
vertexBuffer->bind();
uint32_t index = 0;
for (const auto& element : layout) {
glEnableVertexAttribArray(index);
glVertexAttribPointer(
index,
element.getTypeCount(),
element.getTypeGL(),
element.getNormalized() ? GL_TRUE : GL_FALSE,
layout.getStride(),
reinterpret_cast<const void*>(element.getOffset()));
index++;
}
m_vertexBuffers.push_back(std::move(vertexBuffer));
VertexArray::~VertexArray()
{
glDeleteVertexArrays(1, &m_id);
}
unbind();
vertexBuffer->unbind();
}
void VertexArray::bind() const
{
glBindVertexArray(m_id);
}
void VertexArray::setIndexBuffer(std::shared_ptr<IndexBuffer> indexBuffer)
{
bind();
indexBuffer->bind();
void VertexArray::unbind() const
{
glBindVertexArray(0);
}
m_indexBuffer = std::move(indexBuffer);
void VertexArray::addVertexBuffer(std::shared_ptr<VertexBuffer> vertexBuffer)
{
const auto& layout = vertexBuffer->getLayout();
VERIFY(layout.getElements().size(), "VertexBuffer has no layout");
bind();
vertexBuffer->bind();
uint32_t index = 0;
for (const auto& element : layout) {
glEnableVertexAttribArray(index);
glVertexAttribPointer(
index,
element.getTypeCount(),
element.getTypeGL(),
element.getNormalized() ? GL_TRUE : GL_FALSE,
layout.getStride(),
reinterpret_cast<const void*>(element.getOffset()));
index++;
}
m_vertexBuffers.push_back(std::move(vertexBuffer));
unbind();
vertexBuffer->unbind();
}
void VertexArray::setIndexBuffer(std::shared_ptr<IndexBuffer> indexBuffer)
{
bind();
indexBuffer->bind();
m_indexBuffer = std::move(indexBuffer);
unbind();
indexBuffer->unbind();
}
unbind();
indexBuffer->unbind();
}
} // namespace Inferno

208
src/inferno/render/buffer.h
Unescape View File

@ -8,138 +8,140 @@
namespace Inferno {
// https://www.khronos.org/opengl/wiki/Data_Type_(GLSL)
enum class BufferElementType {
None = 0,
Bool, Bool2, Bool3, Bool4, // bvec
Int, Int2, Int3, Int4, // ivec
Uint, Uint2, Uint3, Uint4, // uvec
Float, Vec2, Vec3, Vec4, // vec
Double, Double2, Double3, Double4, // dvec
Mat2, Mat3, Mat4, // mat
DoubleMat2, DoubleMat3, DoubleMat4, // dmat
};
// clang-format off
// https://www.khronos.org/opengl/wiki/Data_Type_(GLSL)
enum class BufferElementType {
None = 0,
Bool, Bool2, Bool3, Bool4, // bvec
Int, Int2, Int3, Int4, // ivec
Uint, Uint2, Uint3, Uint4, // uvec
Float, Vec2, Vec3, Vec4, // vec
Double, Double2, Double3, Double4, // dvec
Mat2, Mat3, Mat4, // mat
DoubleMat2, DoubleMat3, DoubleMat4, // dmat
};
// clang-format on
// -----------------------------------------
// Describes one element of the BufferLayout
class BufferElement {
public:
BufferElement(BufferElementType type, std::string name, bool normalized = false);
uint32_t getTypeSize() const;
uint32_t getTypeCount() const;
uint32_t getTypeGL() const;
static uint32_t getTypeSize(const BufferElementType type);
static uint32_t getTypeCount(const BufferElementType type);
static uint32_t getTypeGL(const BufferElementType type);
inline BufferElementType getType() const{ return m_type; }
inline std::string getName() const { return m_name; }
inline uint32_t getSize() const { return m_size; }
inline uint32_t getOffset() const { return m_offset; }
inline bool getNormalized() const { return m_normalized; }
inline void setType(const BufferElementType& type) { m_type = type; }
inline void setName(const std::string& name) { m_name = name; }
inline void setSize(const uint32_t& size) { m_size = size; }
inline void setOffset(const uint32_t& offset) { m_offset = offset; }
inline void setNormalized(const bool& normalized) { m_normalized = normalized; }
private:
BufferElementType m_type;
std::string m_name;
uint32_t m_size { 0 };
uint32_t m_offset { 0 };
bool m_normalized { false };
};
// Describes one element of the BufferLayout
class BufferElement {
public:
BufferElement(BufferElementType type, std::string name, bool normalized = false);
uint32_t getTypeSize() const;
uint32_t getTypeCount() const;
uint32_t getTypeGL() const;
static uint32_t getTypeSize(const BufferElementType type);
static uint32_t getTypeCount(const BufferElementType type);
static uint32_t getTypeGL(const BufferElementType type);
inline BufferElementType getType() const { return m_type; }
inline std::string getName() const { return m_name; }
inline uint32_t getSize() const { return m_size; }
inline uint32_t getOffset() const { return m_offset; }
inline bool getNormalized() const { return m_normalized; }
inline void setType(const BufferElementType& type) { m_type = type; }
inline void setName(const std::string& name) { m_name = name; }
inline void setSize(const uint32_t& size) { m_size = size; }
inline void setOffset(const uint32_t& offset) { m_offset = offset; }
inline void setNormalized(const bool& normalized) { m_normalized = normalized; }
private:
BufferElementType m_type;
std::string m_name;
uint32_t m_size { 0 };
uint32_t m_offset { 0 };
bool m_normalized { false };
};
// -----------------------------------------
// Layout that describes raw vertex data
class BufferLayout {
public:
BufferLayout() {}
BufferLayout(const std::initializer_list<BufferElement>& elements);
// Layout that describes raw vertex data
class BufferLayout {
public:
BufferLayout() {}
BufferLayout(const std::initializer_list<BufferElement>& elements);
inline const std::vector<BufferElement>& getElements() const { return m_elements; }
inline uint32_t getStride() const { return m_stride; }
inline const std::vector<BufferElement>& getElements() const { return m_elements; }
inline uint32_t getStride() const { return m_stride; }
// Iterators
inline std::vector<BufferElement>::iterator begin() { return m_elements.begin(); }
inline std::vector<BufferElement>::iterator end() { return m_elements.end(); }
inline std::vector<BufferElement>::const_iterator begin() const { return m_elements.begin(); }
inline std::vector<BufferElement>::const_iterator end() const { return m_elements.end(); }
// Iterators
inline std::vector<BufferElement>::iterator begin() { return m_elements.begin(); }
inline std::vector<BufferElement>::iterator end() { return m_elements.end(); }
inline std::vector<BufferElement>::const_iterator begin() const { return m_elements.begin(); }
inline std::vector<BufferElement>::const_iterator end() const { return m_elements.end(); }
protected:
void calculateOffsetsAndStride();
protected:
void calculateOffsetsAndStride();
private:
std::vector<BufferElement> m_elements;
uint32_t m_stride { 0 };
};
private:
std::vector<BufferElement> m_elements;
uint32_t m_stride { 0 };
};
// -----------------------------------------
// GPU memory which holds raw vertex data
class VertexBuffer {
public:
VertexBuffer(size_t size);
VertexBuffer(float* vertices, size_t size);
~VertexBuffer();
// GPU memory which holds raw vertex data
class VertexBuffer {
public:
VertexBuffer(size_t size);
VertexBuffer(float* vertices, size_t size);
~VertexBuffer();
void bind() const;
void unbind() const;
void bind() const;
void unbind() const;
void uploadData(const void* data, uint32_t size);
void uploadData(const void* data, uint32_t size);
inline const BufferLayout& getLayout() const { return m_layout; }
inline const BufferLayout& getLayout() const { return m_layout; }
inline void setLayout(const BufferLayout& layout) { m_layout = layout; }
inline void setLayout(const BufferLayout& layout) { m_layout = layout; }
private:
uint32_t m_id { 0 };
BufferLayout m_layout;
};
private:
uint32_t m_id { 0 };
BufferLayout m_layout;
};
// -----------------------------------------
// Vertices order of rendering
class IndexBuffer {
public:
IndexBuffer(uint32_t* indices, size_t size);
~IndexBuffer();
// Vertices order of rendering
class IndexBuffer {
public:
IndexBuffer(uint32_t* indices, size_t size);
~IndexBuffer();
void bind() const;
void unbind() const;
void bind() const;
void unbind() const;
inline uint32_t getCount() const { return m_count; }
inline uint32_t getCount() const { return m_count; }
private:
uint32_t m_id { 0 };
uint32_t m_count { 0 };
};
private:
uint32_t m_id { 0 };
uint32_t m_count { 0 };
};
// -----------------------------------------
// Array that holds the vertex attributes configuration
class VertexArray {
public:
VertexArray();
~VertexArray();
// Array that holds the vertex attributes configuration
class VertexArray {
public:
VertexArray();
~VertexArray();
void bind() const;
void unbind() const;
void bind() const;
void unbind() const;
void addVertexBuffer(std::shared_ptr<VertexBuffer> vertexBuffer);
void setIndexBuffer(std::shared_ptr<IndexBuffer> indexBuffer);
void addVertexBuffer(std::shared_ptr<VertexBuffer> vertexBuffer);
void setIndexBuffer(std::shared_ptr<IndexBuffer> indexBuffer);
inline const std::vector<std::shared_ptr<VertexBuffer>>& getVertexBuffers() const { return m_vertexBuffers; }
inline std::shared_ptr<IndexBuffer> getIndexBuffer() const { return m_indexBuffer; }
inline const std::vector<std::shared_ptr<VertexBuffer>>& getVertexBuffers() const { return m_vertexBuffers; }
inline std::shared_ptr<IndexBuffer> getIndexBuffer() const { return m_indexBuffer; }
private:
uint32_t m_id { 0 };
std::vector<std::shared_ptr<VertexBuffer>> m_vertexBuffers;
std::shared_ptr<IndexBuffer> m_indexBuffer;
};
private:
uint32_t m_id { 0 };
std::vector<std::shared_ptr<VertexBuffer>> m_vertexBuffers;
std::shared_ptr<IndexBuffer> m_indexBuffer;
};
} // namespace Inferno

80
src/inferno/render/context.cpp
Unescape View File

@ -1,5 +1,5 @@
#include "glad/glad.h"
#include "GLFW/glfw3.h"
#include "glad/glad.h"
#include "ruc/meta/assert.h"
#include "inferno/core.h"
@ -9,44 +9,44 @@
namespace Inferno {
Context::Context(GLFWwindow* window) :
m_window(window)
{
VERIFY(window, "Context window is nullptr!");
}
void Context::initialize()
{
Context::setCurrent();
// Initialize glad
int glad = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
VERIFY(glad, "Failed to initialize glad!");
// Log OpenGL properties
comment() << "OpenGL Info:";
comment() << " Vendor: " << glGetString(GL_VENDOR);
comment() << " Renderer: " << glGetString(GL_RENDERER);
comment() << " Version: " << glGetString(GL_VERSION);
// Check OpenGL version
VERIFY(GLVersion.major > 4 || (GLVersion.major == 4 && GLVersion.minor >= 5),
"Inferno requires at least OpenGL version 4.5!");
}
void Context::destroy()
{
}
void Context::render()
{
glfwSwapBuffers(m_window);
}
void Context::setCurrent()
{
// Set current OpenGL context to this window
glfwMakeContextCurrent(m_window);
}
Context::Context(GLFWwindow* window)
: m_window(window)
{
VERIFY(window, "Context window is nullptr!");
}
void Context::initialize()
{
Context::setCurrent();
// Initialize glad
int glad = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
VERIFY(glad, "Failed to initialize glad!");
// Log OpenGL properties
comment() << "OpenGL Info:";
comment() << " Vendor: " << glGetString(GL_VENDOR);
comment() << " Renderer: " << glGetString(GL_RENDERER);
comment() << " Version: " << glGetString(GL_VERSION);
// Check OpenGL version
VERIFY(GLVersion.major > 4 || (GLVersion.major == 4 && GLVersion.minor >= 5),
"Inferno requires at least OpenGL version 4.5!");
}
void Context::destroy()
{
}
void Context::render()
{
glfwSwapBuffers(m_window);
}
void Context::setCurrent()
{
// Set current OpenGL context to this window
glfwMakeContextCurrent(m_window);
}
} // namespace Inferno

20
src/inferno/render/context.h
Unescape View File

@ -4,18 +4,18 @@ struct GLFWwindow;
namespace Inferno {
class Context {
public:
Context(GLFWwindow* window);
class Context {
public:
Context(GLFWwindow* window);
void initialize();
void destroy();
void render();
void initialize();
void destroy();
void render();
void setCurrent();
void setCurrent();
private:
GLFWwindow* m_window { nullptr };
};
private:
GLFWwindow* m_window { nullptr };
};
} // namespace Inferno

237
src/inferno/render/font.cpp
Unescape View File

@ -11,154 +11,153 @@
namespace Inferno {
Font::Font(const std::string& name)
: m_name(std::move(name))
{
std::string path = name + ".fnt";
std::string image = name + ".png";
Font::Font(const std::string& name)
: m_name(std::move(name))
{
std::string path = name + ".fnt";
std::string image = name + ".png";
std::string font = File::read(path);
parseFont(font);
std::string font = File::read(path);
parseFont(font);
m_texture = std::make_shared<Texture>(image);
}
void Font::parseFont(const std::string& font)
{
std::istringstream iss(font);
for (std::string line; std::getline(iss, line);) {
if (findAction(line).compare("info") != 0 &&
findAction(line).compare("char") != 0) {
continue;
}
m_texture = std::make_shared<Texture>(image);
}
const std::vector<std::string> columns = findColumns(line);
void Font::parseFont(const std::string& font)
{
std::istringstream iss(font);
for (std::string line; std::getline(iss, line);) {
// Info
if (findAction(line).compare("info") != 0 && findAction(line).compare("char") != 0) {
continue;
}
if (findAction(line).compare("info") == 0) {
m_size = std::stou(findValue("size", columns));
continue;
}
const std::vector<std::string> columns = findColumns(line);
// Character
// Info
unsigned char id = std::stoi(findValue("id", columns));
Character character = {
{ std::stou(findValue("x", columns)), std::stou(findValue("y", columns)) },
{ std::stou(findValue("width", columns)), std::stou(findValue("height", columns)) },
{ std::stoi(findValue("xoffset", columns)), std::stoi(findValue("yoffset", columns)) },
std::stou(findValue("xadvance", columns))
};
m_characterList.emplace(id, std::make_shared<Character>(character));
if (findAction(line).compare("info") == 0) {
m_size = std::stou(findValue("size", columns));
continue;
}
}
const std::string Font::findAction(const std::string& line)
{
return line.substr(0, line.find(" "));
}
// Character
const std::vector<std::string> Font::findColumns(const std::string& line)
{
std::vector<std::string> elements;
size_t index = 0;
size_t find = 0;
size_t findFirstNotOf = 0;
// Loop over line characters
while (find != std::string::npos) {
find = line.find(" ", index);
findFirstNotOf = line.find_first_not_of(" ", index);
// Add element
if (find > findFirstNotOf) {
elements.push_back(line.substr(index, find - findFirstNotOf));
index += 1 + find - findFirstNotOf;
}
// Skip double spaces
else {
index = findFirstNotOf;
}
unsigned char id = std::stoi(findValue("id", columns));
Character character = {
{ std::stou(findValue("x", columns)), std::stou(findValue("y", columns)) },
{ std::stou(findValue("width", columns)), std::stou(findValue("height", columns)) },
{ std::stoi(findValue("xoffset", columns)), std::stoi(findValue("yoffset", columns)) },
std::stou(findValue("xadvance", columns))
};
m_characterList.emplace(id, std::make_shared<Character>(character));
}
}
const std::string Font::findAction(const std::string& line)
{
return line.substr(0, line.find(" "));
}
const std::vector<std::string> Font::findColumns(const std::string& line)
{
std::vector<std::string> elements;
size_t index = 0;
size_t find = 0;
size_t findFirstNotOf = 0;
// Loop over line characters
while (find != std::string::npos) {
find = line.find(" ", index);
findFirstNotOf = line.find_first_not_of(" ", index);
// Add element
if (find > findFirstNotOf) {
elements.push_back(line.substr(index, find - findFirstNotOf));
index += 1 + find - findFirstNotOf;
}
// Skip double spaces
else {
index = findFirstNotOf;
}
VERIFY(!elements.empty(), "Font file did not find any columns");
return elements;
}
const std::string Font::findValue(const std::string& key, const std::vector<std::string>& columns)
{
size_t find = 0;
// Loop over columns
for (auto& column : columns) {
find = column.find(key + "=");
if (find != std::string::npos) {
return column.substr(key.length() + 1);
}
VERIFY(!elements.empty(), "Font file did not find any columns");
return elements;
}
const std::string Font::findValue(const std::string& key, const std::vector<std::string>& columns)
{
size_t find = 0;
// Loop over columns
for (auto& column : columns) {
find = column.find(key + "=");
if (find != std::string::npos) {
return column.substr(key.length() + 1);
}
VERIFY(false, "Font file did not contain key '{}'", key);
return "";
}
// -----------------------------------------
VERIFY(false, "Font file did not contain key '{}'", key);
return "";
}
FontManager::FontManager(s)
{
info() << "FontManager initialized";
}
// -----------------------------------------
FontManager::~FontManager()
{
}
FontManager::FontManager(s)
{
info() << "FontManager initialized";
}
void FontManager::add(const std::string& name, std::shared_ptr<Font> font)
{
// Construct (key, value) pair and insert it into the unordered_map
m_fontList.emplace(std::move(name), std::move(font));
}
FontManager::~FontManager()
{
}
std::shared_ptr<Font> FontManager::load(const std::string& name)
{
if (exists(name)) {
return get(name);
}
void FontManager::add(const std::string& name, std::shared_ptr<Font> font)
{
// Construct (key, value) pair and insert it into the unordered_map
m_fontList.emplace(std::move(name), std::move(font));
}
std::shared_ptr<Font> font = std::make_shared<Font>(name);
add(name, font);
std::shared_ptr<Font> FontManager::load(const std::string& name)
{
if (exists(name)) {
return get(name);
}
std::shared_ptr<Font> FontManager::get(const std::string& name)
{
return exists(name) ? m_fontList.at(name) : nullptr;
std::shared_ptr<Font> font = std::make_shared<Font>(name);
add(name, font);
return get(name);
}
std::shared_ptr<Font> FontManager::get(const std::string& name)
{
return exists(name) ? m_fontList.at(name) : nullptr;
}
bool FontManager::exists(const std::string& name)
{
return m_fontList.find(name) != m_fontList.end();
}
void FontManager::remove(const std::string& name)
{
if (exists(name)) {
m_fontList.erase(name);
}
}
bool FontManager::exists(const std::string& name)
{
return m_fontList.find(name) != m_fontList.end();
}
void FontManager::remove(const std::string& name)
{
if (exists(name)) {
m_fontList.erase(name);
}
}
void FontManager::remove(std::shared_ptr<Font> font)
{
if (exists(font->name())) {
m_fontList.erase(font->name());
}
void FontManager::remove(std::shared_ptr<Font> font)
{
if (exists(font->name())) {
m_fontList.erase(font->name());
}
}
// -----------------------------------------
const LogStream& operator<<(const LogStream& stream, const glm::ivec2& value)
{
return stream << "{ " << value.x << ", " << value.y << " }";
}
const LogStream& operator<<(const LogStream& stream, const glm::ivec2& value)
{
return stream << "{ " << value.x << ", " << value.y << " }";
}
} // namespace Inferno

86
src/inferno/render/font.h
Unescape View File

@ -14,63 +14,63 @@
namespace Inferno {
class Texture;
class Texture;
struct Character {
glm::uvec2 position; // Position
glm::uvec2 size; // Width/height
glm::ivec2 offset; // Offset from baseline to left / top of glyph
uint32_t advance; // Amount to advance to next glyph
};
struct Character {
glm::uvec2 position; // Position
glm::uvec2 size; // Width/height
glm::ivec2 offset; // Offset from baseline to left / top of glyph
uint32_t advance; // Amount to advance to next glyph
};
// -------------------------------------
// -------------------------------------
class Font {
public:
Font(const std::string& name);
virtual ~Font() {}
class Font {
public:
Font(const std::string& name);
virtual ~Font() {}
inline std::string name() const { return m_name; }
inline uint32_t size() const { return m_size; }
inline std::shared_ptr<Texture> texture() const { return m_texture; }
inline std::string name() const { return m_name; }
inline uint32_t size() const { return m_size; }
inline std::shared_ptr<Texture> texture() const { return m_texture; }
inline std::shared_ptr<Character> get(unsigned char c) const { return m_characterList.at(c); }
inline std::shared_ptr<Character> operator[](unsigned char c) const { return m_characterList.at(c); }
inline std::shared_ptr<Character> get(unsigned char c) const { return m_characterList.at(c); }
inline std::shared_ptr<Character> operator[](unsigned char c) const { return m_characterList.at(c); }
private:
void parseFont(const std::string& font);
const std::string findAction(const std::string& line);
const std::vector<std::string> findColumns(const std::string& line);
const std::string findValue(const std::string& key, const std::vector<std::string>& columns);
private:
void parseFont(const std::string& font);
const std::string findAction(const std::string& line);
const std::vector<std::string> findColumns(const std::string& line);
const std::string findValue(const std::string& key, const std::vector<std::string>& columns);
std::string m_name;
uint32_t m_size;
std::shared_ptr<Texture> m_texture;
std::unordered_map<unsigned char, std::shared_ptr<Character>> m_characterList;
};
std::string m_name;
uint32_t m_size;
std::shared_ptr<Texture> m_texture;
std::unordered_map<unsigned char, std::shared_ptr<Character>> m_characterList;
};
// -------------------------------------
// -------------------------------------
class FontManager final : public ruc::Singleton<FontManager> {
public:
FontManager(s);
virtual ~FontManager();
class FontManager final : public ruc::Singleton<FontManager> {
public:
FontManager(s);
virtual ~FontManager();
void add(const std::string& name, std::shared_ptr<Font> font);
std::shared_ptr<Font> load(const std::string& name);
std::shared_ptr<Font> get(const std::string& name);
bool exists(const std::string& name);
void add(const std::string& name, std::shared_ptr<Font> font);
std::shared_ptr<Font> load(const std::string& name);
std::shared_ptr<Font> get(const std::string& name);
bool exists(const std::string& name);
void remove(const std::string& name);
void remove(std::shared_ptr<Font> font);
void remove(const std::string& name);
void remove(std::shared_ptr<Font> font);
private:
std::unordered_map<std::string, std::shared_ptr<Font>> m_fontList;
};
private:
std::unordered_map<std::string, std::shared_ptr<Font>> m_fontList;
};
// -------------------------------------
// -------------------------------------
const LogStream& operator<<(const LogStream& stream, const glm::ivec2& value);
const LogStream& operator<<(const LogStream& stream, const glm::ivec2& value);
} // namespace Inferno

10
src/inferno/render/framebuffer.h
Unescape View File

@ -2,10 +2,10 @@
namespace Inferno {
class Framebuffer {
public:
Framebuffer();
virtual ~Framebuffer();
};
class Framebuffer {
public:
Framebuffer();
virtual ~Framebuffer();
};
} // namespace Inferno

18
src/inferno/render/gltf.cpp
Unescape View File

@ -1,15 +1,15 @@
#if 0
#include <algorithm> // std::copy
#include <utility> // std::move
#include <algorithm> // std::copy
#include <utility> // std::move
#include "nlohmann/json.hpp"
#include "ruc/meta/assert.h"
#include "nlohmann/json.hpp"
#include "ruc/meta/assert.h"
#include "inferno/io/file.h"
#include "inferno/io/gltffile.h"
#include "inferno/io/log.h"
#include "inferno/render/gltf.h"
#include "inferno/util/integer.h"
#include "inferno/io/file.h"
#include "inferno/io/gltffile.h"
#include "inferno/io/log.h"
#include "inferno/render/gltf.h"
#include "inferno/util/integer.h"
namespace Inferno {

56
src/inferno/render/gltf.h
Unescape View File

@ -1,34 +1,34 @@
#pragma once
#if 0
#include <cstdint> // uint32_t
#include <memory> // std::shared_ptr
#include <string> // std::string
#include <unordered_map> // std::unordered_map
#include <vector> // std::vector
#include "ruc/singleton.h"
#include "inferno/util/json.h"
#define GLTF_TYPE_SCALAR 1
#define GLTF_TYPE_VEC2 2
#define GLTF_TYPE_VEC3 3
#define GLTF_TYPE_VEC4 4
#define GLTF_TYPE_MAT2 8
#define GLTF_TYPE_MAT3 12
#define GLTF_TYPE_MAT4 16
#define GLTF_COMPONENT_TYPE_BYTE 5120
#define GLTF_COMPONENT_TYPE_UNSIGNED_BYTE 5121
#define GLTF_COMPONENT_TYPE_SHORT 5122
#define GLTF_COMPONENT_TYPE_UNSIGNED_SHORT 5123
#define GLTF_COMPONENT_TYPE_INT 5124
#define GLTF_COMPONENT_TYPE_UNSIGNED_INT 5125
#define GLTF_COMPONENT_TYPE_FLOAT 5126
#define GLTF_TARGET_ARRAY_BUFFER 34962
#define GLTF_TARGET_ELEMENT_ARRAY_BUFFER 34963
#include <cstdint> // uint32_t
#include <memory> // std::shared_ptr
#include <string> // std::string
#include <unordered_map> // std::unordered_map
#include <vector> // std::vector
#include "ruc/singleton.h"
#include "inferno/util/json.h"
#define GLTF_TYPE_SCALAR 1
#define GLTF_TYPE_VEC2 2
#define GLTF_TYPE_VEC3 3
#define GLTF_TYPE_VEC4 4
#define GLTF_TYPE_MAT2 8
#define GLTF_TYPE_MAT3 12
#define GLTF_TYPE_MAT4 16
#define GLTF_COMPONENT_TYPE_BYTE 5120
#define GLTF_COMPONENT_TYPE_UNSIGNED_BYTE 5121
#define GLTF_COMPONENT_TYPE_SHORT 5122
#define GLTF_COMPONENT_TYPE_UNSIGNED_SHORT 5123
#define GLTF_COMPONENT_TYPE_INT 5124
#define GLTF_COMPONENT_TYPE_UNSIGNED_INT 5125
#define GLTF_COMPONENT_TYPE_FLOAT 5126
#define GLTF_TARGET_ARRAY_BUFFER 34962
#define GLTF_TARGET_ELEMENT_ARRAY_BUFFER 34963
namespace Inferno {

675
src/inferno/render/renderer.cpp
Unescape View File

@ -10,433 +10,436 @@
namespace Inferno {
void RenderCommand::initialize()
{
setDepthTest(true);
void RenderCommand::initialize()
{
setDepthTest(true);
// Enable transparency
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
// Enable transparency
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
info() << "RenderCommand initialized";
}
info() << "RenderCommand initialized";
}
void RenderCommand::destroy()
{
}
void RenderCommand::destroy()
{
}
void RenderCommand::clear()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void RenderCommand::clear()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void RenderCommand::clearColor(const glm::vec4& color)
{
glClearColor(color.r, color.g, color.b, color.a);
}
void RenderCommand::clearColor(const glm::vec4& color)
{
glClearColor(color.r, color.g, color.b, color.a);
}
void RenderCommand::drawIndexed(const VertexArray& vertexArray, uint32_t indexCount)
{
uint32_t count = indexCount ? indexCount : vertexArray.getIndexBuffer()->getCount();
glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, nullptr);
}
void RenderCommand::drawIndexed(const VertexArray& vertexArray, uint32_t indexCount)
{
uint32_t count = indexCount ? indexCount : vertexArray.getIndexBuffer()->getCount();
glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, nullptr);
}
void RenderCommand::setViewport(int32_t x, int32_t y, uint32_t width, uint32_t height)
{
glViewport(x, y, width, height);
}
void RenderCommand::setViewport(int32_t x, int32_t y, uint32_t width, uint32_t height)
{
glViewport(x, y, width, height);
}
void RenderCommand::setDepthTest(bool enabled)
{
// Set z-buffer / depth buffer
enabled ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
}
void RenderCommand::setDepthTest(bool enabled)
{
// Set z-buffer / depth buffer
enabled ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
}
bool RenderCommand::depthTest()
{
unsigned char depthTest = GL_FALSE;
glGetBooleanv(GL_DEPTH_TEST, &depthTest);
return depthTest == GL_TRUE;
}
bool RenderCommand::depthTest()
{
unsigned char depthTest = GL_FALSE;
glGetBooleanv(GL_DEPTH_TEST, &depthTest);
return depthTest == GL_TRUE;
}
int32_t RenderCommand::textureUnitAmount()
{
int32_t amount = 0;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &amount);
return amount;
}
int32_t RenderCommand::textureUnitAmount()
{
int32_t amount = 0;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &amount);
return amount;
}
// -----------------------------------------
uint32_t Renderer::m_supportedTextureUnitPerBatch = 0;
uint32_t Renderer::m_supportedTextureUnitPerBatch = 0;
void Renderer::initialize()
{
// Get amount of texture units supported by the GPU
uint32_t constTextureUnitCount = textureUnitPerBatch;
uint32_t gpuTextureUnitCount = RenderCommand::textureUnitAmount();
m_supportedTextureUnitPerBatch = std::min(constTextureUnitCount, gpuTextureUnitCount);
void Renderer::initialize()
{
// Get amount of texture units supported by the GPU
uint32_t constTextureUnitCount = textureUnitPerBatch;
uint32_t gpuTextureUnitCount = RenderCommand::textureUnitAmount();
m_supportedTextureUnitPerBatch = std::min(constTextureUnitCount, gpuTextureUnitCount);
// Texture unit 0 is reserved for no texture
m_textureUnits[0] = nullptr;
// Texture unit 0 is reserved for no texture
m_textureUnits[0] = nullptr;
// Create texture unit samplers
int32_t samplers[textureUnitPerBatch];
for (uint32_t i = 0; i < textureUnitPerBatch; i++) {
samplers[i] = i;
}
// Create texture unit samplers
int32_t samplers[textureUnitPerBatch];
for (uint32_t i = 0; i < textureUnitPerBatch; i++) {
samplers[i] = i;
}
// Create shader
loadShader();
m_shader->bind();
m_shader->setInt("u_textures", samplers, textureUnitPerBatch);
m_shader->unbind();
// Create vertex array
m_vertexArray = std::make_shared<VertexArray>();
}
// Create shader
loadShader();
m_shader->bind();
m_shader->setInt("u_textures", samplers, textureUnitPerBatch);
m_shader->unbind();
void Renderer::destroy()
{
}
// Create vertex array
m_vertexArray = std::make_shared<VertexArray>();
uint32_t Renderer::addTextureUnit(std::shared_ptr<Texture> texture)
{
if (texture == nullptr) {
return 0;
}
void Renderer::destroy()
{
// Create a new batch if the texture unit limit has been reached
if (m_textureUnitIndex >= m_supportedTextureUnitPerBatch) {
nextBatch();
}
uint32_t Renderer::addTextureUnit(std::shared_ptr<Texture> texture)
{
if (texture == nullptr) {
return 0;
// If texure was already added
for (uint32_t i = 1; i < m_textureUnitIndex; i++) {
if (m_textureUnits[i] == texture) {
return i;
}
}
// Create a new batch if the texture unit limit has been reached
if (m_textureUnitIndex >= m_supportedTextureUnitPerBatch) {
nextBatch();
}
// Add texture
uint32_t textureUnitIndex = m_textureUnitIndex;
m_textureUnits[textureUnitIndex] = texture;
m_textureUnitIndex++;
// If texure was already added
for (uint32_t i = 1; i < m_textureUnitIndex; i++) {
if (m_textureUnits[i] == texture) {
return i;
}
}
return textureUnitIndex;
}
// Add texture
uint32_t textureUnitIndex = m_textureUnitIndex;
m_textureUnits[textureUnitIndex] = texture;
m_textureUnitIndex++;
void Renderer::bind()
{
m_shader->bind();
return textureUnitIndex;
for (uint32_t i = 1; i < m_textureUnitIndex; i++) {
m_textureUnits[i]->bind(i);
}
void Renderer::bind()
{
m_shader->bind();
m_vertexArray->bind();
}
for (uint32_t i = 1; i < m_textureUnitIndex; i++) {
m_textureUnits[i]->bind(i);
}
void Renderer::unbind()
{
m_vertexArray->unbind();
m_vertexArray->bind();
for (uint32_t i = 1; i < m_textureUnitIndex; i++) {
m_textureUnits[i]->unbind();
}
void Renderer::unbind()
{
m_vertexArray->unbind();
for (uint32_t i = 1; i < m_textureUnitIndex; i++) {
m_textureUnits[i]->unbind();
}
m_shader->unbind();
}
m_shader->unbind();
}
// -----------------------------------------
Renderer2D::Renderer2D(s)
{
Renderer::initialize();
// CPU
// ---------------------------------
Renderer2D::Renderer2D(s)
{
Renderer::initialize();
// Create array for storing quads vertices
m_vertexBufferBase = std::make_unique<QuadVertex[]>(vertexCount);
m_vertexBufferPtr = m_vertexBufferBase.get();
// CPU
// ---------------------------------
// Set default quad vertex positions
m_vertexPositions[0] = { -0.5f, -0.5f, 0.0f, 1.0f };
m_vertexPositions[1] = { 0.5f, -0.5f, 0.0f, 1.0f };
m_vertexPositions[2] = { 0.5f, 0.5f, 0.0f, 1.0f };
m_vertexPositions[3] = { -0.5f, 0.5f, 0.0f, 1.0f };
// Create array for storing quads vertices
m_vertexBufferBase = std::make_unique<QuadVertex[]>(vertexCount);
m_vertexBufferPtr = m_vertexBufferBase.get();
// Generate indices
// Set default quad vertex positions
m_vertexPositions[0] = { -0.5f, -0.5f, 0.0f, 1.0f };
m_vertexPositions[1] = { 0.5f, -0.5f, 0.0f, 1.0f };
m_vertexPositions[2] = { 0.5f, 0.5f, 0.0f, 1.0f };
m_vertexPositions[3] = { -0.5f, 0.5f, 0.0f, 1.0f };
uint32_t* indices = new uint32_t[indexCount];
// Generate indices
uint32_t offset = 0;
for (uint32_t i = 0; i < indexCount; i += indexPerQuad) {
indices[i + 0] = offset + 0;
indices[i + 1] = offset + 1;
indices[i + 2] = offset + 2;
indices[i + 3] = offset + 2;
indices[i + 4] = offset + 3;
indices[i + 5] = offset + 0;
uint32_t* indices = new uint32_t[indexCount];
offset += vertexPerQuad;
}
uint32_t offset = 0;
for (uint32_t i = 0; i < indexCount; i += indexPerQuad) {
indices[i + 0] = offset + 0;
indices[i + 1] = offset + 1;
indices[i + 2] = offset + 2;
indices[i + 3] = offset + 2;
indices[i + 4] = offset + 3;
indices[i + 5] = offset + 0;
// GPU
// ---------------------------------
// Create vertex buffer
auto vertexBuffer = std::make_shared<VertexBuffer>(sizeof(QuadVertex) * vertexCount);
vertexBuffer->setLayout({
{ BufferElementType::Vec3, "a_position" },
{ BufferElementType::Vec4, "a_color" },
{ BufferElementType::Vec2, "a_textureCoordinates" },
{ BufferElementType::Float, "a_textureIndex" },
});
m_vertexArray->addVertexBuffer(vertexBuffer);
// Create index buffer
auto indexBuffer = std::make_shared<IndexBuffer>(indices, sizeof(uint32_t) * indexCount);
m_vertexArray->setIndexBuffer(indexBuffer);
delete[] indices;
info() << "Renderer2D initialized";
offset += vertexPerQuad;
}
Renderer2D::~Renderer2D()
{
Renderer::destroy();
}
// GPU
// ---------------------------------
void Renderer2D::beginScene(glm::mat4 cameraProjectionView)
{
m_shader->bind();
m_shader->setFloat("u_projectionView", cameraProjectionView);
m_shader->unbind();
}
// Create vertex buffer
auto vertexBuffer = std::make_shared<VertexBuffer>(sizeof(QuadVertex) * vertexCount);
vertexBuffer->setLayout({
{ BufferElementType::Vec3, "a_position" },
{ BufferElementType::Vec4, "a_color" },
{ BufferElementType::Vec2, "a_textureCoordinates" },
{ BufferElementType::Float, "a_textureIndex" },
});
m_vertexArray->addVertexBuffer(vertexBuffer);
void Renderer2D::endScene()
{
nextBatch();
}
void Renderer2D::drawQuad(const TransformComponent& transform, glm::vec4 color)
{
drawQuad(transform, color, nullptr);
}
// Create index buffer
auto indexBuffer = std::make_shared<IndexBuffer>(indices, sizeof(uint32_t) * indexCount);
m_vertexArray->setIndexBuffer(indexBuffer);
delete[] indices;
void Renderer2D::drawQuad(const TransformComponent& transform, glm::mat4 color)
{
drawQuad(transform, color, nullptr);
}
info() << "Renderer2D initialized";
}
void Renderer2D::drawQuad(const TransformComponent& transform, glm::vec4 color, std::shared_ptr<Texture> texture)
{
drawQuad(transform, glm::mat4(color, color, color, color), texture);
}
Renderer2D::~Renderer2D()
{
Renderer::destroy();
}
void Renderer2D::drawQuad(const TransformComponent& transform, glm::mat4 color, std::shared_ptr<Texture> texture)
{
// Create a new batch if the quad limit has been reached
if (m_quadIndex >= quadCount) {
nextBatch();
}
void Renderer2D::beginScene(glm::mat4 cameraProjectionView)
{
m_shader->bind();
m_shader->setFloat("u_projectionView", cameraProjectionView);
m_shader->unbind();
}
constexpr glm::vec2 textureCoordinates[] = {
{ 0.0f, 0.0f }, { 1.0f, 0.0f }, { 1.0f, 1.0f }, { 0.0f, 1.0f }
};
void Renderer2D::endScene()
{
nextBatch();
}
uint32_t textureUnitIndex = addTextureUnit(texture);
void Renderer2D::drawQuad(const TransformComponent& transform, glm::vec4 color)
{
drawQuad(transform, color, nullptr);
}
// Add the quads 4 vertices
for (uint32_t i = 0; i < vertexPerQuad; i++) {
m_vertexBufferPtr->position = transform.transform * m_vertexPositions[i];
m_vertexBufferPtr->color = color[i];
m_vertexBufferPtr->textureCoordinates = textureCoordinates[i];
m_vertexBufferPtr->textureIndex = (float)textureUnitIndex;
m_vertexBufferPtr++;
}
void Renderer2D::drawQuad(const TransformComponent& transform, glm::mat4 color)
{
drawQuad(transform, color, nullptr);
}
m_quadIndex++;
}
void Renderer2D::drawQuad(const TransformComponent& transform, glm::vec4 color, std::shared_ptr<Texture> texture)
{
drawQuad(transform, glm::mat4(color, color, color, color), texture);
}
void Renderer2D::loadShader()
{
m_shader = ShaderManager::the().load("assets/glsl/batch-quad");
void Renderer2D::drawQuad(const TransformComponent& transform, glm::mat4 color, std::shared_ptr<Texture> texture)
{
// Create a new batch if the quad limit has been reached
if (m_quadIndex >= quadCount) {
nextBatch();
}
void Renderer2D::flush()
{
if (m_quadIndex == 0) {
return;
}
constexpr glm::vec2 textureCoordinates[] = {
{ 0.0f, 0.0f },
{ 1.0f, 0.0f },
{ 1.0f, 1.0f },
{ 0.0f, 1.0f }
};
// Upload vertex data to GPU
m_vertexArray->getVertexBuffers().at(0)->uploadData(
m_vertexBufferBase.get(),
m_quadIndex * vertexPerQuad * sizeof(QuadVertex));
uint32_t textureUnitIndex = addTextureUnit(texture);
bind();
// Render
RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad);
unbind();
// Add the quads 4 vertices
for (uint32_t i = 0; i < vertexPerQuad; i++) {
m_vertexBufferPtr->position = transform.transform * m_vertexPositions[i];
m_vertexBufferPtr->color = color[i];
m_vertexBufferPtr->textureCoordinates = textureCoordinates[i];
m_vertexBufferPtr->textureIndex = (float)textureUnitIndex;
m_vertexBufferPtr++;
}
void Renderer2D::startBatch()
{
m_quadIndex = 0;
m_vertexBufferPtr = m_vertexBufferBase.get();
m_quadIndex++;
}
m_textureUnitIndex = 1;
}
void Renderer2D::loadShader()
{
m_shader = ShaderManager::the().load("assets/glsl/batch-quad");
}
void Renderer2D::nextBatch()
{
flush();
startBatch();
void Renderer2D::flush()
{
if (m_quadIndex == 0) {
return;
}
// -----------------------------------------
// Upload vertex data to GPU
m_vertexArray->getVertexBuffers().at(0)->uploadData(
m_vertexBufferBase.get(),
m_quadIndex * vertexPerQuad * sizeof(QuadVertex));
RendererCharacter::RendererCharacter(s)
{
Renderer::initialize();
bind();
// CPU
// ---------------------------------
// Render
RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad);
// Create array for storing quads vertices
m_vertexBufferBase = std::make_unique<CharacterVertex[]>(vertexCount);
m_vertexBufferPtr = m_vertexBufferBase.get();
unbind();
}
// Generate indices
void Renderer2D::startBatch()
{
m_quadIndex = 0;
m_vertexBufferPtr = m_vertexBufferBase.get();
uint32_t* indices = new uint32_t[indexCount];
m_textureUnitIndex = 1;
}
uint32_t offset = 0;
for (uint32_t i = 0; i < indexCount; i += indexPerQuad) {
indices[i + 0] = offset + 0;
indices[i + 1] = offset + 1;
indices[i + 2] = offset + 2;
indices[i + 3] = offset + 2;
indices[i + 4] = offset + 3;
indices[i + 5] = offset + 0;
void Renderer2D::nextBatch()
{
flush();
startBatch();
}
offset += vertexPerQuad;
}
// -----------------------------------------
// GPU
// ---------------------------------
// Create vertex buffer
auto vertexBuffer = std::make_shared<VertexBuffer>(sizeof(CharacterVertex) * vertexCount);
vertexBuffer->setLayout({
{ BufferElementType::Vec3, "a_position" },
{ BufferElementType::Vec4, "a_color" },
{ BufferElementType::Vec2, "a_textureCoordinates" },
{ BufferElementType::Float, "a_textureIndex" },
{ BufferElementType::Float, "a_width" },
{ BufferElementType::Float, "a_edge" },
{ BufferElementType::Float, "a_borderWidth" },
{ BufferElementType::Float, "a_borderEdge" },
{ BufferElementType::Vec4, "a_borderColor" },
{ BufferElementType::Float, "a_offset" },
});
m_vertexArray->addVertexBuffer(vertexBuffer);
// Create index buffer
auto indexBuffer = std::make_shared<IndexBuffer>(indices, sizeof(uint32_t) * indexCount);
m_vertexArray->setIndexBuffer(indexBuffer);
delete[] indices;
info() << "RendererCharacter initialized";
}
RendererCharacter::RendererCharacter(s)
{
Renderer::initialize();
// CPU
// ---------------------------------
// Create array for storing quads vertices
m_vertexBufferBase = std::make_unique<CharacterVertex[]>(vertexCount);
m_vertexBufferPtr = m_vertexBufferBase.get();
// Generate indices
uint32_t* indices = new uint32_t[indexCount];
uint32_t offset = 0;
for (uint32_t i = 0; i < indexCount; i += indexPerQuad) {
indices[i + 0] = offset + 0;
indices[i + 1] = offset + 1;
indices[i + 2] = offset + 2;
indices[i + 3] = offset + 2;
indices[i + 4] = offset + 3;
indices[i + 5] = offset + 0;
offset += vertexPerQuad;
}
// GPU
// ---------------------------------
// Create vertex buffer
auto vertexBuffer = std::make_shared<VertexBuffer>(sizeof(CharacterVertex) * vertexCount);
vertexBuffer->setLayout({
{ BufferElementType::Vec3, "a_position" },
{ BufferElementType::Vec4, "a_color" },
{ BufferElementType::Vec2, "a_textureCoordinates" },
{ BufferElementType::Float, "a_textureIndex" },
{ BufferElementType::Float, "a_width" },
{ BufferElementType::Float, "a_edge" },
{ BufferElementType::Float, "a_borderWidth" },
{ BufferElementType::Float, "a_borderEdge" },
{ BufferElementType::Vec4, "a_borderColor" },
{ BufferElementType::Float, "a_offset" },
});
m_vertexArray->addVertexBuffer(vertexBuffer);
// Create index buffer
auto indexBuffer = std::make_shared<IndexBuffer>(indices, sizeof(uint32_t) * indexCount);
m_vertexArray->setIndexBuffer(indexBuffer);
delete[] indices;
info() << "RendererCharacter initialized";
}
RendererCharacter::~RendererCharacter()
{
Renderer::destroy();
}
RendererCharacter::~RendererCharacter()
{
Renderer::destroy();
}
void RendererCharacter::beginScene()
{
}
void RendererCharacter::beginScene()
{
}
void RendererCharacter::endScene()
{
void RendererCharacter::endScene()
{
nextBatch();
}
void RendererCharacter::drawCharacter(std::array<CharacterVertex, vertexPerQuad>& characterQuad, std::shared_ptr<Texture> texture)
{
// Create a new batch if the quad limit has been reached
if (m_quadIndex >= quadCount) {
nextBatch();
}
void RendererCharacter::drawCharacter(std::array<CharacterVertex, vertexPerQuad>& characterQuad, std::shared_ptr<Texture> texture)
{
// Create a new batch if the quad limit has been reached
if (m_quadIndex >= quadCount) {
nextBatch();
}
uint32_t textureUnitIndex = addTextureUnit(texture);
// Add the quads 4 vertices
for (uint32_t i = 0; i < vertexPerQuad; i++) {
m_vertexBufferPtr->quad.position = characterQuad[i].quad.position;
m_vertexBufferPtr->quad.color = characterQuad[i].quad.color;
m_vertexBufferPtr->quad.textureCoordinates = characterQuad[i].quad.textureCoordinates;
m_vertexBufferPtr->quad.textureIndex = (float)textureUnitIndex;
uint32_t textureUnitIndex = addTextureUnit(texture);
m_vertexBufferPtr->width = characterQuad[i].width;
m_vertexBufferPtr->edge = characterQuad[i].edge;
m_vertexBufferPtr->borderWidth = characterQuad[i].borderWidth;
m_vertexBufferPtr->borderEdge = characterQuad[i].borderEdge;
m_vertexBufferPtr->borderColor = characterQuad[i].borderColor;
m_vertexBufferPtr->offset = characterQuad[i].offset;
// Add the quads 4 vertices
for (uint32_t i = 0; i < vertexPerQuad; i++) {
m_vertexBufferPtr->quad.position = characterQuad[i].quad.position;
m_vertexBufferPtr->quad.color = characterQuad[i].quad.color;
m_vertexBufferPtr->quad.textureCoordinates = characterQuad[i].quad.textureCoordinates;
m_vertexBufferPtr->quad.textureIndex = (float)textureUnitIndex;
m_vertexBufferPtr++;
}
m_vertexBufferPtr->width = characterQuad[i].width;
m_vertexBufferPtr->edge = characterQuad[i].edge;
m_vertexBufferPtr->borderWidth = characterQuad[i].borderWidth;
m_vertexBufferPtr->borderEdge = characterQuad[i].borderEdge;
m_vertexBufferPtr->borderColor = characterQuad[i].borderColor;
m_vertexBufferPtr->offset = characterQuad[i].offset;
m_quadIndex++;
m_vertexBufferPtr++;
}
void RendererCharacter::loadShader()
{
m_shader = ShaderManager::the().load("assets/glsl/batch-font");
}
m_quadIndex++;
}
void RendererCharacter::flush()
{
if (m_quadIndex == 0) {
return;
}
void RendererCharacter::loadShader()
{
m_shader = ShaderManager::the().load("assets/glsl/batch-font");
}
// Upload vertex data to GPU
m_vertexArray->getVertexBuffers().at(0)->uploadData(
m_vertexBufferBase.get(),
m_quadIndex * vertexPerQuad * sizeof(CharacterVertex));
void RendererCharacter::flush()
{
if (m_quadIndex == 0) {
return;
}
bind();
// Upload vertex data to GPU
m_vertexArray->getVertexBuffers().at(0)->uploadData(
m_vertexBufferBase.get(),
m_quadIndex * vertexPerQuad * sizeof(CharacterVertex));
// Render
bool depthTest = RenderCommand::depthTest();
RenderCommand::setDepthTest(false);
RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad);
RenderCommand::setDepthTest(depthTest);
bind();
unbind();
}
// Render
bool depthTest = RenderCommand::depthTest();
RenderCommand::setDepthTest(false);
RenderCommand::drawIndexed(*m_vertexArray, m_quadIndex * indexPerQuad);
RenderCommand::setDepthTest(depthTest);
void RendererCharacter::startBatch()
{
m_quadIndex = 0;
m_vertexBufferPtr = m_vertexBufferBase.get();
unbind();
}
m_textureUnitIndex = 1;
}
void RendererCharacter::startBatch()
{
m_quadIndex = 0;
m_vertexBufferPtr = m_vertexBufferBase.get();
void RendererCharacter::nextBatch()
{
flush();
startBatch();
}
m_textureUnitIndex = 1;
}
void RendererCharacter::nextBatch()
{
flush();
startBatch();
}
} // namespace Inferno

276
src/inferno/render/renderer.h
Unescape View File

@ -13,150 +13,150 @@
namespace Inferno {
class Shader;
class Texture;
class VertexArray;
struct QuadVertex {
glm::vec3 position { 0.0f, 0.0f, 0.0f };
glm::vec4 color { 1.0f, 1.0f, 1.0f, 1.0f };
glm::vec2 textureCoordinates { 0.0f, 0.0f };
float textureIndex = 0; // @Todo get int to pass to fragment correctly
};
struct CharacterVertex {
QuadVertex quad;
// Font
float width = 0.44f;
float edge = 0.15f;
// Outline
float borderWidth = 0.7f;
float borderEdge = 0.1f;
glm::vec4 borderColor { 1.0f, 1.0f, 1.0f, 1.0f };
// Dropshadow
float offset = 0.0f;
};
// -------------------------------------
class RenderCommand {
public:
static void initialize();
static void destroy();
static void clear();
static void clearColor(const glm::vec4& color);
static void drawIndexed(const VertexArray& vertexArray, uint32_t indexCount = 0);
static void setViewport(int32_t x, int32_t y, uint32_t width, uint32_t height);
static void setDepthTest(bool enabled);
static bool depthTest();
static int32_t textureUnitAmount();
};
// -------------------------------------
class Renderer {
public:
static const uint32_t vertexPerQuad = 4;
static const uint32_t indexPerQuad = 6;
static const uint32_t textureUnitPerBatch = 32;
protected:
Renderer() {}
void initialize();
void destroy();
uint32_t addTextureUnit(std::shared_ptr<Texture> texture);
void bind();
void unbind();
virtual void loadShader() = 0;
virtual void flush() = 0;
virtual void startBatch() = 0;
virtual void nextBatch() = 0;
uint32_t m_quadIndex = 0;
// Texture units
static uint32_t m_supportedTextureUnitPerBatch;
uint32_t m_textureUnitIndex = 1;
std::array<std::shared_ptr<Texture>, textureUnitPerBatch> m_textureUnits;
// GPU objects
std::shared_ptr<Shader> m_shader;
std::shared_ptr<VertexArray> m_vertexArray;
};
// -------------------------------------
class Renderer2D final
: public Renderer
, public ruc::Singleton<Renderer2D> {
public:
Renderer2D(s);
virtual ~Renderer2D();
using Singleton<Renderer2D>::destroy;
static const uint32_t quadCount = 1000;
static const uint32_t vertexCount = quadCount * vertexPerQuad;
static const uint32_t indexCount = quadCount * indexPerQuad;
void beginScene(glm::mat4 cameraProjectionView);
void endScene();
void drawQuad(const TransformComponent& transform, glm::vec4 color);
void drawQuad(const TransformComponent& transform, glm::mat4 color);
void drawQuad(const TransformComponent& transform, glm::vec4 color, std::shared_ptr<Texture> texture);
void drawQuad(const TransformComponent& transform, glm::mat4 color, std::shared_ptr<Texture> texture);
private:
void loadShader() override;
void flush() override;
void startBatch() override;
void nextBatch() override;
// CPU quad vertices
std::unique_ptr<QuadVertex[]> m_vertexBufferBase;
QuadVertex* m_vertexBufferPtr { nullptr };
class Shader;
class Texture;
class VertexArray;
struct QuadVertex {
glm::vec3 position { 0.0f, 0.0f, 0.0f };
glm::vec4 color { 1.0f, 1.0f, 1.0f, 1.0f };
glm::vec2 textureCoordinates { 0.0f, 0.0f };
float textureIndex = 0; // @Todo get int to pass to fragment correctly
};
struct CharacterVertex {
QuadVertex quad;
// Font
float width = 0.44f;
float edge = 0.15f;
// Outline
float borderWidth = 0.7f;
float borderEdge = 0.1f;
glm::vec4 borderColor { 1.0f, 1.0f, 1.0f, 1.0f };
// Dropshadow
float offset = 0.0f;
};
// -------------------------------------
class RenderCommand {
public:
static void initialize();
static void destroy();
static void clear();
static void clearColor(const glm::vec4& color);
static void drawIndexed(const VertexArray& vertexArray, uint32_t indexCount = 0);
static void setViewport(int32_t x, int32_t y, uint32_t width, uint32_t height);
static void setDepthTest(bool enabled);
static bool depthTest();
static int32_t textureUnitAmount();
};
// -------------------------------------
class Renderer {
public:
static const uint32_t vertexPerQuad = 4;
static const uint32_t indexPerQuad = 6;
static const uint32_t textureUnitPerBatch = 32;
protected:
Renderer() {}
void initialize();
void destroy();
uint32_t addTextureUnit(std::shared_ptr<Texture> texture);
void bind();
void unbind();
virtual void loadShader() = 0;
virtual void flush() = 0;
virtual void startBatch() = 0;
virtual void nextBatch() = 0;
uint32_t m_quadIndex = 0;
// Texture units
static uint32_t m_supportedTextureUnitPerBatch;
uint32_t m_textureUnitIndex = 1;
std::array<std::shared_ptr<Texture>, textureUnitPerBatch> m_textureUnits;
// GPU objects
std::shared_ptr<Shader> m_shader;
std::shared_ptr<VertexArray> m_vertexArray;
};
// -------------------------------------
class Renderer2D final
: public Renderer
, public ruc::Singleton<Renderer2D> {
public:
Renderer2D(s);
virtual ~Renderer2D();
using Singleton<Renderer2D>::destroy;
static const uint32_t quadCount = 1000;
static const uint32_t vertexCount = quadCount * vertexPerQuad;
static const uint32_t indexCount = quadCount * indexPerQuad;
void beginScene(glm::mat4 cameraProjectionView);
void endScene();
void drawQuad(const TransformComponent& transform, glm::vec4 color);
void drawQuad(const TransformComponent& transform, glm::mat4 color);
void drawQuad(const TransformComponent& transform, glm::vec4 color, std::shared_ptr<Texture> texture);
void drawQuad(const TransformComponent& transform, glm::mat4 color, std::shared_ptr<Texture> texture);
private:
void loadShader() override;
void flush() override;
void startBatch() override;
void nextBatch() override;
// CPU quad vertices
std::unique_ptr<QuadVertex[]> m_vertexBufferBase;
QuadVertex* m_vertexBufferPtr { nullptr };
// Default quad vertex positions
glm::vec4 m_vertexPositions[vertexPerQuad];
};
// -------------------------------------
class RendererCharacter final
: public Renderer
, public ruc::Singleton<RendererCharacter> {
public:
RendererCharacter(s);
virtual ~RendererCharacter();
// Default quad vertex positions
glm::vec4 m_vertexPositions[vertexPerQuad];
};
// -------------------------------------
class RendererCharacter final
: public Renderer
, public ruc::Singleton<RendererCharacter> {
public:
RendererCharacter(s);
virtual ~RendererCharacter();
using Singleton<RendererCharacter>::destroy;
using Singleton<RendererCharacter>::destroy;
static const uint32_t quadCount = 1000;
static const uint32_t vertexCount = quadCount * vertexPerQuad;
static const uint32_t indexCount = quadCount * indexPerQuad;
static const uint32_t quadCount = 1000;
static const uint32_t vertexCount = quadCount * vertexPerQuad;
static const uint32_t indexCount = quadCount * indexPerQuad;
void beginScene();
void endScene();
void beginScene();
void endScene();
void drawCharacter(std::array<CharacterVertex, vertexPerQuad>& characterQuad, std::shared_ptr<Texture> texture);
void drawCharacter(std::array<CharacterVertex, vertexPerQuad>& characterQuad, std::shared_ptr<Texture> texture);
private:
void loadShader() override;
void flush() override;
void startBatch() override;
void nextBatch() override;
private:
void loadShader() override;
void flush() override;
void startBatch() override;
void nextBatch() override;
// CPU quad vertices
std::unique_ptr<CharacterVertex[]> m_vertexBufferBase;
CharacterVertex* m_vertexBufferPtr { nullptr };
};
// CPU quad vertices
std::unique_ptr<CharacterVertex[]> m_vertexBufferBase;
CharacterVertex* m_vertexBufferPtr { nullptr };
};
} // namespace Inferno

446
src/inferno/render/shader.cpp
Unescape View File

@ -12,259 +12,261 @@
namespace Inferno {
Shader::Shader(const std::string& name)
: m_name(std::move(name)),
m_id(0)
{
// Get file contents
std::string vertexSrc = File::read(name + ".vert");
std::string fragmentSrc = File::read(name + ".frag");
// Compile shaders
uint32_t vertexID = compileShader(GL_VERTEX_SHADER, vertexSrc.c_str());
uint32_t fragmentID = compileShader(GL_FRAGMENT_SHADER, fragmentSrc.c_str());
// Link shaders
if (vertexID > 0 && fragmentID > 0) {
m_id = linkShader(vertexID, fragmentID);
}
// Clear resources
else if (vertexID > 0) glDeleteShader(vertexID);
else if (fragmentID > 0) glDeleteShader(fragmentID);
Shader::Shader(const std::string& name)
: m_name(std::move(name))
, m_id(0)
{
// Get file contents
std::string vertexSrc = File::read(name + ".vert");
std::string fragmentSrc = File::read(name + ".frag");
// Compile shaders
uint32_t vertexID = compileShader(GL_VERTEX_SHADER, vertexSrc.c_str());
uint32_t fragmentID = compileShader(GL_FRAGMENT_SHADER, fragmentSrc.c_str());
// Link shaders
if (vertexID > 0 && fragmentID > 0) {
m_id = linkShader(vertexID, fragmentID);
}
Shader::~Shader()
{
if (m_id > 0) {
glDeleteProgram(m_id);
m_id = 0;
}
}
int32_t Shader::findUniform(const std::string& name) const
{
int32_t location = glGetUniformLocation(m_id, name.c_str());
VERIFY(location != -1, "Shader could not find uniform '{}'", name);
return location;
}
void Shader::setInt(const std::string& name, int value)
{
// Set uniform int
glUniform1i(findUniform(name), value);
}
void Shader::setInt(const std::string& name, int* values, uint32_t count)
{
// Set uniform int array
glUniform1iv(findUniform(name), count, values);
}
void Shader::setFloat(const std::string& name, float value) const
{
// Set uniform float
glUniform1f(findUniform(name), value);
}
void Shader::setFloat(const std::string& name, float v1, float v2, float v3, float v4) const
{
// Set uniform vec4 data
glUniform4f(findUniform(name), v1, v2, v3, v4);
}
void Shader::setFloat(const std::string& name, glm::vec2 value) const
{
// Set uniform vec2 data
glUniform2f(findUniform(name), value.x, value.y);
}
void Shader::setFloat(const std::string& name, glm::vec3 value) const
{
// Set uniform vec3 data
glUniform3f(findUniform(name), value.x, value.y, value.z);
// Clear resources
else if (vertexID > 0)
glDeleteShader(vertexID);
else if (fragmentID > 0)
glDeleteShader(fragmentID);
}
Shader::~Shader()
{
if (m_id > 0) {
glDeleteProgram(m_id);
m_id = 0;
}
void Shader::setFloat(const std::string& name, glm::vec4 value) const
{
// Set uniform vec4 data
glUniform4f(findUniform(name), value.x, value.y, value.z, value.w);
}
int32_t Shader::findUniform(const std::string& name) const
{
int32_t location = glGetUniformLocation(m_id, name.c_str());
VERIFY(location != -1, "Shader could not find uniform '{}'", name);
return location;
}
void Shader::setInt(const std::string& name, int value)
{
// Set uniform int
glUniform1i(findUniform(name), value);
}
void Shader::setInt(const std::string& name, int* values, uint32_t count)
{
// Set uniform int array
glUniform1iv(findUniform(name), count, values);
}
void Shader::setFloat(const std::string& name, float value) const
{
// Set uniform float
glUniform1f(findUniform(name), value);
}
void Shader::setFloat(const std::string& name, float v1, float v2, float v3, float v4) const
{
// Set uniform vec4 data
glUniform4f(findUniform(name), v1, v2, v3, v4);
}
void Shader::setFloat(const std::string& name, glm::vec2 value) const
{
// Set uniform vec2 data
glUniform2f(findUniform(name), value.x, value.y);
}
void Shader::setFloat(const std::string& name, glm::vec3 value) const
{
// Set uniform vec3 data
glUniform3f(findUniform(name), value.x, value.y, value.z);
}
void Shader::setFloat(const std::string& name, glm::vec4 value) const
{
// Set uniform vec4 data
glUniform4f(findUniform(name), value.x, value.y, value.z, value.w);
}
void Shader::setFloat(const std::string& name, glm::mat3 matrix) const
{
// Set uniform mat3 data
glUniformMatrix3fv(findUniform(name), 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::setFloat(const std::string& name, glm::mat4 matrix) const
{
// Set uniform mat4 data
glUniformMatrix4fv(findUniform(name), 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::bind() const
{
glUseProgram(m_id);
}
void Shader::unbind() const
{
glUseProgram(0);
}
uint32_t Shader::compileShader(int32_t type, const char* source) const
{
// Create new shader
uint32_t shader = 0;
shader = glCreateShader(type);
// Attach shader source to shader object
glShaderSource(shader, 1, &source, nullptr);
// Compile shader
glCompileShader(shader);
// Check compilation status
if (checkStatus(shader) == GL_TRUE) {
return shader;
}
void Shader::setFloat(const std::string& name, glm::mat3 matrix) const
{
// Set uniform mat3 data
glUniformMatrix3fv(findUniform(name), 1, GL_FALSE, glm::value_ptr(matrix));
// On fail
glDeleteShader(shader);
return 0;
}
uint32_t Shader::linkShader(uint32_t vertex, uint32_t fragment) const
{
// Create new shader program
uint32_t shaderProgram = 0;
shaderProgram = glCreateProgram();
// Attach both shaders to the shader program
glAttachShader(shaderProgram, vertex);
glAttachShader(shaderProgram, fragment);
// Setup vertex attributes
glBindAttribLocation(shaderProgram, 0, "a_position");
// Link the shaders
glLinkProgram(shaderProgram);
// Clear resources
glDeleteShader(vertex);
glDeleteShader(fragment);
// Check linking status
if (checkStatus(shaderProgram, true) == GL_TRUE) {
return shaderProgram;
}
void Shader::setFloat(const std::string& name, glm::mat4 matrix) const
{
// Set uniform mat4 data
glUniformMatrix4fv(findUniform(name), 1, GL_FALSE, glm::value_ptr(matrix));
}
// On fail
glDeleteProgram(shaderProgram);
return 0;
}
void Shader::bind() const
{
glUseProgram(m_id);
}
int32_t Shader::checkStatus(uint32_t check, bool isProgram) const
{
int32_t success;
int32_t maxLength = 0;
std::vector<char> infoLog;
void Shader::unbind() const
{
glUseProgram(0);
}
// Get the compilation/linking status
!isProgram
? glGetShaderiv(check, GL_COMPILE_STATUS, &success)
: glGetProgramiv(check, GL_LINK_STATUS, &success);
uint32_t Shader::compileShader(int32_t type, const char* source) const
{
// Create new shader
uint32_t shader = 0;
shader = glCreateShader(type);
// Attach shader source to shader object
glShaderSource(shader, 1, &source, nullptr);
// Compile shader
glCompileShader(shader);
// Check compilation status
if (checkStatus(shader) == GL_TRUE) {
return shader;
}
// On fail
glDeleteShader(shader);
return 0;
}
uint32_t Shader::linkShader(uint32_t vertex, uint32_t fragment) const
{
// Create new shader program
uint32_t shaderProgram = 0;
shaderProgram = glCreateProgram();
// Attach both shaders to the shader program
glAttachShader(shaderProgram, vertex);
glAttachShader(shaderProgram, fragment);
// Setup vertex attributes
glBindAttribLocation(shaderProgram, 0, "a_position");
// Link the shaders
glLinkProgram(shaderProgram);
// Clear resources
glDeleteShader(vertex);
glDeleteShader(fragment);
// Check linking status
if (checkStatus(shaderProgram, true) == GL_TRUE) {
return shaderProgram;
}
// On fail
glDeleteProgram(shaderProgram);
return 0;
}
int32_t Shader::checkStatus(uint32_t check, bool isProgram) const
{
int32_t success;
int32_t maxLength = 0;
std::vector<char> infoLog;
// Get the compilation/linking status
if (success != GL_TRUE) {
// Get max length of the log including \0 terminator
!isProgram
? glGetShaderiv(check, GL_COMPILE_STATUS, &success)
: glGetProgramiv(check, GL_LINK_STATUS, &success);
if (success != GL_TRUE) {
// Get max length of the log including \0 terminator
!isProgram
? glGetShaderiv(check, GL_INFO_LOG_LENGTH, &maxLength)
: glGetProgramiv(check, GL_INFO_LOG_LENGTH, &maxLength);
? glGetShaderiv(check, GL_INFO_LOG_LENGTH, &maxLength)
: glGetProgramiv(check, GL_INFO_LOG_LENGTH, &maxLength);
// Reserve data for the log
infoLog.reserve(maxLength);
// Reserve data for the log
infoLog.reserve(maxLength);
// Retrieve the error message
!isProgram
? glGetShaderInfoLog(check, maxLength, nullptr, &infoLog[0])
: glGetProgramInfoLog(check, maxLength, nullptr, &infoLog[0]);
// Retrieve the error message
!isProgram
? glGetShaderInfoLog(check, maxLength, nullptr, &infoLog[0])
: glGetProgramInfoLog(check, maxLength, nullptr, &infoLog[0]);
warn() << "Shader " << infoLog.data();
}
warn() << "Shader " << infoLog.data();
}
VERIFY(success == GL_TRUE, "Shader program creation failed!");
VERIFY(success == GL_TRUE, "Shader program creation failed!");
return success;
}
return success;
}
// -----------------------------------------
ShaderManager::ShaderManager(s)
{
info() << "ShaderManager initialized";
}
ShaderManager::ShaderManager(s)
{
info() << "ShaderManager initialized";
}
ShaderManager::~ShaderManager()
{
}
ShaderManager::~ShaderManager()
{
}
void ShaderManager::add(const std::string& name, std::shared_ptr<Shader> shader)
{
// Construct (key, value) pair and insert it into the unordered_map
m_shaderList.emplace(std::move(name), std::move(shader));
}
std::shared_ptr<Shader> ShaderManager::load(const std::string& name)
{
if (exists(name)) {
return get(name);
}
void ShaderManager::add(const std::string& name, std::shared_ptr<Shader> shader)
{
// Construct (key, value) pair and insert it into the unordered_map
m_shaderList.emplace(std::move(name), std::move(shader));
}
std::shared_ptr<Shader> shader = std::make_shared<Shader>(name);
add(name, shader);
std::shared_ptr<Shader> ShaderManager::load(const std::string& name)
{
if (exists(name)) {
return get(name);
}
std::shared_ptr<Shader> ShaderManager::load(const std::string& vertexSource,
const std::string& fragmentSource)
{
std::string name = computeName(vertexSource, fragmentSource);
return load(name);
std::shared_ptr<Shader> shader = std::make_shared<Shader>(name);
add(name, shader);
return get(name);
}
std::shared_ptr<Shader> ShaderManager::load(const std::string& vertexSource,
const std::string& fragmentSource)
{
std::string name = computeName(vertexSource, fragmentSource);
return load(name);
}
std::shared_ptr<Shader> ShaderManager::get(const std::string& name)
{
return exists(name) ? m_shaderList.at(name) : nullptr;
}
bool ShaderManager::exists(const std::string& name)
{
return m_shaderList.find(name) != m_shaderList.end();
}
void ShaderManager::remove(const std::string& name)
{
if (exists(name)) {
m_shaderList.erase(name);
}
}
std::shared_ptr<Shader> ShaderManager::get(const std::string& name)
{
return exists(name) ? m_shaderList.at(name) : nullptr;
void ShaderManager::remove(std::shared_ptr<Shader> shader)
{
if (exists(shader->name())) {
m_shaderList.erase(shader->name());
}
}
bool ShaderManager::exists(const std::string& name)
{
return m_shaderList.find(name) != m_shaderList.end();
}
std::string ShaderManager::computeName(const std::string& vertexSource,
const std::string& fragmentSource)
{
auto vertexPos = vertexSource.find_last_of('.');
auto fragmentPos = fragmentSource.find_last_of('.');
void ShaderManager::remove(const std::string& name)
{
if (exists(name)) {
m_shaderList.erase(name);
}
}
VERIFY(vertexPos != std::string::npos, "Shader did not have file extension: '{}'", vertexSource);
VERIFY(fragmentPos != std::string::npos, "Shader did not have file extension: '{}'", fragmentSource);
void ShaderManager::remove(std::shared_ptr<Shader> shader)
{
if (exists(shader->name())) {
m_shaderList.erase(shader->name());
}
}
auto vertexName = vertexSource.substr(0, vertexPos);
auto fragmentName = vertexSource.substr(0, fragmentPos);
std::string ShaderManager::computeName(const std::string& vertexSource,
const std::string& fragmentSource)
{
auto vertexPos = vertexSource.find_last_of('.');
auto fragmentPos = fragmentSource.find_last_of('.');
VERIFY(vertexName == fragmentName, "Shader names did not match: {} {}", vertexSource, fragmentSource);
VERIFY(vertexPos != std::string::npos, "Shader did not have file extension: '{}'", vertexSource);
VERIFY(fragmentPos != std::string::npos, "Shader did not have file extension: '{}'", fragmentSource);
auto vertexName = vertexSource.substr(0, vertexPos);
auto fragmentName = vertexSource.substr(0, fragmentPos);
VERIFY(vertexName == fragmentName, "Shader names did not match: {} {}", vertexSource, fragmentSource);
return vertexName;
}
return vertexName;
}
} // namespace Inferno

114
src/inferno/render/shader.h
Unescape View File

@ -10,62 +10,62 @@
namespace Inferno {
class Shader {
public:
Shader(const std::string& name);
virtual ~Shader();
int32_t findUniform(const std::string& name) const;
void setInt(const std::string& name, int value);
void setInt(const std::string& name, int* values, uint32_t count);
void setFloat(const std::string& name, float value) const;
void setFloat(const std::string& name, float v1, float v2, float v3, float v4) const;
void setFloat(const std::string& name, glm::vec2 value) const;
void setFloat(const std::string& name, glm::vec3 value) const;
void setFloat(const std::string& name, glm::vec4 value) const;
void setFloat(const std::string& name, glm::mat3 matrix) const;
void setFloat(const std::string& name, glm::mat4 matrix) const;
void bind() const;
void unbind() const;
inline std::string name() const { return m_name; }
inline uint32_t id() const { return m_id; }
protected:
uint32_t compileShader(int32_t type, const char* shaderSource) const;
uint32_t linkShader(uint32_t vertex, uint32_t fragment) const;
int32_t checkStatus(uint32_t check, bool isProgram = false) const;
private:
std::string m_name;
uint32_t m_id;
};
// -------------------------------------
class ShaderManager final : public ruc::Singleton<ShaderManager> {
public:
ShaderManager(s);
virtual ~ShaderManager();
void add(const std::string& name, std::shared_ptr<Shader> shader);
std::shared_ptr<Shader> load(const std::string& name);
std::shared_ptr<Shader> load(const std::string& vertexSource,
const std::string& fragmentSource);
std::shared_ptr<Shader> get(const std::string& name);
bool exists(const std::string& name);
void remove(const std::string& name);
void remove(std::shared_ptr<Shader> shader);
protected:
std::string computeName(const std::string& vertexSource,
const std::string& fragmentSource);
private:
std::unordered_map<std::string, std::shared_ptr<Shader>> m_shaderList;
};
class Shader {
public:
Shader(const std::string& name);
virtual ~Shader();
int32_t findUniform(const std::string& name) const;
void setInt(const std::string& name, int value);
void setInt(const std::string& name, int* values, uint32_t count);
void setFloat(const std::string& name, float value) const;
void setFloat(const std::string& name, float v1, float v2, float v3, float v4) const;
void setFloat(const std::string& name, glm::vec2 value) const;
void setFloat(const std::string& name, glm::vec3 value) const;
void setFloat(const std::string& name, glm::vec4 value) const;
void setFloat(const std::string& name, glm::mat3 matrix) const;
void setFloat(const std::string& name, glm::mat4 matrix) const;
void bind() const;
void unbind() const;
inline std::string name() const { return m_name; }
inline uint32_t id() const { return m_id; }
protected:
uint32_t compileShader(int32_t type, const char* shaderSource) const;
uint32_t linkShader(uint32_t vertex, uint32_t fragment) const;
int32_t checkStatus(uint32_t check, bool isProgram = false) const;
private:
std::string m_name;
uint32_t m_id;
};
// -------------------------------------
class ShaderManager final : public ruc::Singleton<ShaderManager> {
public:
ShaderManager(s);
virtual ~ShaderManager();
void add(const std::string& name, std::shared_ptr<Shader> shader);
std::shared_ptr<Shader> load(const std::string& name);
std::shared_ptr<Shader> load(const std::string& vertexSource,
const std::string& fragmentSource);
std::shared_ptr<Shader> get(const std::string& name);
bool exists(const std::string& name);
void remove(const std::string& name);
void remove(std::shared_ptr<Shader> shader);
protected:
std::string computeName(const std::string& vertexSource,
const std::string& fragmentSource);
private:
std::unordered_map<std::string, std::shared_ptr<Shader>> m_shaderList;
};
} // namespace Inferno

242
src/inferno/render/texture.cpp
Unescape View File

@ -12,146 +12,146 @@
namespace Inferno {
Texture::Texture(const std::string& path)
: m_path(std::move(path))
{
int width;
int height;
int channels;
// Load image data
stbi_set_flip_vertically_on_load(1);
unsigned char* data = stbi_load(path.c_str(), &width, &height, &channels, STBI_default);
VERIFY(data, "Failed to load image: '{}'", path);
m_width = width;
m_height = height;
if (channels == 4) {
m_internalFormat = GL_RGBA8;
m_dataFormat = GL_RGBA;
}
else if (channels == 3) {
m_internalFormat = GL_RGB8;
m_dataFormat = GL_RGB;
}
create(data);
// Clean resources
stbi_image_free(data);
}
Texture::Texture(const std::string& path)
: m_path(std::move(path))
{
int width;
int height;
int channels;
Texture::~Texture()
{
glDeleteTextures(1, &m_id);
}
// Load image data
stbi_set_flip_vertically_on_load(1);
unsigned char* data = stbi_load(path.c_str(), &width, &height, &channels, STBI_default);
void Texture::bind(uint32_t unit) const
{
// Set active unit
glActiveTexture(GL_TEXTURE0 + unit);
VERIFY(data, "Failed to load image: '{}'", path);
glBindTexture(GL_TEXTURE_2D, m_id);
m_width = width;
m_height = height;
// Reset unit
glActiveTexture(GL_TEXTURE0);
if (channels == 4) {
m_internalFormat = GL_RGBA8;
m_dataFormat = GL_RGBA;
}
void Texture::unbind() const
{
glBindTexture(GL_TEXTURE_2D, 0);
else if (channels == 3) {
m_internalFormat = GL_RGB8;
m_dataFormat = GL_RGB;
}
void Texture::create(unsigned char* data)
{
m_id = UINT_MAX;
// Create texture object
glGenTextures(1, &m_id);
// Bind texture object
glBindTexture(GL_TEXTURE_2D, m_id);
// Set unpacking of pixel data to byte-alignment,
// this prevents alignment issues when using a single byte for color
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Generate texture
glTexImage2D(
GL_TEXTURE_2D, // Texture target
0, // Midmap level, base starts at level 0
m_internalFormat, // Texture format
m_width, m_height, // Image width/height
0, // Always 0 (legacy)
m_dataFormat, // Texture source format
GL_UNSIGNED_BYTE, // Texture source datatype
data); // Image data
// Set the texture wrapping / filtering options
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // X
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Y
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Minify
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Magnify
// Automatically generate all mipmap levels
glGenerateMipmap(GL_TEXTURE_2D);
// Unbind texture object
glBindTexture(GL_TEXTURE_2D, 0);
}
create(data);
// -----------------------------------------
// Clean resources
stbi_image_free(data);
}
TextureManager::TextureManager(s)
{
info() << "TextureManager initialized";
}
Texture::~Texture()
{
glDeleteTextures(1, &m_id);
}
TextureManager::~TextureManager()
{
}
void Texture::bind(uint32_t unit) const
{
// Set active unit
glActiveTexture(GL_TEXTURE0 + unit);
void TextureManager::add(const std::string& path, std::shared_ptr<Texture> texture)
{
// Construct (key, value) pair and insert it into the unordered_map
m_textureList.emplace(std::move(path), std::move(texture));
}
glBindTexture(GL_TEXTURE_2D, m_id);
std::shared_ptr<Texture> TextureManager::load(const std::string& path)
{
if (exists(path)) {
return get(path);
}
// Reset unit
glActiveTexture(GL_TEXTURE0);
}
std::shared_ptr<Texture> texture = std::make_shared<Texture>(path);
add(path, texture);
return get(path);
}
void Texture::unbind() const
{
glBindTexture(GL_TEXTURE_2D, 0);
}
std::shared_ptr<Texture> TextureManager::get(const std::string& path)
{
return exists(path) ? m_textureList.at(path) : nullptr;
}
void Texture::create(unsigned char* data)
{
m_id = UINT_MAX;
// Create texture object
glGenTextures(1, &m_id);
bool TextureManager::exists(const std::string& path)
{
return m_textureList.find(path) != m_textureList.end();
// Bind texture object
glBindTexture(GL_TEXTURE_2D, m_id);
// Set unpacking of pixel data to byte-alignment,
// this prevents alignment issues when using a single byte for color
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Generate texture
glTexImage2D(
GL_TEXTURE_2D, // Texture target
0, // Midmap level, base starts at level 0
m_internalFormat, // Texture format
m_width, m_height, // Image width/height
0, // Always 0 (legacy)
m_dataFormat, // Texture source format
GL_UNSIGNED_BYTE, // Texture source datatype
data); // Image data
// Set the texture wrapping / filtering options
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // X
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Y
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Minify
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Magnify
// Automatically generate all mipmap levels
glGenerateMipmap(GL_TEXTURE_2D);
// Unbind texture object
glBindTexture(GL_TEXTURE_2D, 0);
}
// -----------------------------------------
TextureManager::TextureManager(s)
{
info() << "TextureManager initialized";
}
TextureManager::~TextureManager()
{
}
void TextureManager::add(const std::string& path, std::shared_ptr<Texture> texture)
{
// Construct (key, value) pair and insert it into the unordered_map
m_textureList.emplace(std::move(path), std::move(texture));
}
std::shared_ptr<Texture> TextureManager::load(const std::string& path)
{
if (exists(path)) {
return get(path);
}
void TextureManager::remove(const std::string& path)
{
if (exists(path)) {
m_textureList.erase(path);
}
std::shared_ptr<Texture> texture = std::make_shared<Texture>(path);
add(path, texture);
return get(path);
}
std::shared_ptr<Texture> TextureManager::get(const std::string& path)
{
return exists(path) ? m_textureList.at(path) : nullptr;
}
bool TextureManager::exists(const std::string& path)
{
return m_textureList.find(path) != m_textureList.end();
}
void TextureManager::remove(const std::string& path)
{
if (exists(path)) {
m_textureList.erase(path);
}
}
void TextureManager::remove(std::shared_ptr<Texture> texture)
{
if (exists(texture->path())) {
m_textureList.erase(texture->path());
}
void TextureManager::remove(std::shared_ptr<Texture> texture)
{
if (exists(texture->path())) {
m_textureList.erase(texture->path());
}
}
} // namespace Inferno

90
src/inferno/render/texture.h
Unescape View File

@ -9,50 +9,50 @@
namespace Inferno {
class Texture {
public:
Texture(const std::string& path);
virtual ~Texture();
void bind(uint32_t unit = 0) const;
void unbind() const;
inline std::string path() const { return m_path; }
inline uint32_t width() const { return m_width; }
inline uint32_t height() const { return m_height; }
inline uint32_t id() const { return m_id; }
inline uint32_t internalFormat() const { return m_internalFormat; }
inline uint32_t dataFormat() const { return m_dataFormat; }
protected:
void create(unsigned char* data);
private:
std::string m_path;
uint32_t m_width;
uint32_t m_height;
uint32_t m_id;
uint32_t m_internalFormat;
uint32_t m_dataFormat;
};
// -------------------------------------
class TextureManager final : public ruc::Singleton<TextureManager> {
public:
TextureManager(s);
virtual ~TextureManager();
void add(const std::string& path, std::shared_ptr<Texture> texture);
std::shared_ptr<Texture> load(const std::string& path);
std::shared_ptr<Texture> get(const std::string& path);
bool exists(const std::string& path);
void remove(const std::string& path);
void remove(std::shared_ptr<Texture> texture);
private:
std::unordered_map<std::string, std::shared_ptr<Texture>> m_textureList;
};
class Texture {
public:
Texture(const std::string& path);
virtual ~Texture();
void bind(uint32_t unit = 0) const;
void unbind() const;
inline std::string path() const { return m_path; }
inline uint32_t width() const { return m_width; }
inline uint32_t height() const { return m_height; }
inline uint32_t id() const { return m_id; }
inline uint32_t internalFormat() const { return m_internalFormat; }
inline uint32_t dataFormat() const { return m_dataFormat; }
protected:
void create(unsigned char* data);
private:
std::string m_path;
uint32_t m_width;
uint32_t m_height;
uint32_t m_id;
uint32_t m_internalFormat;
uint32_t m_dataFormat;
};
// -------------------------------------
class TextureManager final : public ruc::Singleton<TextureManager> {
public:
TextureManager(s);
virtual ~TextureManager();
void add(const std::string& path, std::shared_ptr<Texture> texture);
std::shared_ptr<Texture> load(const std::string& path);
std::shared_ptr<Texture> get(const std::string& path);
bool exists(const std::string& path);
void remove(const std::string& path);
void remove(std::shared_ptr<Texture> texture);
private:
std::unordered_map<std::string, std::shared_ptr<Texture>> m_textureList;
};
} // namespace Inferno

212
src/inferno/scene/scene.cpp
Unescape View File

@ -17,111 +17,111 @@
namespace Inferno {
void Scene::initialize()
{
// Initialize
// ---------------------------------
m_registry = std::make_shared<entt::registry>();
TransformSystem::the().setRegistry(m_registry);
CameraSystem::the().setRegistry(m_registry);
RenderSystem::the().setRegistry(m_registry);
ScriptSystem::the().setScene(this);
TextAreaSystem::the().setScene(this);
// Load assets
// ---------------------------------
m_texture = TextureManager::the().load("assets/gfx/test.png");
m_texture2 = TextureManager::the().load("assets/gfx/test-inverted.png");
// Construct entities
// ---------------------------------
uint32_t camera = createEntity("Camera Entity");
auto& cameraTransform = getComponent<TransformComponent>(camera);
// cameraTransform.rotate.z = 0.0f;
// cameraTransform.translate.z = -1.0f;
// addComponent<CameraComponent>(camera, CameraType::Orthographic);
cameraTransform.rotate.z = -1.0f;
cameraTransform.translate.z = 1.0f;
addComponent<CameraComponent>(camera, CameraType::Perspective);
// addComponent<NativeScriptComponent>(camera).bind<CameraController>();
addComponent<LuaScriptComponent>(camera, "assets/lua/cameracontroller.lua");
uint32_t quad = createEntity("Quad");
addComponent<SpriteComponent>(quad, glm::vec4 { 1.0f, 1.0f, 1.0f, 1.0f }, m_texture);
uint32_t quad2 = createEntity("Quad 2");
auto& quad2Transform = getComponent<TransformComponent>(quad2);
quad2Transform.translate.x = 1.1f;
addComponent<SpriteComponent>(quad2, glm::vec4 { 0.5f, 0.6f, 0.8f, 1.0f }, m_texture);
uint32_t quad3 = createEntity("Quad 3");
auto& quad3Transform = getComponent<TransformComponent>(quad3);
quad3Transform.translate.x = 2.2f;
addComponent<SpriteComponent>(quad3, glm::vec4 { 1.0f, 1.0f, 1.0f, 1.0f }, m_texture2);
uint32_t text = createEntity("Text");
addComponent<TextAreaComponent>(text, "HelloWorld!", "assets/fnt/dejavu-sans", 0, 150, 3);
// addComponent<TextAreaComponent>(text, "@#$%^&*()qygij!", "assets/fnt/dejavu-sans-test", 0, 150, 3);
info() << "Scene initialized";
}
void Scene::update(float deltaTime)
{
ScriptSystem::the().update(deltaTime);
TransformSystem::the().update();
CameraSystem::the().update();
}
void Scene::render()
{
RenderSystem::the().render();
TextAreaSystem::the().render();
}
void Scene::destroy()
{
ScriptSystem::destroy();
RenderSystem::destroy();
CameraSystem::destroy();
TransformSystem::destroy();
}
uint32_t Scene::createEntity(const std::string& name)
{
uint32_t entity = static_cast<uint32_t>(m_registry->create());
addComponent<TagComponent>(entity, name.empty() ? "Unnamed Entity" : name);
addComponent<TransformComponent>(entity);
return entity;
}
void Scene::destroyEntity(uint32_t entity)
{
ScriptSystem::the().cleanup(entity);
m_registry->destroy(entt::entity { entity });
}
glm::mat4 Scene::cameraProjectionView()
{
return CameraSystem::the().projectionView();
}
void Scene::validEntity(uint32_t entity) const
{
VERIFY(m_registry->valid(entt::entity { entity }), "Entity is not valid");
}
// -------------------------------------
const LogStream& operator<<(const LogStream& stream, entt::entity entity)
{
return stream << static_cast<uint32_t>(entity);
}
void Scene::initialize()
{
// Initialize
// ---------------------------------
m_registry = std::make_shared<entt::registry>();
TransformSystem::the().setRegistry(m_registry);
CameraSystem::the().setRegistry(m_registry);
RenderSystem::the().setRegistry(m_registry);
ScriptSystem::the().setScene(this);
TextAreaSystem::the().setScene(this);
// Load assets
// ---------------------------------
m_texture = TextureManager::the().load("assets/gfx/test.png");
m_texture2 = TextureManager::the().load("assets/gfx/test-inverted.png");
// Construct entities
// ---------------------------------
uint32_t camera = createEntity("Camera Entity");
auto& cameraTransform = getComponent<TransformComponent>(camera);
// cameraTransform.rotate.z = 0.0f;
// cameraTransform.translate.z = -1.0f;
// addComponent<CameraComponent>(camera, CameraType::Orthographic);
cameraTransform.rotate.z = -1.0f;
cameraTransform.translate.z = 1.0f;
addComponent<CameraComponent>(camera, CameraType::Perspective);
// addComponent<NativeScriptComponent>(camera).bind<CameraController>();
addComponent<LuaScriptComponent>(camera, "assets/lua/cameracontroller.lua");
uint32_t quad = createEntity("Quad");
addComponent<SpriteComponent>(quad, glm::vec4 { 1.0f, 1.0f, 1.0f, 1.0f }, m_texture);
uint32_t quad2 = createEntity("Quad 2");
auto& quad2Transform = getComponent<TransformComponent>(quad2);
quad2Transform.translate.x = 1.1f;
addComponent<SpriteComponent>(quad2, glm::vec4 { 0.5f, 0.6f, 0.8f, 1.0f }, m_texture);
uint32_t quad3 = createEntity("Quad 3");
auto& quad3Transform = getComponent<TransformComponent>(quad3);
quad3Transform.translate.x = 2.2f;
addComponent<SpriteComponent>(quad3, glm::vec4 { 1.0f, 1.0f, 1.0f, 1.0f }, m_texture2);
uint32_t text = createEntity("Text");
addComponent<TextAreaComponent>(text, "HelloWorld!", "assets/fnt/dejavu-sans", 0, 150, 3);
// addComponent<TextAreaComponent>(text, "@#$%^&*()qygij!", "assets/fnt/dejavu-sans-test", 0, 150, 3);
info() << "Scene initialized";
}
void Scene::update(float deltaTime)
{
ScriptSystem::the().update(deltaTime);
TransformSystem::the().update();
CameraSystem::the().update();
}
void Scene::render()
{
RenderSystem::the().render();
TextAreaSystem::the().render();
}
void Scene::destroy()
{
ScriptSystem::destroy();
RenderSystem::destroy();
CameraSystem::destroy();
TransformSystem::destroy();
}
uint32_t Scene::createEntity(const std::string& name)
{
uint32_t entity = static_cast<uint32_t>(m_registry->create());
addComponent<TagComponent>(entity, name.empty() ? "Unnamed Entity" : name);
addComponent<TransformComponent>(entity);
return entity;
}
void Scene::destroyEntity(uint32_t entity)
{
ScriptSystem::the().cleanup(entity);
m_registry->destroy(entt::entity { entity });
}
glm::mat4 Scene::cameraProjectionView()
{
return CameraSystem::the().projectionView();
}
void Scene::validEntity(uint32_t entity) const
{
VERIFY(m_registry->valid(entt::entity { entity }), "Entity is not valid");
}
// -------------------------------------
const LogStream& operator<<(const LogStream& stream, entt::entity entity)
{
return stream << static_cast<uint32_t>(entity);
}
} // namespace Inferno

126
src/inferno/scene/scene.h
Unescape View File

@ -10,73 +10,73 @@
namespace Inferno {
class Camera;
class Texture;
class Scene {
public:
void initialize();
void update(float deltaTime);
void render();
void destroy();
uint32_t createEntity(const std::string& name = "");
void destroyEntity(uint32_t entity);
glm::mat4 cameraProjectionView();
void validEntity(uint32_t entity) const;
template<typename... T>
[[nodiscard]] bool hasComponent(uint32_t entity) const
{
validEntity(entity);
return m_registry->has<T...>(entt::entity { entity });
}
template<typename... T>
[[nodiscard]] bool anyComponent(uint32_t entity) const
{
validEntity(entity);
return m_registry->any<T...>(entt::entity { entity });
}
// @Todo Should replace be allowed? could trigger memory leaks with nativescript
template<typename T, typename... P>
T& addComponent(uint32_t entity, P&&... parameters) const
{
validEntity(entity);
return m_registry->emplace_or_replace<T>(entt::entity { entity }, std::forward<P>(parameters)...);
};
template<typename T>
size_t removeComponent(uint32_t entity) const
{
validEntity(entity);
return m_registry->remove_if_exists<T>(entt::entity { entity });
}
// @Todo Should replace be allowed? could trigger memory leaks with nativescript
template<typename T, typename... P>
T& getComponent(uint32_t entity, P&&... parameters) const
{
validEntity(entity);
return m_registry->get_or_emplace<T>(entt::entity { entity }, std::forward<P>(parameters)...);
}
// const entt::registry& registry() const { return m_registry; }
std::shared_ptr<entt::registry> registry() const { return m_registry; }
private:
std::shared_ptr<Texture> m_texture;
std::shared_ptr<Texture> m_texture2;
std::shared_ptr<entt::registry> m_registry;
class Camera;
class Texture;
class Scene {
public:
void initialize();
void update(float deltaTime);
void render();
void destroy();
uint32_t createEntity(const std::string& name = "");
void destroyEntity(uint32_t entity);
glm::mat4 cameraProjectionView();
void validEntity(uint32_t entity) const;
template<typename... T>
[[nodiscard]] bool hasComponent(uint32_t entity) const
{
validEntity(entity);
return m_registry->has<T...>(entt::entity { entity });
}
template<typename... T>
[[nodiscard]] bool anyComponent(uint32_t entity) const
{
validEntity(entity);
return m_registry->any<T...>(entt::entity { entity });
}
// @Todo Should replace be allowed? could trigger memory leaks with nativescript
template<typename T, typename... P>
T& addComponent(uint32_t entity, P&&... parameters) const
{
validEntity(entity);
return m_registry->emplace_or_replace<T>(entt::entity { entity }, std::forward<P>(parameters)...);
};
template<typename T>
size_t removeComponent(uint32_t entity) const
{
validEntity(entity);
return m_registry->remove_if_exists<T>(entt::entity { entity });
}
// @Todo Should replace be allowed? could trigger memory leaks with nativescript
template<typename T, typename... P>
T& getComponent(uint32_t entity, P&&... parameters) const
{
validEntity(entity);
return m_registry->get_or_emplace<T>(entt::entity { entity }, std::forward<P>(parameters)...);
}
// const entt::registry& registry() const { return m_registry; }
std::shared_ptr<entt::registry> registry() const { return m_registry; }
private:
std::shared_ptr<Texture> m_texture;
std::shared_ptr<Texture> m_texture2;
std::shared_ptr<entt::registry> m_registry;
};
// -----------------------------------------
const LogStream& operator<<(const LogStream& stream, entt::entity handle);
const LogStream& operator<<(const LogStream& stream, entt::entity handle);
} // namespace Inferno

224
src/inferno/script/cameracontroller.cpp
Unescape View File

@ -1,4 +1,4 @@
#include "glm/ext/matrix_transform.hpp" // glm::radians
#include "glm/ext/matrix_transform.hpp" // glm::radians
#include "inferno/component/cameracomponent.h"
#include "inferno/component/transformcomponent.h"
@ -8,115 +8,117 @@
namespace Inferno {
void CameraController::updateOrthographic(float deltaTime)
{
// Update camera rotation
float cameraRotateSpeed = ROTATE_SPEED * deltaTime;
if (Input::isKeyPressed(keyCode("GLFW_KEY_Q"))) {
transform->rotate.z -= cameraRotateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_E"))) {
transform->rotate.z += cameraRotateSpeed;
}
if (transform->rotate.z > 180.0f) {
transform->rotate.z -= 360.0f;
}
else if (transform->rotate.z <= -180.0f) {
transform->rotate.z += 360.0f;
}
// Update camera translation
float cameraTranslateSpeed = TRANSLATE_SPEED * deltaTime;
// WASD movement
if (Input::isKeyPressed(keyCode("GLFW_KEY_W"))) {
transform->translate.x += -sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y += cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_S"))) {
transform->translate.x -= -sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y -= cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_A"))) {
transform->translate.x -= cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y -= sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_D"))) {
transform->translate.x += cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y += sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
// Update camera zoom
float zoomSpeed = ZOOM_SENSITIVITY * deltaTime;
if (Input::isKeyPressed(keyCode("GLFW_KEY_EQUAL"))) {
m_camera->zoomLevel -= zoomSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_MINUS"))) {
m_camera->zoomLevel += zoomSpeed;
}
m_camera->zoomLevel = std::max(m_camera->zoomLevel, 0.25f);
m_camera->zoomLevel = std::min(m_camera->zoomLevel, 10.0f);
}
void CameraController::updatePerspective(float deltaTime)
{
// Get mouse movement offset compared to last frame
float xOffset = Input::getXOffset() * MOUSE_SENSITIVITY;
float yOffset = Input::getYOffset() * MOUSE_SENSITIVITY;
m_camera->yaw += xOffset;
m_camera->pitch += yOffset;
// Prevent gimbal lock
if (m_camera->pitch > 89.0f) m_camera->pitch = 89.0f;
if (m_camera->pitch < -89.0f) m_camera->pitch = -89.0f;
// Update camera rotation, by calculating direction vector via yaw and pitch
transform->rotate = {
cos(glm::radians(m_camera->pitch)) * cos(glm::radians(m_camera->yaw)),
sin(glm::radians(m_camera->pitch)),
cos(glm::radians(m_camera->pitch)) * sin(glm::radians(m_camera->yaw))
};
transform->rotate = glm::normalize(transform->rotate);
// The direction vector is based on
// Camera direction (z): normalize(position - target)
// Right axis (x): normalize(cross(up, direction))
// Up axis (y): cross(direction, right)
// Source: https://learnopengl.com/img/getting-started/camera_axes.png
// Cross = combination of two vectors in 3D space,
// where result is always perpendicular to both of the vectors
// Update camera translation
float cameraSpeed = TRANSLATE_SPEED * deltaTime;
// WASD movement
if (Input::isKeyPressed(keyCode("GLFW_KEY_W"))) {
transform->translate += transform->rotate * cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_S"))) {
transform->translate -= transform->rotate * cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_A"))) {
transform->translate -= glm::normalize(glm::cross(transform->rotate, m_camera->up)) * cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_D"))) {
transform->translate += glm::normalize(glm::cross(transform->rotate, m_camera->up)) * cameraSpeed;
}
// Up / down movement
if (Input::isKeyPressed(keyCode("GLFW_KEY_SPACE"))) {
transform->translate.y += cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_LEFT_SHIFT"))) {
transform->translate.y -= cameraSpeed;
}
void CameraController::updateOrthographic(float deltaTime)
{
// Update camera rotation
float cameraRotateSpeed = ROTATE_SPEED * deltaTime;
if (Input::isKeyPressed(keyCode("GLFW_KEY_Q"))) {
transform->rotate.z -= cameraRotateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_E"))) {
transform->rotate.z += cameraRotateSpeed;
}
if (transform->rotate.z > 180.0f) {
transform->rotate.z -= 360.0f;
}
else if (transform->rotate.z <= -180.0f) {
transform->rotate.z += 360.0f;
}
// Update camera translation
float cameraTranslateSpeed = TRANSLATE_SPEED * deltaTime;
// WASD movement
if (Input::isKeyPressed(keyCode("GLFW_KEY_W"))) {
transform->translate.x += -sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y += cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_S"))) {
transform->translate.x -= -sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y -= cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_A"))) {
transform->translate.x -= cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y -= sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_D"))) {
transform->translate.x += cos(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
transform->translate.y += sin(glm::radians(transform->rotate.z)) * cameraTranslateSpeed;
}
// Update camera zoom
float zoomSpeed = ZOOM_SENSITIVITY * deltaTime;
if (Input::isKeyPressed(keyCode("GLFW_KEY_EQUAL"))) {
m_camera->zoomLevel -= zoomSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_MINUS"))) {
m_camera->zoomLevel += zoomSpeed;
}
m_camera->zoomLevel = std::max(m_camera->zoomLevel, 0.25f);
m_camera->zoomLevel = std::min(m_camera->zoomLevel, 10.0f);
}
void CameraController::updatePerspective(float deltaTime)
{
// Get mouse movement offset compared to last frame
float xOffset = Input::getXOffset() * MOUSE_SENSITIVITY;
float yOffset = Input::getYOffset() * MOUSE_SENSITIVITY;
m_camera->yaw += xOffset;
m_camera->pitch += yOffset;
// Prevent gimbal lock
if (m_camera->pitch > 89.0f)
m_camera->pitch = 89.0f;
if (m_camera->pitch < -89.0f)
m_camera->pitch = -89.0f;
// Update camera rotation, by calculating direction vector via yaw and pitch
transform->rotate = {
cos(glm::radians(m_camera->pitch)) * cos(glm::radians(m_camera->yaw)),
sin(glm::radians(m_camera->pitch)),
cos(glm::radians(m_camera->pitch)) * sin(glm::radians(m_camera->yaw))
};
transform->rotate = glm::normalize(transform->rotate);
// The direction vector is based on
// Camera direction (z): normalize(position - target)
// Right axis (x): normalize(cross(up, direction))
// Up axis (y): cross(direction, right)
// Source: https://learnopengl.com/img/getting-started/camera_axes.png
// Cross = combination of two vectors in 3D space,
// where result is always perpendicular to both of the vectors
// Update camera translation
float cameraSpeed = TRANSLATE_SPEED * deltaTime;
// WASD movement
if (Input::isKeyPressed(keyCode("GLFW_KEY_W"))) {
transform->translate += transform->rotate * cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_S"))) {
transform->translate -= transform->rotate * cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_A"))) {
transform->translate -= glm::normalize(glm::cross(transform->rotate, m_camera->up)) * cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_D"))) {
transform->translate += glm::normalize(glm::cross(transform->rotate, m_camera->up)) * cameraSpeed;
}
// Up / down movement
if (Input::isKeyPressed(keyCode("GLFW_KEY_SPACE"))) {
transform->translate.y += cameraSpeed;
}
if (Input::isKeyPressed(keyCode("GLFW_KEY_LEFT_SHIFT"))) {
transform->translate.y -= cameraSpeed;
}
}
} // namespace Inferno

38
src/inferno/script/cameracontroller.h
Unescape View File

@ -10,27 +10,27 @@
namespace Inferno {
struct CameraComponent;
class CameraController final : public NativeScript {
public:
virtual void update(float deltaTime) override
{
m_camera = &getComponent<CameraComponent>();
if (m_camera->type == CameraType::Orthographic) {
updateOrthographic(deltaTime);
}
else if (m_camera->type == CameraType::Perspective) {
updatePerspective(deltaTime);
}
struct CameraComponent;
class CameraController final : public NativeScript {
public:
virtual void update(float deltaTime) override
{
m_camera = &getComponent<CameraComponent>();
if (m_camera->type == CameraType::Orthographic) {
updateOrthographic(deltaTime);
}
else if (m_camera->type == CameraType::Perspective) {
updatePerspective(deltaTime);
}
}
void updateOrthographic(float deltaTime);
void updatePerspective(float deltaTime);
void updateOrthographic(float deltaTime);
void updatePerspective(float deltaTime);
private:
CameraComponent* m_camera { nullptr };
};
private:
CameraComponent* m_camera { nullptr };
};
} // namespace Inferno

128
src/inferno/script/luascript.cpp
Unescape View File

@ -11,69 +11,69 @@
namespace Inferno {
void LuaScript::initialize()
{
// Type registration
// ---------------------------------
Registration::fill(m_state);
// Load libraries
// ---------------------------------
m_state.open_libraries(sol::lib::base, sol::lib::math);
// Component get functions
// ---------------------------------
m_state.set_function("getTagComponent", [this]() -> TagComponent* {
return &m_scene->getComponent<TagComponent>(m_entity);
});
m_state.set_function("getTransformComponent", [this]() -> TransformComponent* {
return &m_scene->getComponent<TransformComponent>(m_entity);
});
m_state.set_function("getCameraComponent", [this]() -> CameraComponent* {
return &m_scene->getComponent<CameraComponent>(m_entity);
});
m_state.set_function("getSpriteComponent", [this]() -> SpriteComponent* {
return &m_scene->getComponent<SpriteComponent>(m_entity);
});
// Load and Initialize script
// ---------------------------------
loadScript();
callFunction("LuaScript", "initialize");
}
void LuaScript::destroy()
{
callFunction("LuaScript", "destroy");
}
void LuaScript::update(float deltaTime)
{
m_state["LuaScript"]["transform"] = &m_scene->getComponent<TransformComponent>(m_entity);
callFunction("LuaScript", "update", deltaTime);
}
void LuaScript::loadScript()
{
std::string script = File::read(m_path);
auto result = m_state.script(script.c_str(),
[](lua_State*, sol::protected_function_result pfr) { return pfr; });
VERIFY(result.valid(), "LuaScript {}", ((sol::error)result).what());
}
sol::table LuaScript::getTable(const char* name)
{
sol::table table = m_state[name];
VERIFY(table.valid(), "LuaScript table does not exist");
return table;
}
void LuaScript::initialize()
{
// Type registration
// ---------------------------------
Registration::fill(m_state);
// Load libraries
// ---------------------------------
m_state.open_libraries(sol::lib::base, sol::lib::math);
// Component get functions
// ---------------------------------
m_state.set_function("getTagComponent", [this]() -> TagComponent* {
return &m_scene->getComponent<TagComponent>(m_entity);
});
m_state.set_function("getTransformComponent", [this]() -> TransformComponent* {
return &m_scene->getComponent<TransformComponent>(m_entity);
});
m_state.set_function("getCameraComponent", [this]() -> CameraComponent* {
return &m_scene->getComponent<CameraComponent>(m_entity);
});
m_state.set_function("getSpriteComponent", [this]() -> SpriteComponent* {
return &m_scene->getComponent<SpriteComponent>(m_entity);
});
// Load and Initialize script
// ---------------------------------
loadScript();
callFunction("LuaScript", "initialize");
}
void LuaScript::destroy()
{
callFunction("LuaScript", "destroy");
}
void LuaScript::update(float deltaTime)
{
m_state["LuaScript"]["transform"] = &m_scene->getComponent<TransformComponent>(m_entity);
callFunction("LuaScript", "update", deltaTime);
}
void LuaScript::loadScript()
{
std::string script = File::read(m_path);
auto result = m_state.script(script.c_str(),
[](lua_State*, sol::protected_function_result pfr) { return pfr; });
VERIFY(result.valid(), "LuaScript {}", ((sol::error)result).what());
}
sol::table LuaScript::getTable(const char* name)
{
sol::table table = m_state[name];
VERIFY(table.valid(), "LuaScript table does not exist");
return table;
}
} // namespace Inferno

54
src/inferno/script/luascript.h
Unescape View File

@ -12,42 +12,42 @@
namespace Inferno {
struct TransformComponent;
struct TransformComponent;
class Scene;
class Scene;
class LuaScript {
public:
void initialize();
void destroy();
void update(float deltaTime);
class LuaScript {
public:
void initialize();
void destroy();
void update(float deltaTime);
void loadScript();
void loadScript();
private:
sol::table getTable(const char* name);
private:
sol::table getTable(const char* name);
template<typename... P>
void callFunction(const char* table, const char* function, P&&... parameters)
{
sol::table solTable = getTable(table);
sol::protected_function solFunction = solTable[function];
template<typename... P>
void callFunction(const char* table, const char* function, P&&... parameters)
{
sol::table solTable = getTable(table);
sol::protected_function solFunction = solTable[function];
// Only call function if it exists
if (solFunction.valid()) {
sol::protected_function_result result = solFunction(solTable, parameters...);
VERIFY(result.valid(), "Lua function {}", ((sol::error)result).what());
}
// Only call function if it exists
if (solFunction.valid()) {
sol::protected_function_result result = solFunction(solTable, parameters...);
VERIFY(result.valid(), "Lua function {}", ((sol::error)result).what());
}
}
sol::state m_state;
std::string m_path = "";
sol::state m_state;
std::string m_path = "";
Scene* m_scene { nullptr };
uint32_t m_entity { 0 };
TransformComponent* transform { nullptr };
Scene* m_scene { nullptr };
uint32_t m_entity { 0 };
TransformComponent* transform { nullptr };
friend class ScriptSystem;
};
friend class ScriptSystem;
};
} // namespace Inferno

38
src/inferno/script/nativescript.h
Unescape View File

@ -4,30 +4,30 @@
namespace Inferno {
struct TransformComponent;
struct TransformComponent;
class NativeScript {
public:
virtual ~NativeScript() {}
class NativeScript {
public:
virtual ~NativeScript() {}
protected:
virtual void initialize() {}
virtual void destroy() {}
virtual void update(float deltaTime) { (void)deltaTime; }
protected:
virtual void initialize() {}
virtual void destroy() {}
virtual void update(float deltaTime) { (void)deltaTime; }
template<typename T>
T& getComponent() const
{
return m_scene->getComponent<T>(m_entity);
}
template<typename T>
T& getComponent() const
{
return m_scene->getComponent<T>(m_entity);
}
TransformComponent* transform { nullptr };
TransformComponent* transform { nullptr };
private:
Scene* m_scene { nullptr };
uint32_t m_entity { 0 };
private:
Scene* m_scene { nullptr };
uint32_t m_entity { 0 };
friend class ScriptSystem;
};
friend class ScriptSystem;
};
} // namespace Inferno

209
src/inferno/script/registration.cpp
Unescape View File

@ -1,7 +1,7 @@
#include "glm/ext/matrix_transform.hpp" // glm::radians
#include "glm/ext/vector_float2.hpp" // glm::vec2
#include "glm/ext/vector_float3.hpp" // glm::vec3
#include "glm/ext/vector_float4.hpp" // glm::vec4
#include "glm/ext/matrix_transform.hpp" // glm::radians
#include "inferno/component/cameracomponent.h"
#include "inferno/component/spritecomponent.h"
@ -13,110 +13,105 @@
namespace Inferno {
void Registration::fill(sol::state_view &state)
{
glm(state);
component(state);
input(state);
}
void Registration::glm(sol::state_view& state)
{
auto glm = state["glm"].get_or_create<sol::table>();
auto vec2 = glm.new_usertype<glm::vec2>(
"vec2",
sol::call_constructor, sol::constructors<glm::vec2(), glm::vec2(glm::vec2), glm::vec2(float), glm::vec2(float, float)>(),
"x", &glm::vec2::x, "y", &glm::vec2::y,
"r", &glm::vec2::r, "g", &glm::vec2::g,
"s", &glm::vec2::s, "t", &glm::vec2::t,
"__add", addition<glm::vec2, float>(),
"__sub", subtraction<glm::vec2, float>(),
"__mul", multiplication<glm::vec2, float>(),
"__div", division<glm::vec2, float>(),
"__tostring", string<glm::vec2>
);
auto vec3 = glm.new_usertype<glm::vec3>(
"vec3",
sol::call_constructor, sol::constructors<glm::vec3(), glm::vec3(glm::vec3), glm::vec3(float), glm::vec3(float, float, float)>(),
"x", &glm::vec3::x, "y", &glm::vec3::y, "z", &glm::vec3::z,
"r", &glm::vec3::r, "g", &glm::vec3::g, "b", &glm::vec3::b,
"s", &glm::vec3::s, "t", &glm::vec3::t, "p", &glm::vec3::p,
"__add", addition<glm::vec3, float>(),
"__sub", subtraction<glm::vec3, float>(),
"__mul", multiplication<glm::vec3, float>(),
"__div", division<glm::vec3, float>(),
"__tostring", string<glm::vec3>
);
auto vec4 = glm.new_usertype<glm::vec4>(
"vec4",
sol::call_constructor, sol::constructors<glm::vec4(), glm::vec4(glm::vec4), glm::vec4(float), glm::vec4(float, float, float, float)>(),
"x", &glm::vec4::x, "y", &glm::vec4::y, "z", &glm::vec4::z, "w", &glm::vec4::w,
"r", &glm::vec4::r, "g", &glm::vec4::g, "b", &glm::vec4::b, "a", &glm::vec4::a,
"s", &glm::vec4::s, "t", &glm::vec4::t, "p", &glm::vec4::p, "q", &glm::vec4::q,
"__add", addition<glm::vec4, float>(),
"__sub", subtraction<glm::vec4, float>(),
"__mul", multiplication<glm::vec4, float>(),
"__div", division<glm::vec4, float>(),
"__tostring", string<glm::vec4>
);
glm.set_function("radians", sol::overload(
[](float v) { return glm::radians(v); },
[](const glm::vec2& v) { return glm::radians(v); },
[](const glm::vec3& v) { return glm::radians(v); },
[](const glm::vec4& v) { return glm::radians(v); }
));
glm.set_function("normalize", sol::overload(
[](const glm::vec2& v) { return glm::normalize(v); },
[](const glm::vec3& v) { return glm::normalize(v); },
[](const glm::vec4& v) { return glm::normalize(v); }
));
glm.set_function("cross", [](const glm::vec3& x, const glm::vec3& y) { return glm::cross(x, y); });
}
void Registration::component(sol::state_view& state)
{
auto tagComponent = state.new_usertype<TagComponent>("TagComponent", sol::no_constructor);
tagComponent["tag"] = &TagComponent::tag;
auto transformComponent = state.new_usertype<TransformComponent>("TransformComponent", sol::no_constructor);
transformComponent["translate"] = &TransformComponent::translate;
transformComponent["rotate"] = &TransformComponent::rotate;
transformComponent["scale"] = &TransformComponent::scale;
transformComponent["transform"] = &TransformComponent::transform;
transformComponent["__tostring"] = &string<TransformComponent>;
auto cameraType = state.new_enum("CameraType",
"Orthographic", CameraType::Orthographic,
"Perspective", CameraType::Perspective);
auto cameraComponent = state.new_usertype<CameraComponent>("CameraComponent", sol::no_constructor);
cameraComponent["type"] = &CameraComponent::type;
cameraComponent["zoomLevel"] = &CameraComponent::zoomLevel;
cameraComponent["rotateAxis"] = &CameraComponent::rotateAxis;
cameraComponent["fov"] = &CameraComponent::fov;
cameraComponent["pitch"] = &CameraComponent::pitch;
cameraComponent["yaw"] = &CameraComponent::yaw;
cameraComponent["up"] = &CameraComponent::up;
cameraComponent["projection"] = &CameraComponent::projection;
auto spriteComponent = state.new_usertype<SpriteComponent>("SpriteComponent", sol::no_constructor);
spriteComponent["color"] = &SpriteComponent::color;
spriteComponent["texture"] = &SpriteComponent::texture;
}
void Registration::input(sol::state_view& state)
{
state.set_function("keyCode", &keyCode);
auto input = state.new_usertype<Input>("Input", sol::no_constructor);
input["isKeyPressed"] = &Input::isKeyPressed;
input["getXOffset"] = &Input::getXOffset;
input["getYOffset"] = &Input::getYOffset;
}
void Registration::fill(sol::state_view& state)
{
glm(state);
component(state);
input(state);
}
void Registration::glm(sol::state_view& state)
{
auto glm = state["glm"].get_or_create<sol::table>();
auto vec2 = glm.new_usertype<glm::vec2>(
"vec2",
sol::call_constructor, sol::constructors<glm::vec2(), glm::vec2(glm::vec2), glm::vec2(float), glm::vec2(float, float)>(),
"x", &glm::vec2::x, "y", &glm::vec2::y,
"r", &glm::vec2::r, "g", &glm::vec2::g,
"s", &glm::vec2::s, "t", &glm::vec2::t,
"__add", addition<glm::vec2, float>(),
"__sub", subtraction<glm::vec2, float>(),
"__mul", multiplication<glm::vec2, float>(),
"__div", division<glm::vec2, float>(),
"__tostring", string<glm::vec2>);
auto vec3 = glm.new_usertype<glm::vec3>(
"vec3",
sol::call_constructor, sol::constructors<glm::vec3(), glm::vec3(glm::vec3), glm::vec3(float), glm::vec3(float, float, float)>(),
"x", &glm::vec3::x, "y", &glm::vec3::y, "z", &glm::vec3::z,
"r", &glm::vec3::r, "g", &glm::vec3::g, "b", &glm::vec3::b,
"s", &glm::vec3::s, "t", &glm::vec3::t, "p", &glm::vec3::p,
"__add", addition<glm::vec3, float>(),
"__sub", subtraction<glm::vec3, float>(),
"__mul", multiplication<glm::vec3, float>(),
"__div", division<glm::vec3, float>(),
"__tostring", string<glm::vec3>);
auto vec4 = glm.new_usertype<glm::vec4>(
"vec4",
sol::call_constructor, sol::constructors<glm::vec4(), glm::vec4(glm::vec4), glm::vec4(float), glm::vec4(float, float, float, float)>(),
"x", &glm::vec4::x, "y", &glm::vec4::y, "z", &glm::vec4::z, "w", &glm::vec4::w,
"r", &glm::vec4::r, "g", &glm::vec4::g, "b", &glm::vec4::b, "a", &glm::vec4::a,
"s", &glm::vec4::s, "t", &glm::vec4::t, "p", &glm::vec4::p, "q", &glm::vec4::q,
"__add", addition<glm::vec4, float>(),
"__sub", subtraction<glm::vec4, float>(),
"__mul", multiplication<glm::vec4, float>(),
"__div", division<glm::vec4, float>(),
"__tostring", string<glm::vec4>);
glm.set_function("radians", sol::overload(
[](float v) { return glm::radians(v); },
[](const glm::vec2& v) { return glm::radians(v); },
[](const glm::vec3& v) { return glm::radians(v); },
[](const glm::vec4& v) { return glm::radians(v); }));
glm.set_function("normalize", sol::overload(
[](const glm::vec2& v) { return glm::normalize(v); },
[](const glm::vec3& v) { return glm::normalize(v); },
[](const glm::vec4& v) { return glm::normalize(v); }));
glm.set_function("cross", [](const glm::vec3& x, const glm::vec3& y) { return glm::cross(x, y); });
}
void Registration::component(sol::state_view& state)
{
auto tagComponent = state.new_usertype<TagComponent>("TagComponent", sol::no_constructor);
tagComponent["tag"] = &TagComponent::tag;
auto transformComponent = state.new_usertype<TransformComponent>("TransformComponent", sol::no_constructor);
transformComponent["translate"] = &TransformComponent::translate;
transformComponent["rotate"] = &TransformComponent::rotate;
transformComponent["scale"] = &TransformComponent::scale;
transformComponent["transform"] = &TransformComponent::transform;
transformComponent["__tostring"] = &string<TransformComponent>;
auto cameraType = state.new_enum("CameraType",
"Orthographic", CameraType::Orthographic,
"Perspective", CameraType::Perspective);
auto cameraComponent = state.new_usertype<CameraComponent>("CameraComponent", sol::no_constructor);
cameraComponent["type"] = &CameraComponent::type;
cameraComponent["zoomLevel"] = &CameraComponent::zoomLevel;
cameraComponent["rotateAxis"] = &CameraComponent::rotateAxis;
cameraComponent["fov"] = &CameraComponent::fov;
cameraComponent["pitch"] = &CameraComponent::pitch;
cameraComponent["yaw"] = &CameraComponent::yaw;
cameraComponent["up"] = &CameraComponent::up;
cameraComponent["projection"] = &CameraComponent::projection;
auto spriteComponent = state.new_usertype<SpriteComponent>("SpriteComponent", sol::no_constructor);
spriteComponent["color"] = &SpriteComponent::color;
spriteComponent["texture"] = &SpriteComponent::texture;
}
void Registration::input(sol::state_view& state)
{
state.set_function("keyCode", &keyCode);
auto input = state.new_usertype<Input>("Input", sol::no_constructor);
input["isKeyPressed"] = &Input::isKeyPressed;
input["getXOffset"] = &Input::getXOffset;
input["getYOffset"] = &Input::getYOffset;
}
} // namespace Inferno

98
src/inferno/script/registration.h
Unescape View File

@ -7,62 +7,58 @@
namespace Inferno {
class Registration final {
public:
static void fill(sol::state_view& state);
class Registration final {
public:
static void fill(sol::state_view& state);
private:
static void glm(sol::state_view& state);
static void component(sol::state_view& state);
static void input(sol::state_view& state);
private:
static void glm(sol::state_view& state);
static void component(sol::state_view& state);
static void input(sol::state_view& state);
template<typename T, typename V>
static auto addition()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs + rhs; },
[](const T& lhs, const V& rhs) { return lhs + rhs; },
[](const V& lhs, const T& rhs) { return lhs + rhs; }
);
}
template<typename T, typename V>
static auto addition()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs + rhs; },
[](const T& lhs, const V& rhs) { return lhs + rhs; },
[](const V& lhs, const T& rhs) { return lhs + rhs; });
}
template<typename T, typename V>
static auto subtraction()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs - rhs; },
[](const T& lhs, const V& rhs) { return lhs - rhs; },
[](const V& lhs, const T& rhs) { return lhs - rhs; }
);
}
template<typename T, typename V>
static auto subtraction()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs - rhs; },
[](const T& lhs, const V& rhs) { return lhs - rhs; },
[](const V& lhs, const T& rhs) { return lhs - rhs; });
}
template<typename T, typename V>
static auto multiplication()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs * rhs; },
[](const T& lhs, const V& rhs) { return lhs * rhs; },
[](const V& lhs, const T& rhs) { return lhs * rhs; }
);
}
template<typename T, typename V>
static auto multiplication()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs * rhs; },
[](const T& lhs, const V& rhs) { return lhs * rhs; },
[](const V& lhs, const T& rhs) { return lhs * rhs; });
}
template<typename T, typename V>
static auto division()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs / rhs; },
[](const T& lhs, const V& rhs) { return lhs / rhs; },
[](const V& lhs, const T& rhs) { return lhs / rhs; }
);
}
template<typename T, typename V>
static auto division()
{
return sol::overload(
[](const T& lhs, const T& rhs) { return lhs / rhs; },
[](const T& lhs, const V& rhs) { return lhs / rhs; },
[](const V& lhs, const T& rhs) { return lhs / rhs; });
}
template<typename T>
static std::string string(const T& t)
{
std::string result;
str(&result) << t;
return result;
}
};
template<typename T>
static std::string string(const T& t)
{
std::string result;
str(&result) << t;
return result;
}
};
} // namespace Inferno

146
src/inferno/settings.cpp
Unescape View File

@ -10,91 +10,91 @@
namespace Inferno {
const char* Settings::m_path { "assets/settings.json" };
SettingsProperties Settings::m_properties {};
const char* Settings::m_path { "assets/settings.json" };
SettingsProperties Settings::m_properties {};
void Settings::initialize()
{
Settings::load();
void Settings::initialize()
{
Settings::load();
info() << "Settings initialized";
info() << "Settings initialized";
Settings::save();
}
void Settings::destroy()
{
}
bool Settings::load()
{
ruc::Json object;
if (!File::ioRead(&object, m_path)) {
warn() << "Settings invalid formatting, using default values";
return false;
}
m_properties = object.get<SettingsProperties>();
Settings::save();
}
return true;
}
bool Settings::save()
{
ruc::Json object = m_properties;
void Settings::destroy()
{
}
if (!File::ioWrite(&object, m_path)) {
warn() << "Settings could not be saved";
return false;
}
bool Settings::load()
{
ruc::Json object;
info() << "Settings saved";
return true;
if (!File::ioRead(&object, m_path)) {
warn() << "Settings invalid formatting, using default values";
return false;
}
// -------------------------------------
void toJson(ruc::Json& object, const SettingsProperties& settings)
{
object = ruc::Json {
{ "window", settings.window }
};
}
m_properties = object.get<SettingsProperties>();
void fromJson(const ruc::Json& object, SettingsProperties& settings)
{
VERIFY(object.type() == ruc::Json::Type::Object);
return true;
}
if (object.exists("window"))
object.at("window").getTo(settings.window);
}
bool Settings::save()
{
ruc::Json object = m_properties;
void toJson(ruc::Json& object, const WindowProperties& window)
{
object = ruc::Json {
{ "title", window.title },
{ "width", window.width },
{ "height", window.height },
{ "fullscreen", window.fullscreen },
{ "vsync", window.vsync },
};
if (!File::ioWrite(&object, m_path)) {
warn() << "Settings could not be saved";
return false;
}
void fromJson(const ruc::Json& object, WindowProperties& window)
{
VERIFY(object.type() == ruc::Json::Type::Object);
if (object.exists("title"))
object.at("title").getTo(window.title);
if (object.exists("width"))
object.at("width").getTo(window.width);
if (object.exists("height"))
object.at("height").getTo(window.height);
if (object.exists("fullscreen"))
object.at("fullscreen").getTo(window.fullscreen);
if (object.exists("vsync"))
object.at("vsync").getTo(window.vsync);
}
info() << "Settings saved";
return true;
}
// -------------------------------------
void toJson(ruc::Json& object, const SettingsProperties& settings)
{
object = ruc::Json {
{ "window", settings.window }
};
}
void fromJson(const ruc::Json& object, SettingsProperties& settings)
{
VERIFY(object.type() == ruc::Json::Type::Object);
if (object.exists("window"))
object.at("window").getTo(settings.window);
}
void toJson(ruc::Json& object, const WindowProperties& window)
{
object = ruc::Json {
{ "title", window.title },
{ "width", window.width },
{ "height", window.height },
{ "fullscreen", window.fullscreen },
{ "vsync", window.vsync },
};
}
void fromJson(const ruc::Json& object, WindowProperties& window)
{
VERIFY(object.type() == ruc::Json::Type::Object);
if (object.exists("title"))
object.at("title").getTo(window.title);
if (object.exists("width"))
object.at("width").getTo(window.width);
if (object.exists("height"))
object.at("height").getTo(window.height);
if (object.exists("fullscreen"))
object.at("fullscreen").getTo(window.fullscreen);
if (object.exists("vsync"))
object.at("vsync").getTo(window.vsync);
}
} // namespace Inferno

38
src/inferno/settings.h
Unescape View File

@ -6,33 +6,33 @@
namespace Inferno {
struct SettingsProperties {
WindowProperties window;
};
struct SettingsProperties {
WindowProperties window;
};
class Settings {
public:
static void initialize();
static void destroy();
class Settings {
public:
static void initialize();
static void destroy();
static bool load();
static bool save();
static bool load();
static bool save();
static inline SettingsProperties& get() { return m_properties; }
static inline SettingsProperties& get() { return m_properties; }
private:
static const char* m_path;
static SettingsProperties m_properties;
};
private:
static const char* m_path;
static SettingsProperties m_properties;
};
// -----------------------------------------
// Json arbitrary type conversion functions
// Json arbitrary type conversion functions
void toJson(ruc::Json& object, const SettingsProperties& settings);
void fromJson(const ruc::Json& object, SettingsProperties& settings);
void toJson(ruc::Json& object, const SettingsProperties& settings);
void fromJson(const ruc::Json& object, SettingsProperties& settings);
void toJson(ruc::Json& object, const WindowProperties& window);
void fromJson(const ruc::Json& object, WindowProperties& window);
void toJson(ruc::Json& object, const WindowProperties& window);
void fromJson(const ruc::Json& object, WindowProperties& window);
} // namespace Inferno

86
src/inferno/singleton.h
Unescape View File

@ -4,48 +4,48 @@
namespace Inferno {
template<typename T>
class Singleton {
// Application is allowed to access its Singleton instance for early setting
friend class Application;
public:
static inline void initialize()
{
VERIFY(!s_instance, "singleton already exists");
s_instance = new T { s {} };
}
static inline void destroy()
{
VERIFY(s_instance, "singleton does not exist");
delete s_instance;
s_instance = nullptr;
}
static inline T& the()
{
VERIFY(s_instance, "singleton does not exist");
return *s_instance;
}
// Remove copy constructor and copy assignment operator
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
Singleton(Singleton&&) = delete;
Singleton& operator=(Singleton&&) = delete;
protected:
Singleton() {}
// Constructor token
struct s {};
private:
static T* s_instance;
};
template<typename T>
T* Singleton<T>::s_instance = nullptr;
template<typename T>
class Singleton {
// Application is allowed to access its Singleton instance for early setting
friend class Application;
public:
static inline void initialize()
{
VERIFY(!s_instance, "singleton already exists");
s_instance = new T { s {} };
}
static inline void destroy()
{
VERIFY(s_instance, "singleton does not exist");
delete s_instance;
s_instance = nullptr;
}
static inline T& the()
{
VERIFY(s_instance, "singleton does not exist");
return *s_instance;
}
// Remove copy constructor and copy assignment operator
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
Singleton(Singleton&&) = delete;
Singleton& operator=(Singleton&&) = delete;
protected:
Singleton() {}
// Constructor token
struct s {};
private:
static T* s_instance;
};
template<typename T>
T* Singleton<T>::s_instance = nullptr;
} // namespace Inferno

127
src/inferno/system/camerasystem.cpp
Unescape View File

@ -12,86 +12,85 @@
namespace Inferno {
CameraSystem::CameraSystem(s)
{
info() << "CameraSystem initialized";
}
CameraSystem::CameraSystem(s)
{
info() << "CameraSystem initialized";
}
CameraSystem::~CameraSystem()
{
}
CameraSystem::~CameraSystem()
{
}
void CameraSystem::update()
{
auto view = m_registry->view<TransformComponent, CameraComponent>();
void CameraSystem::update()
{
auto view = m_registry->view<TransformComponent, CameraComponent>();
for (auto [entity, transform, camera] : view.each()) {
for (auto [entity, transform, camera] : view.each()) {
if (camera.type == CameraType::Orthographic) {
updateOrthographic(transform, camera);
}
else if (camera.type == CameraType::Perspective) {
updatePerspective(transform, camera);
}
if (camera.type == CameraType::Orthographic) {
updateOrthographic(transform, camera);
}
else if (camera.type == CameraType::Perspective) {
updatePerspective(transform, camera);
}
}
}
glm::mat4 CameraSystem::projectionView()
{
auto view = m_registry->view<TransformComponent, CameraComponent>();
glm::mat4 CameraSystem::projectionView()
{
auto view = m_registry->view<TransformComponent, CameraComponent>();
for (auto [entity, transform, camera] : view.each()) {
return camera.projection * transform.transform;
}
for (auto [entity, transform, camera] : view.each()) {
return camera.projection * transform.transform;
}
VERIFY_NOT_REACHED();
VERIFY_NOT_REACHED();
return glm::mat4 { 1.0f };
}
return glm::mat4 { 1.0f };
}
void CameraSystem::updateOrthographic(TransformComponent& transform, CameraComponent& camera)
{
// Update camera matrix
// Local space -> World space: model matrix
// Is done in Object::update()
// World space -> View space: view matrix
transform.transform = {
glm::translate(glm::mat4(1.0f), transform.translate) *
glm::rotate(glm::mat4(1.0f), glm::radians(transform.rotate.z), camera.rotateAxis)
};
transform.transform = { glm::inverse(transform.transform) };
// View space -> Clip space: projection matrix
float aspectRatio = Application::the().getWindow().getAspect();
camera.projection = {
glm::ortho(-aspectRatio * camera.zoomLevel, aspectRatio * camera.zoomLevel,
-camera.zoomLevel, camera.zoomLevel, -1.0f, 1.0f)
};
// Clip space -> Screen space: viewport transform
// Is done in the fragment shader using the settings of glViewport
}
void CameraSystem::updateOrthographic(TransformComponent& transform, CameraComponent& camera)
{
// Update camera matrix
void CameraSystem::updatePerspective(TransformComponent& transform, CameraComponent& camera)
{
// Update camera matrix
// Local space -> World space: model matrix
// Is done in Object::update()
// Local space -> World space: model matrix
// Is done in Object::update()
// World space -> View space: view matrix
transform.transform = {
glm::translate(glm::mat4(1.0f), transform.translate) * glm::rotate(glm::mat4(1.0f), glm::radians(transform.rotate.z), camera.rotateAxis)
};
transform.transform = { glm::inverse(transform.transform) };
// World space -> View space: view matrix
transform.transform = { glm::lookAt(transform.translate, transform.translate + transform.rotate, camera.up) };
// View space -> Clip space: projection matrix
float aspectRatio = Application::the().getWindow().getAspect();
camera.projection = {
glm::ortho(-aspectRatio * camera.zoomLevel, aspectRatio * camera.zoomLevel,
-camera.zoomLevel, camera.zoomLevel, -1.0f, 1.0f)
};
// View space -> Clip space: projection matrix
float aspect = Application::the().getWindow().getAspect();
camera.projection = { glm::perspective(glm::radians(camera.fov), aspect, NEAR_PLANE, FAR_PLANE) };
// Clip space -> Screen space: viewport transform
// Is done in the fragment shader using the settings of glViewport
}
// Clip space -> Screen space: viewport transform
// Is done in the fragment shader using the settings of glViewport
void CameraSystem::updatePerspective(TransformComponent& transform, CameraComponent& camera)
{
// Update camera matrix
// Souce: https://learnopengl.com/img/getting-started/coordinate_systems.png
}
// Local space -> World space: model matrix
// Is done in Object::update()
// World space -> View space: view matrix
transform.transform = { glm::lookAt(transform.translate, transform.translate + transform.rotate, camera.up) };
// View space -> Clip space: projection matrix
float aspect = Application::the().getWindow().getAspect();
camera.projection = { glm::perspective(glm::radians(camera.fov), aspect, NEAR_PLANE, FAR_PLANE) };
// Clip space -> Screen space: viewport transform
// Is done in the fragment shader using the settings of glViewport
// Souce: https://learnopengl.com/img/getting-started/coordinate_systems.png
}
} // namespace Inferno

28
src/inferno/system/camerasystem.h
Unescape View File

@ -11,25 +11,25 @@
namespace Inferno {
struct TransformComponent;
struct CameraComponent;
struct TransformComponent;
struct CameraComponent;
class CameraSystem final : public ruc::Singleton<CameraSystem> {
public:
CameraSystem(s);
virtual ~CameraSystem();
class CameraSystem final : public ruc::Singleton<CameraSystem> {
public:
CameraSystem(s);
virtual ~CameraSystem();
void update();
void update();
glm::mat4 projectionView();
glm::mat4 projectionView();
void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
private:
void updateOrthographic(TransformComponent& transform, CameraComponent& camera);
void updatePerspective(TransformComponent& transform, CameraComponent& camera);
private:
void updateOrthographic(TransformComponent& transform, CameraComponent& camera);
void updatePerspective(TransformComponent& transform, CameraComponent& camera);
std::shared_ptr<entt::registry> m_registry;
};
std::shared_ptr<entt::registry> m_registry;
};
} // namespace Inferno

26
src/inferno/system/rendersystem.cpp
Unescape View File

@ -8,22 +8,22 @@
namespace Inferno {
RenderSystem::RenderSystem(s)
{
info() << "RenderSystem initialized";
}
RenderSystem::RenderSystem(s)
{
info() << "RenderSystem initialized";
}
RenderSystem::~RenderSystem()
{
}
RenderSystem::~RenderSystem()
{
}
void RenderSystem::render()
{
auto group = m_registry->group<TransformComponent, SpriteComponent>();
void RenderSystem::render()
{
auto group = m_registry->group<TransformComponent, SpriteComponent>();
for (auto [entity, transform, sprite] : group.each()) {
Renderer2D::the().drawQuad(transform, sprite.color, sprite.texture);
}
for (auto [entity, transform, sprite] : group.each()) {
Renderer2D::the().drawQuad(transform, sprite.color, sprite.texture);
}
}
} // namespace Inferno

18
src/inferno/system/rendersystem.h
Unescape View File

@ -9,17 +9,17 @@
namespace Inferno {
class RenderSystem final : public ruc::Singleton<RenderSystem> {
public:
RenderSystem(s);
virtual ~RenderSystem();
class RenderSystem final : public ruc::Singleton<RenderSystem> {
public:
RenderSystem(s);
virtual ~RenderSystem();
void render();
void render();
void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
private:
std::shared_ptr<entt::registry> m_registry;
};
private:
std::shared_ptr<entt::registry> m_registry;
};
} // namespace Inferno

126
src/inferno/system/scriptsystem.cpp
Unescape View File

@ -11,91 +11,91 @@
namespace Inferno {
ScriptSystem::ScriptSystem(s)
{
info() << "ScriptSystem initialized";
}
ScriptSystem::ScriptSystem(s)
{
info() << "ScriptSystem initialized";
}
ScriptSystem::~ScriptSystem()
{
auto nativeScriptView = m_scene->registry()->view<NativeScriptComponent>();
ScriptSystem::~ScriptSystem()
{
auto nativeScriptView = m_scene->registry()->view<NativeScriptComponent>();
for (auto entity : nativeScriptView) {
cleanup(nativeScriptView.get<NativeScriptComponent>(entity));
}
for (auto entity : nativeScriptView) {
cleanup(nativeScriptView.get<NativeScriptComponent>(entity));
}
auto luaScriptView = m_scene->registry()->view<LuaScriptComponent>();
auto luaScriptView = m_scene->registry()->view<LuaScriptComponent>();
for (auto entity : luaScriptView) {
cleanup(luaScriptView.get<LuaScriptComponent>(entity));
}
for (auto entity : luaScriptView) {
cleanup(luaScriptView.get<LuaScriptComponent>(entity));
}
}
void ScriptSystem::update(float deltaTime)
{
// @Todo figure out why group doesn't work here
auto nativeScriptView = m_scene->registry()->view<TransformComponent, NativeScriptComponent>();
for (auto [entity, transform, nativeScript] : nativeScriptView.each()) {
void ScriptSystem::update(float deltaTime)
{
// @Todo figure out why group doesn't work here
auto nativeScriptView = m_scene->registry()->view<TransformComponent, NativeScriptComponent>();
// Create native script if not initialized
if (!nativeScript.instance) {
nativeScript.instance = nativeScript.initialize();
nativeScript.instance->transform = &transform;
nativeScript.instance->m_scene = m_scene;
nativeScript.instance->m_entity = static_cast<uint32_t>(entity);
nativeScript.instance->initialize();
}
for (auto [entity, transform, nativeScript] : nativeScriptView.each()) {
// Create native script if not initialized
if (!nativeScript.instance) {
nativeScript.instance = nativeScript.initialize();
nativeScript.instance->transform = &transform;
nativeScript.instance->update(deltaTime);
nativeScript.instance->m_scene = m_scene;
nativeScript.instance->m_entity = static_cast<uint32_t>(entity);
nativeScript.instance->initialize();
}
auto luaScriptView = m_scene->registry()->view<TransformComponent, LuaScriptComponent>();
nativeScript.instance->transform = &transform;
nativeScript.instance->update(deltaTime);
}
for (auto [entity, transform, luaScript] : luaScriptView.each()) {
auto luaScriptView = m_scene->registry()->view<TransformComponent, LuaScriptComponent>();
// Create Lua script if not initialized
if (!luaScript.instance) {
luaScript.instance = new LuaScript();
luaScript.instance->transform = &transform;
luaScript.instance->m_scene = m_scene;
luaScript.instance->m_entity = static_cast<uint32_t>(entity);
luaScript.instance->m_path = luaScript.path;
luaScript.instance->initialize();
}
for (auto [entity, transform, luaScript] : luaScriptView.each()) {
luaScript.instance->update(deltaTime);
// Create Lua script if not initialized
if (!luaScript.instance) {
luaScript.instance = new LuaScript();
luaScript.instance->transform = &transform;
luaScript.instance->m_scene = m_scene;
luaScript.instance->m_entity = static_cast<uint32_t>(entity);
luaScript.instance->m_path = luaScript.path;
luaScript.instance->initialize();
}
luaScript.instance->update(deltaTime);
}
}
void ScriptSystem::cleanup(uint32_t entity)
{
if (m_scene->hasComponent<NativeScriptComponent>(entity)) {
auto& nativeScript = m_scene->getComponent<NativeScriptComponent>(entity);
cleanup(nativeScript);
}
void ScriptSystem::cleanup(uint32_t entity)
{
if (m_scene->hasComponent<NativeScriptComponent>(entity)) {
auto& nativeScript = m_scene->getComponent<NativeScriptComponent>(entity);
cleanup(nativeScript);
}
if (m_scene->hasComponent<LuaScriptComponent>(entity)) {
auto& luaScript = m_scene->getComponent<LuaScriptComponent>(entity);
cleanup(luaScript);
}
if (m_scene->hasComponent<LuaScriptComponent>(entity)) {
auto& luaScript = m_scene->getComponent<LuaScriptComponent>(entity);
cleanup(luaScript);
}
}
void ScriptSystem::cleanup(NativeScriptComponent& nativeScript)
{
if (nativeScript.instance) {
nativeScript.instance->destroy();
nativeScript.destroy();
}
void ScriptSystem::cleanup(NativeScriptComponent& nativeScript)
{
if (nativeScript.instance) {
nativeScript.instance->destroy();
nativeScript.destroy();
}
}
void ScriptSystem::cleanup(LuaScriptComponent& luaScript)
{
if (luaScript.instance) {
luaScript.instance->destroy();
delete luaScript.instance;
}
void ScriptSystem::cleanup(LuaScriptComponent& luaScript)
{
if (luaScript.instance) {
luaScript.instance->destroy();
delete luaScript.instance;
}
}
} // namespace Inferno

30
src/inferno/system/scriptsystem.h
Unescape View File

@ -6,26 +6,26 @@
namespace Inferno {
struct NativeScriptComponent;
struct LuaScriptComponent;
struct NativeScriptComponent;
struct LuaScriptComponent;
class Scene;
class Scene;
class ScriptSystem final : public ruc::Singleton<ScriptSystem> {
public:
ScriptSystem(s);
virtual ~ScriptSystem();
class ScriptSystem final : public ruc::Singleton<ScriptSystem> {
public:
ScriptSystem(s);
virtual ~ScriptSystem();
void update(float deltaTime);
void update(float deltaTime);
void cleanup(uint32_t entity);
void cleanup(NativeScriptComponent& nativeScript);
void cleanup(LuaScriptComponent& luaScript);
void cleanup(uint32_t entity);
void cleanup(NativeScriptComponent& nativeScript);
void cleanup(LuaScriptComponent& luaScript);
void setScene(Scene* scene) { m_scene = scene; }
void setScene(Scene* scene) { m_scene = scene; }
private:
Scene* m_scene { nullptr };
};
private:
Scene* m_scene { nullptr };
};
} // namespace Inferno

168
src/inferno/system/textareasystem.cpp
Unescape View File

@ -11,108 +11,108 @@
namespace Inferno {
TextAreaSystem::TextAreaSystem(s)
{
info() << "TextAreaSystem initialized";
}
TextAreaSystem::~TextAreaSystem()
{
}
void TextAreaSystem::render()
{
auto view = m_scene->registry()->view<TransformComponent, TextAreaComponent>();
glm::ivec2 viewport = {
Application::the().getWindow().getWidth(),
Application::the().getWindow().getHeight(),
};
for (auto [entity, transform, textarea] : view.each()) {
// Loop through textareas content
// Linebreak if width reached
// Break if lines AND width reached
// Calculate character quad
// Submit character quad for rendering
std::shared_ptr<Font> font = FontManager::the().load(textarea.font);
// glm::mat4 translate = transform.translate;
float advance = 0.0f;
for (auto character : textarea.content) {
std::optional<CharacterQuad> quad = calculateCharacterQuad(character, font, advance);
if (quad) {
RendererCharacter::the().drawCharacter(quad.value(), font->texture());
}
TextAreaSystem::TextAreaSystem(s)
{
info() << "TextAreaSystem initialized";
}
TextAreaSystem::~TextAreaSystem()
{
}
void TextAreaSystem::render()
{
auto view = m_scene->registry()->view<TransformComponent, TextAreaComponent>();
glm::ivec2 viewport = {
Application::the().getWindow().getWidth(),
Application::the().getWindow().getHeight(),
};
for (auto [entity, transform, textarea] : view.each()) {
// Loop through textareas content
// Linebreak if width reached
// Break if lines AND width reached
// Calculate character quad
// Submit character quad for rendering
std::shared_ptr<Font> font = FontManager::the().load(textarea.font);
// glm::mat4 translate = transform.translate;
float advance = 0.0f;
for (auto character : textarea.content) {
std::optional<CharacterQuad> quad = calculateCharacterQuad(character, font, advance);
if (quad) {
RendererCharacter::the().drawCharacter(quad.value(), font->texture());
}
}
}
}
std::optional<CharacterQuad> TextAreaSystem::calculateCharacterQuad(unsigned char character, std::shared_ptr<Font> font, float& advance)
{
CharacterQuad characterQuad;
std::optional<CharacterQuad> TextAreaSystem::calculateCharacterQuad(unsigned char character, std::shared_ptr<Font> font, float& advance)
{
CharacterQuad characterQuad;
auto c = font->get(character);
auto c = font->get(character);
// Texture
// ---------------------------------
// Texture
// ---------------------------------
float textureWidth = static_cast<float>(font->texture()->width());
float textureHeight = static_cast<float>(font->texture()->height());
VERIFY(textureWidth == textureHeight, "TextAreaSystem read invalid font texture");
float textureWidth = static_cast<float>(font->texture()->width());
float textureHeight = static_cast<float>(font->texture()->height());
VERIFY(textureWidth == textureHeight, "TextAreaSystem read invalid font texture");
// Skip empty characters
if (c->size.x == 0 || c->size.y == 0) {
// Jump to the next glyph
advance += c->advance / textureWidth;
return {};
}
// Skip empty characters
if (c->size.x == 0 || c->size.y == 0) {
// Jump to the next glyph
advance += c->advance / textureWidth;
return {};
}
// Position
// ---------------------------------
// Position
// ---------------------------------
float quadWidth = c->size.x / textureWidth;
float quadHeight = c->size.y / textureHeight;
characterQuad.at(0).quad.position = { -quadWidth, -quadHeight, 0.0f }; // bottom left
characterQuad.at(1).quad.position = { quadWidth, -quadHeight, 0.0f }; // bottom right
characterQuad.at(2).quad.position = { quadWidth, quadHeight, 0.0f }; // top right
characterQuad.at(3).quad.position = { -quadWidth, quadHeight, 0.0f }; // top left
float quadWidth = c->size.x / textureWidth;
float quadHeight = c->size.y / textureHeight;
characterQuad.at(0).quad.position = { -quadWidth, -quadHeight, 0.0f }; // bottom left
characterQuad.at(1).quad.position = { quadWidth, -quadHeight, 0.0f }; // bottom right
characterQuad.at(2).quad.position = { quadWidth, quadHeight, 0.0f }; // top right
characterQuad.at(3).quad.position = { -quadWidth, quadHeight, 0.0f }; // top left
for (auto& quad : characterQuad) {
quad.quad.position.x -= 0.5f;
for (auto& quad : characterQuad) {
quad.quad.position.x -= 0.5f;
quad.quad.position.x += c->offset.x / (float)textureWidth;
quad.quad.position.y -= c->offset.y / (float)textureHeight;
quad.quad.position.x += c->offset.x / (float)textureWidth;
quad.quad.position.y -= c->offset.y / (float)textureHeight;
quad.quad.position.x += advance;
}
quad.quad.position.x += advance;
}
// dbgln("character: {} ({}) width: {} height: {} advance: {} x: {}",
// character, (int)character, quadWidth, quadHeight, advance, characterQuad.at(0).quad.position.x);
// dbgln("character: {} ({}) width: {} height: {} advance: {} x: {}",
// character, (int)character, quadWidth, quadHeight, advance, characterQuad.at(0).quad.position.x);
// Jump to the next glyph
advance += c->advance / textureWidth;
// Jump to the next glyph
advance += c->advance / textureWidth;
// Texture coordinates
// ---------------------------------
// Texture coordinates
// ---------------------------------
glm::vec2 x {
1 - (textureWidth - c->position.x) / textureWidth,
1 - (textureWidth - c->position.x - c->size.x) / textureWidth
};
glm::vec2 y {
(textureHeight - c->position.y - c->size.y) / textureHeight,
(textureHeight - c->position.y) / textureHeight
};
glm::vec2 x {
1 - (textureWidth - c->position.x) / textureWidth,
1 - (textureWidth - c->position.x - c->size.x) / textureWidth
};
glm::vec2 y {
(textureHeight - c->position.y - c->size.y) / textureHeight,
(textureHeight - c->position.y) / textureHeight
};
characterQuad.at(0).quad.textureCoordinates = { x.x, y.x };
characterQuad.at(1).quad.textureCoordinates = { x.y, y.x };
characterQuad.at(2).quad.textureCoordinates = { x.y, y.y };
characterQuad.at(3).quad.textureCoordinates = { x.x, y.y };
characterQuad.at(0).quad.textureCoordinates = { x.x, y.x };
characterQuad.at(1).quad.textureCoordinates = { x.y, y.x };
characterQuad.at(2).quad.textureCoordinates = { x.y, y.y };
characterQuad.at(3).quad.textureCoordinates = { x.x, y.y };
return characterQuad;
}
return characterQuad;
}
} // namespace Inferno

26
src/inferno/system/textareasystem.h
Unescape View File

@ -12,24 +12,24 @@
namespace Inferno {
using CharacterQuad = std::array<CharacterVertex, Renderer::vertexPerQuad>;
using CharacterQuad = std::array<CharacterVertex, Renderer::vertexPerQuad>;
class Font;
class Scene;
class Font;
class Scene;
class TextAreaSystem final : public ruc::Singleton<TextAreaSystem> {
public:
TextAreaSystem(s);
virtual ~TextAreaSystem();
class TextAreaSystem final : public ruc::Singleton<TextAreaSystem> {
public:
TextAreaSystem(s);
virtual ~TextAreaSystem();
void render();
void render();
void setScene(Scene* scene) { m_scene = scene; }
void setScene(Scene* scene) { m_scene = scene; }
private:
std::optional<CharacterQuad> calculateCharacterQuad(unsigned char character, std::shared_ptr<Font> font, float& advance);
private:
std::optional<CharacterQuad> calculateCharacterQuad(unsigned char character, std::shared_ptr<Font> font, float& advance);
Scene* m_scene { nullptr };
};
Scene* m_scene { nullptr };
};
} // namespace Inferno

46
src/inferno/system/transformsystem.cpp
Unescape View File

@ -6,37 +6,37 @@
namespace Inferno {
TransformSystem::TransformSystem(s)
{
info() << "TransformSystem initialized";
}
TransformSystem::TransformSystem(s)
{
info() << "TransformSystem initialized";
}
TransformSystem::~TransformSystem()
{
}
TransformSystem::~TransformSystem()
{
}
void TransformSystem::update()
{
auto view = m_registry->view<TransformComponent>();
void TransformSystem::update()
{
auto view = m_registry->view<TransformComponent>();
for (auto entity : view) {
for (auto entity : view) {
auto& component = view.get<TransformComponent>(entity);
auto& component = view.get<TransformComponent>(entity);
// Identity matrix
component.transform = glm::mat4(1.0f);
// Identity matrix
component.transform = glm::mat4(1.0f);
// Translate
component.transform = glm::translate(component.transform, component.translate);
// Translate
component.transform = glm::translate(component.transform, component.translate);
// Rotate
component.transform = glm::rotate(component.transform, glm::radians(component.rotate.x), {1.0, 0.0, 0.0});
component.transform = glm::rotate(component.transform, glm::radians(component.rotate.y), {0.0, 1.0, 0.0});
component.transform = glm::rotate(component.transform, glm::radians(component.rotate.z), {0.0, 0.0, 1.0});
// Rotate
component.transform = glm::rotate(component.transform, glm::radians(component.rotate.x), { 1.0, 0.0, 0.0 });
component.transform = glm::rotate(component.transform, glm::radians(component.rotate.y), { 0.0, 1.0, 0.0 });
component.transform = glm::rotate(component.transform, glm::radians(component.rotate.z), { 0.0, 0.0, 1.0 });
// Scale
component.transform = glm::scale(component.transform, component.scale);
}
// Scale
component.transform = glm::scale(component.transform, component.scale);
}
}
} // namespace Inferno

18
src/inferno/system/transformsystem.h
Unescape View File

@ -7,17 +7,17 @@
namespace Inferno {
class TransformSystem final : public ruc::Singleton<TransformSystem> {
public:
TransformSystem(s);
virtual ~TransformSystem();
class TransformSystem final : public ruc::Singleton<TransformSystem> {
public:
TransformSystem(s);
virtual ~TransformSystem();
void update();
void update();
void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
void setRegistry(std::shared_ptr<entt::registry> registry) { m_registry = registry; };
private:
std::shared_ptr<entt::registry> m_registry;
};
private:
std::shared_ptr<entt::registry> m_registry;
};
} // namespace Inferno

10
src/inferno/time.cpp
Unescape View File

@ -4,9 +4,9 @@
namespace Inferno {
float Time::time()
{
return static_cast<float>(glfwGetTime());
}
float Time::time()
{
return static_cast<float>(glfwGetTime());
}
} // namespace Inferno

8
src/inferno/time.h
Unescape View File

@ -2,9 +2,9 @@
namespace Inferno {
class Time {
public:
static float time();
};
class Time {
public:
static float time();
};
} // namespace Inferno

22
src/inferno/util/integer.h
Unescape View File

@ -7,18 +7,18 @@
namespace std {
// Can't believe this is not in the standard library
// Can't believe this is not in the standard library
inline uint32_t stou(const std::string& string)
{
unsigned long size = std::stoul(string);
VERIFY(size <= std::numeric_limits<uint32_t>::max(), "String util not in uint32_t range '{}'", string);
return static_cast<uint32_t>(size);
}
inline uint32_t stou(const std::string& string)
{
unsigned long size = std::stoul(string);
VERIFY(size <= std::numeric_limits<uint32_t>::max(), "String util not in uint32_t range '{}'", string);
return static_cast<uint32_t>(size);
}
inline uint32_t stou(const char* string)
{
return stou(std::string(string));
}
inline uint32_t stou(const char* string)
{
return stou(std::string(string));
}
} // namespace std

10
src/inferno/util/json.h
Unescape View File

@ -1,12 +1,12 @@
#pragma once
#if 0
#include <cstdint> // int32_t, uint32_t
#include <optional> // std::optional
#include <vector> // std::vector
#include <cstdint> // int32_t, uint32_t
#include <optional> // std::optional
#include <vector> // std::vector
#include "nlohmann/json.hpp"
#include "ruc/meta/assert.h"
#include "nlohmann/json.hpp"
#include "ruc/meta/assert.h"
namespace Inferno {

18
src/inferno/util/string.h
Unescape View File

@ -5,15 +5,15 @@
namespace Inferno {
template<typename T>
std::string intToHex(T i)
{
std::stringstream stream;
stream << "0x"
<< std::setfill('0') << std::setw(sizeof(T) * 2)
<< std::hex << i;
template<typename T>
std::string intToHex(T i)
{
std::stringstream stream;
stream << "0x"
<< std::setfill('0') << std::setw(sizeof(T) * 2)
<< std::hex << i;
return stream.str();
}
return stream.str();
}
} // namespace Inferno

393
src/inferno/window.cpp
Unescape View File

@ -18,244 +18,245 @@
namespace Inferno {
unsigned char Window::s_windowCount = 0;
Window::Window()
{
m_properties = {
Settings::get().window.title,
Settings::get().window.width,
Settings::get().window.height,
Settings::get().window.fullscreen,
Settings::get().window.vsync,
};
this->initialize();
}
unsigned char Window::s_windowCount = 0;
Window::Window()
{
m_properties = {
Settings::get().window.title,
Settings::get().window.width,
Settings::get().window.height,
Settings::get().window.fullscreen,
Settings::get().window.vsync,
};
this->initialize();
}
Window::~Window()
{
this->destroy();
}
Window::~Window()
{
this->destroy();
}
// -----------------------------------------
void Window::initialize()
{
std::string title = m_properties.title;
uint32_t width = m_properties.width;
uint32_t height = m_properties.height;
bool vsync = m_properties.vsync;
void Window::initialize()
{
std::string title = m_properties.title;
uint32_t width = m_properties.width;
uint32_t height = m_properties.height;
bool vsync = m_properties.vsync;
// Only init once
if (s_windowCount == 0) {
glfwInit();
}
// Only init once
if (s_windowCount == 0) {
glfwInit();
}
// Set window properties
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Set window properties
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// Create GLFW window
m_window = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr);
s_windowCount++;
VERIFY(m_window, "Failed to create GLFW window!");
// Create GLFW window
m_window = glfwCreateWindow(width, height, title.c_str(), nullptr, nullptr);
s_windowCount++;
VERIFY(m_window, "Failed to create GLFW window!");
// Set windowed/fullscreen/borderless
this->setWindowMonitor();
// Set windowed/fullscreen/borderless
this->setWindowMonitor();
// Associate the wrapper to the window
glfwSetWindowUserPointer(m_window, this);
// Associate the wrapper to the window
glfwSetWindowUserPointer(m_window, this);
// Create graphics context
m_context = std::make_shared<Context>(m_window);
m_context->initialize();
// Create graphics context
m_context = std::make_shared<Context>(m_window);
m_context->initialize();
// Set vsync, viewport
setVSync(vsync);
RenderCommand::setViewport(0, 0, width, height);
// Set vsync, viewport
setVSync(vsync);
RenderCommand::setViewport(0, 0, width, height);
// Signal callbacks
signal(SIGINT, Window::signalCallback);
signal(SIGTERM, Window::signalCallback);
// Signal callbacks
signal(SIGINT, Window::signalCallback);
signal(SIGTERM, Window::signalCallback);
// Error callback
glfwSetErrorCallback([](int error, const char* description) {
dbgln("GLFW Error {}: {}", error, description);
});
// Error callback
glfwSetErrorCallback([](int error, const char* description) {
dbgln("GLFW Error {}: {}", error, description);
});
// Window close callback
glfwSetWindowCloseCallback(m_window, [](GLFWwindow* window) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
// Window close callback
glfwSetWindowCloseCallback(m_window, [](GLFWwindow* window) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
WindowCloseEvent event;
w.m_eventCallback(event);
});
WindowCloseEvent event;
w.m_eventCallback(event);
});
// Window resize callback
glfwSetWindowSizeCallback(m_window, [](GLFWwindow* window, int width, int height) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
// Window resize callback
glfwSetWindowSizeCallback(m_window, [](GLFWwindow* window, int width, int height) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
w.m_properties.width = width;
w.m_properties.height = height;
w.m_properties.width = width;
w.m_properties.height = height;
WindowResizeEvent event(width, height);
WindowResizeEvent event(width, height);
w.m_eventCallback(event);
});
// Keyboard callback
glfwSetKeyCallback(m_window, [](GLFWwindow* window, int key, int scanCode, int action, int mods) {
// Suppress unused warning
(void)scanCode;
(void)mods;
Window& w = *(Window*)glfwGetWindowUserPointer(window);
switch (action) {
case GLFW_PRESS: {
KeyPressEvent event(key);
w.m_eventCallback(event);
});
// Keyboard callback
glfwSetKeyCallback(m_window, [](GLFWwindow* window, int key, int scanCode, int action, int mods) {
// Suppress unused warning
(void)scanCode;
(void)mods;
Window& w = *(Window*)glfwGetWindowUserPointer(window);
switch (action) {
case GLFW_PRESS: {
KeyPressEvent event(key);
w.m_eventCallback(event);
break;
}
case GLFW_RELEASE: {
KeyReleaseEvent event(key);
w.m_eventCallback(event);
break;
}
case GLFW_REPEAT: {
KeyRepeatEvent event(key);
w.m_eventCallback(event);
break;
}
}
});
// Mouse button callback
glfwSetMouseButtonCallback(m_window, [](GLFWwindow* window, int button, int action, int mods) {
// Suppress unused warning
(void)mods;
Window& w = *(Window*)glfwGetWindowUserPointer(window);
switch (action) {
case GLFW_PRESS: {
MouseButtonPressEvent event(button);
w.m_eventCallback(event);
break;
}
case GLFW_RELEASE: {
MouseButtonReleaseEvent event(button);
w.m_eventCallback(event);
break;
}
}
});
// Mouse position callback
glfwSetCursorPosCallback(m_window, [](GLFWwindow* window, double xPos, double yPos) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
MousePositionEvent event(xPos, yPos);
break;
}
case GLFW_RELEASE: {
KeyReleaseEvent event(key);
w.m_eventCallback(event);
break;
}
case GLFW_REPEAT: {
KeyRepeatEvent event(key);
w.m_eventCallback(event);
});
break;
}
}
});
// Mouse button callback
glfwSetMouseButtonCallback(m_window, [](GLFWwindow* window, int button, int action, int mods) {
// Suppress unused warning
(void)mods;
// Mouse scroll callback
glfwSetScrollCallback(m_window, [](GLFWwindow* window, double xOffset, double yOffset) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
Window& w = *(Window*)glfwGetWindowUserPointer(window);
MouseScrollEvent event(xOffset, yOffset);
switch (action) {
case GLFW_PRESS: {
MouseButtonPressEvent event(button);
w.m_eventCallback(event);
});
}
break;
}
case GLFW_RELEASE: {
MouseButtonReleaseEvent event(button);
w.m_eventCallback(event);
break;
}
}
});
void Window::destroy()
{
m_context->destroy();
// Mouse position callback
glfwSetCursorPosCallback(m_window, [](GLFWwindow* window, double xPos, double yPos) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
glfwDestroyWindow(m_window);
s_windowCount--;
MousePositionEvent event(xPos, yPos);
w.m_eventCallback(event);
});
if (s_windowCount == 0) {
glfwTerminate();
}
}
// Mouse scroll callback
glfwSetScrollCallback(m_window, [](GLFWwindow* window, double xOffset, double yOffset) {
Window& w = *(Window*)glfwGetWindowUserPointer(window);
void Window::update()
{
glfwPollEvents();
MouseScrollEvent event(xOffset, yOffset);
w.m_eventCallback(event);
});
}
// Capture cursor in window and hide it
if (!Input::isKeyPressed(keyCode("GLFW_KEY_LEFT_SUPER"))) {
glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
}
else {
glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
}
void Window::destroy()
{
m_context->destroy();
glfwDestroyWindow(m_window);
s_windowCount--;
if (s_windowCount == 0) {
glfwTerminate();
}
}
void Window::update()
{
glfwPollEvents();
void Window::render()
{
m_context->render();
// Capture cursor in window and hide it
if (!Input::isKeyPressed(keyCode("GLFW_KEY_LEFT_SUPER"))) {
glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
}
else {
glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
}
}
void Window::render()
{
m_context->render();
}
// -----------------------------------------
void Window::signalCallback(int signal)
{
Application::the().setStatus(signal);
void Window::signalCallback(int signal)
{
Application::the().setStatus(signal);
if (signal == SIGINT || signal == SIGTERM) {
WindowCloseEvent e;
Application::the().getWindow().m_eventCallback(e);
}
if (signal == SIGINT || signal == SIGTERM) {
WindowCloseEvent e;
Application::the().getWindow().m_eventCallback(e);
}
}
void Window::setWindowMonitor() const
{
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
int xPos = 0;
int yPos = 0;
unsigned int width = m_properties.width;
unsigned int height = m_properties.height;
int refresh = GLFW_DONT_CARE;
std::string fullscreen = m_properties.fullscreen;
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
void Window::setWindowMonitor() const
{
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
int xPos = 0;
int yPos = 0;
unsigned int width = m_properties.width;
unsigned int height = m_properties.height;
int refresh = GLFW_DONT_CARE;
if (fullscreen.compare("fullscreen") == 0) {
refresh = mode->refreshRate;
}
else if (fullscreen.compare("borderless") == 0) {
width = mode->width;
height = mode->height;
refresh = mode->refreshRate;
}
// Default window state is windowed
else {
monitor = nullptr;
// Put window in the center of the monitor
xPos = (mode->width - width) / 2;
yPos = (mode->height - height) / 2;
}
std::string fullscreen = m_properties.fullscreen;
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwSetWindowMonitor(m_window, monitor, xPos, yPos, width, height, refresh);
if (fullscreen.compare("fullscreen") == 0) {
refresh = mode->refreshRate;
}
void Window::setVSync(bool enabled)
{
enabled ? glfwSwapInterval(GL_TRUE) : glfwSwapInterval(GL_FALSE);
m_properties.vsync = enabled;
else if (fullscreen.compare("borderless") == 0) {
width = mode->width;
height = mode->height;
refresh = mode->refreshRate;
}
void Window::setShouldClose(bool close) const
{
glfwSetWindowShouldClose(m_window, close ? GL_TRUE : GL_FALSE);
// Default window state is windowed
else {
monitor = nullptr;
// Put window in the center of the monitor
xPos = (mode->width - width) / 2;
yPos = (mode->height - height) / 2;
}
bool Window::shouldClose() const {
return glfwWindowShouldClose(m_window);
}
glfwSetWindowMonitor(m_window, monitor, xPos, yPos, width, height, refresh);
}
void Window::setVSync(bool enabled)
{
enabled ? glfwSwapInterval(GL_TRUE) : glfwSwapInterval(GL_FALSE);
m_properties.vsync = enabled;
}
void Window::setShouldClose(bool close) const
{
glfwSetWindowShouldClose(m_window, close ? GL_TRUE : GL_FALSE);
}
bool Window::shouldClose() const
{
return glfwWindowShouldClose(m_window);
}
} // namespace Inferno

74
src/inferno/window.h
Unescape View File

@ -9,55 +9,55 @@ struct GLFWwindow;
namespace Inferno {
class Context;
class Event;
class Context;
class Event;
struct WindowProperties {
std::string title { "Inferno" };
uint32_t width = 1280;
uint32_t height = 720;
std::string fullscreen { "windowed" }; // windowed/fullscreen/borderless
bool vsync = true;
};
struct WindowProperties {
std::string title { "Inferno" };
uint32_t width = 1280;
uint32_t height = 720;
std::string fullscreen { "windowed" }; // windowed/fullscreen/borderless
bool vsync = true;
};
class Window {
public:
Window();
virtual ~Window();
class Window {
public:
Window();
virtual ~Window();
// -----------------------------------------
// -----------------------------------------
void initialize();
void destroy();
void update();
void render();
void initialize();
void destroy();
void update();
void render();
// -----------------------------------------
// -----------------------------------------
static void signalCallback(int signal);
static void signalCallback(int signal);
void setWindowMonitor() const;
void setVSync(bool enabled);
void setShouldClose(bool close) const;
void setWindowMonitor() const;
void setVSync(bool enabled);
void setShouldClose(bool close) const;
bool shouldClose() const;
inline float getAspect() const { return static_cast<float>(m_properties.width) / static_cast<float>(m_properties.height); }
inline uint32_t getWidth() const { return m_properties.width; }
inline uint32_t getHeight() const { return m_properties.height; }
bool shouldClose() const;
inline float getAspect() const { return static_cast<float>(m_properties.width) / static_cast<float>(m_properties.height); }
inline uint32_t getWidth() const { return m_properties.width; }
inline uint32_t getHeight() const { return m_properties.height; }
inline GLFWwindow* getWindow() const { return m_window; }
inline std::shared_ptr<Context> getContext() const { return m_context; }
inline GLFWwindow* getWindow() const { return m_window; }
inline std::shared_ptr<Context> getContext() const { return m_context; }
inline void setEventCallback(const std::function<void(Event&)>& callback) { m_eventCallback = callback; }
inline void setEventCallback(const std::function<void(Event&)>& callback) { m_eventCallback = callback; }
private:
WindowProperties m_properties;
GLFWwindow* m_window;
std::shared_ptr<Context> m_context;
private:
WindowProperties m_properties;
GLFWwindow* m_window;
std::shared_ptr<Context> m_context;
std::function<void(Event&)> m_eventCallback;
std::function<void(Event&)> m_eventCallback;
static unsigned char s_windowCount;
};
static unsigned char s_windowCount;
};
} // namespace Inferno

Write Preview
Loading…
Cancel
Save