light7734/light
light7734/light
1
1
Fork 0
Code Issues 20 Pull requests 1 Projects 1 Releases Packages Wiki Activity

Style: Rename LT_* Log macros to LOG

Browse source
This commit is contained in:
Light 2022-03-07 21:57:00 +03:30
parent b1e60d08b7
commit dcedb1799c
47 changed files with 2890 additions and 3017 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

97
Engine/src/Engine/Base/Base.h
View file

@ -4,40 +4,40 @@
namespace Light { namespace Light {
// Ref (Ref) // Ref (Ref)
template<typename T> template<typename T>
using Ref = std::shared_ptr<T>; using Ref = std::shared_ptr<T>;
template<typename T, typename... Args>
constexpr Ref<T> CreateRef(Args&&... args)
{
return std::make_shared<T>(std::forward<Args>(args)...);
}
template<typename T>
constexpr Ref<T> MakeRef(T* rawPointer)
{
return std::shared_ptr<T>(rawPointer);
}
// Scope (std::unique_ptr)
template<typename T>
using Scope = std::unique_ptr<T>;
template<typename T, typename... Args>
constexpr std::unique_ptr<T> CreateScope(Args&&... args)
{
return std::make_unique<T>(std::forward<Args>(args)...);
}
template<typename T>
constexpr std::unique_ptr<T> MakeScope(T* rawPointer)
{
return std::unique_ptr<T>(rawPointer);
}
template<typename T, typename... Args>
constexpr Ref<T> CreateRef(Args&&... args)
{
return std::make_shared<T>(std::forward<Args>(args)...);
} }
template<typename T>
constexpr Ref<T> MakeRef(T* rawPointer)
{
return std::shared_ptr<T>(rawPointer);
}
// Scope (std::unique_ptr)
template<typename T>
using Scope = std::unique_ptr<T>;
template<typename T, typename... Args>
constexpr std::unique_ptr<T> CreateScope(Args&&... args)
{
return std::make_unique<T>(std::forward<Args>(args)...);
}
template<typename T>
constexpr std::unique_ptr<T> MakeScope(T* rawPointer)
{
return std::unique_ptr<T>(rawPointer);
}
} // namespace Light
//========== PLATFORM ==========// //========== PLATFORM ==========//
#define LT_WIN(x) // windows #define LT_WIN(x) // windows
#define LT_LIN(x) // linux #define LT_LIN(x) // linux
@ -45,32 +45,45 @@ namespace Light {
#if defined(LIGHT_PLATFORM_WINDOWS) #if defined(LIGHT_PLATFORM_WINDOWS)
#define LT_BUILD_PLATFORM "Windows" #define LT_BUILD_PLATFORM "Windows"
#define LT_WIN(x) x #define LT_WIN(x) x
#elif defined(LIGHT_PLATFORM_LINUX) #elif defined(LIGHT_PLATFORM_LINUX)
#define LT_BUILD_PLATFORM "Linux" #define LT_BUILD_PLATFORM "Linux"
#define LT_LIN(x) x #define LT_LIN(x) x
#elif defined(LIGHT_PLATFORM_MAC) #elif defined(LIGHT_PLATFORM_MAC)
#error "Unsupported platform: MAC" #error "Unsupported platform: MAC"
#define LT_MAC(x) x #define LT_MAC(x) x
#else #else
// #error "Unsupported platform: Unknown" // #error "Unsupported platform: Unknown"
#endif #endif
//========== PLATFORM ==========// //========== PLATFORM ==========//
//====================================================================== OPERATIONS ======================================================================// //====================================================================== OPERATIONS ======================================================================//
/* assertions */ /* assertions */
#define LT_ENGINE_ASSERT(x, ...) { if(!(x)) { LT_ENGINE_CRITICAL(__VA_ARGS__); LT_DEBUG_TRAP(); throw ::Light::FailedEngineAssertion(__FILE__, __LINE__); } } #define ASSERT(x, ...) \
#define LT_CLIENT_ASSERT(x, ...) { if(!(x)) { LT_CLIENT_CRITICAL(__VA_ARGS__); LT_DEBUG_TRAP(); throw ::Light::FailedClientAssertion(__FILE__, __LINE__); } } { \
if (!(x)) \
{ \
LOG(critical, __VA_ARGS__); \
LT_DEBUG_TRAP(); \
throw ::Light::FailedAssertion(__FILE__, __LINE__); \
} \
}
/* bit-wise */ /* bit-wise */
#define BIT(x) 1 << x #define BIT(x) 1 << x
/* token */ /* token */
#define LT_PAIR_TOKEN_VALUE_TO_NAME(token) { token, #token } #define LT_PAIR_TOKEN_VALUE_TO_NAME(token) \
#define LT_PAIR_TOKEN_NAME_TO_VALUE(token) { #token, token } { \
token, #token \
}
#define LT_PAIR_TOKEN_NAME_TO_VALUE(token) \
{ \
#token, token \
}
#define LT_TOKEN_NAME(token) #token #define LT_TOKEN_NAME(token) #token
//====================================================================== OPERATIONS ======================================================================// //====================================================================== OPERATIONS ======================================================================//
@ -95,4 +108,4 @@ namespace Light {
#ifndef LIGHT_STRINGIFIER_H #ifndef LIGHT_STRINGIFIER_H
#include "Utility/Stringifier.h" #include "Utility/Stringifier.h"
#endif #endif
//========== ESSENTIAL_HEADERS ==========// //========== ESSENTIAL_HEADERS ==========//

44
Engine/src/Engine/Base/EntryPoint.h
View file

@ -2,7 +2,7 @@
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
#include <LightEngine.h> #include <LightEngine.h>
// to be defined in client project // to be defined in client project
extern Light::Application* Light::CreateApplication(std::string execName, std::vector<std::string> args); extern Light::Application* Light::CreateApplication(std::string execName, std::vector<std::string> args);
@ -11,7 +11,7 @@ extern Light::Application* Light::CreateApplication(std::string execName, std::v
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
Light::Application* application = nullptr; Light::Application* application = nullptr;
int exitCode = 0; int exitCode = 0;
std::vector<std::string> args; std::vector<std::string> args;
@ -21,35 +21,29 @@ int main(int argc, char* argv[])
try try
{ {
application = Light::CreateApplication(argv[0], args); application = Light::CreateApplication(argv[0], args);
LT_ENGINE_ASSERT(application, "main: Light::Application is not intialized"); ASSERT(application, "Light::Application is not intialized");
for (int i = 0; i < argc; i++) for (int i = 0; i < argc; i++)
LT_ENGINE_INFO("main: argv[{}]: {}", i, argv[i]); LOG(info, "argv[{}]: {}", i, argv[i]);
application->GameLoop(); application->GameLoop();
} }
// failed engine assertion // failed engine assertion
catch (Light::FailedEngineAssertion) catch (Light::FailedAssertion)
{ {
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedEngineAssertion'"); LOG(critical, "Terminating due to unhandled 'FailedEngineAssertion'");
exitCode = -1; exitCode = -1;
} }
// failed client assertion
catch (Light::FailedClientAssertion)
{
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedClientAssertion'");
exitCode = -2;
}
// gl exception // gl exception
catch(Light::glException) catch (Light::glException)
{ {
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'glException'"); LOG(critical, "Terminating due to unhandled 'glException'");
exitCode = -3; exitCode = -3;
} }
// dx exception // dx exception
catch (Light::dxException) catch (Light::dxException)
{ {
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'dxException'"); LOG(critical, "Terminating due to unhandled 'dxException'");
exitCode = -4; exitCode = -4;
} }
@ -59,7 +53,7 @@ int main(int argc, char* argv[])
#elif defined(LIGHT_PLATFORM_LINUX) #elif defined(LIGHT_PLATFORM_LINUX)
#include <LightEngine.h> #include <LightEngine.h>
// to be defined in client project // to be defined in client project
extern Light::Application* Light::CreateApplication(); extern Light::Application* Light::CreateApplication();
@ -68,31 +62,25 @@ extern Light::Application* Light::CreateApplication();
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
Light::Application* application = nullptr; Light::Application* application = nullptr;
int exitCode = 0; int exitCode = 0;
try try
{ {
application = Light::CreateApplication(); application = Light::CreateApplication();
LT_ENGINE_ASSERT(application, "main: Light::Application is not intialized"); ASSERT(application, "Light::Application is not intialized");
application->GameLoop(); application->GameLoop();
} }
// failed engine assertion // failed engine assertion
catch (Light::FailedEngineAssertion) catch (Light::FailedAssertion)
{ {
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedEngineAssertion'"); LOG(critical, "Exitting due to unhandled 'FailedEngineAssertion'");
exitCode = -1; exitCode = -1;
} }
// failed client assertion
catch (Light::FailedClientAssertion)
{
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'FailedClientAssertion'");
exitCode = -2;
}
// gl exception // gl exception
catch (Light::glException) catch (Light::glException)
{ {
LT_ENGINE_CRITICAL("main: exitting due to unhandled 'glException'"); LOG(critical, "main: exitting due to unhandled 'glException'");
exitCode = -3; exitCode = -3;
} }
@ -100,4 +88,4 @@ int main(int argc, char* argv[])
return exitCode; return exitCode;
} }
#endif #endif

220
Engine/src/Engine/Base/Portables/DebugTrap.h
View file

@ -1,127 +1,149 @@
#pragma once #pragma once
#ifndef LIGHT_DEBUG_TRAP_H #ifndef LIGHT_DEBUG_TRAP_H
#define LIGHT_DEBUG_TRAP_H #define LIGHT_DEBUG_TRAP_H
#include "Base/Base.h" #include "Base/Base.h"
// https://github.com/nemequ/portable-snippets/tree/master/debug-trap // https://github.com/nemequ/portable-snippets/tree/master/debug-trap
#ifdef LIGHT_DIST #ifdef LIGHT_DIST
#ifdef _MSC_VER #ifdef _MSC_VER
#define LT_DEBUG_TRAP() \ #define LT_DEBUG_TRAP() \
LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \ LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
__FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__ __FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__
#else #else
#define LT_DEBUG_TRAP() \ #define LT_DEBUG_TRAP() \
LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__) LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
#endif #endif
#endif #endif
#if !defined(LT_DEBUG_TRAP) && defined(__has_builtin) && !defined(__ibmxl__) #if !defined(LT_DEBUG_TRAP) && defined(__has_builtin) && !defined(__ibmxl__)
#if __has_builtin(__builtin_debugtrap) #if __has_builtin(__builtin_debugtrap)
#define LT_DEBUG_TRAP() __builtin_debugtrap() #define LT_DEBUG_TRAP() __builtin_debugtrap()
#elif __has_builtin(__debugbreak) #elif __has_builtin(__debugbreak)
#define LT_DEBUG_TRAP() __debugbreak() #define LT_DEBUG_TRAP() __debugbreak()
#endif #endif
#endif #endif
#if !defined(LT_DEBUG_TRAP) #if !defined(LT_DEBUG_TRAP)
#if defined(_MSC_VER) || defined(__INTEL_COMPILER) #if defined(_MSC_VER) || defined(__INTEL_COMPILER)
#define LT_DEBUG_TRAP() __debugbreak() #define LT_DEBUG_TRAP() __debugbreak()
#elif defined(__ARMCC_VERSION) #elif defined(__ARMCC_VERSION)
#define LT_DEBUG_TRAP() __breakpoint(42) #define LT_DEBUG_TRAP() __breakpoint(42)
#elif defined(__ibmxl__) || defined(__xlC__) #elif defined(__ibmxl__) || defined(__xlC__)
#include <builtins.h> #include <builtins.h>
#define LT_DEBUG_TRAP() __trap(42) #define LT_DEBUG_TRAP() __trap(42)
#elif defined(__DMC__) && defined(_M_IX86) #elif defined(__DMC__) && defined(_M_IX86)
static inline void LT_DEBUG_TRAP(void) { __asm int 3h; } static inline void LT_DEBUG_TRAP(void)
{
#elif defined(__i386__) || defined(__x86_64__) __asm int 3h;
static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("int3"); }
#elif defined(__thumb__)
static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__(".inst 0xde01"); }
#elif defined(__aarch64__)
static inline void LT_DEBUG_TRAP(void) {
__asm__ __volatile__(".inst 0xd4200000");
} }
#elif defined(__arm__) #elif defined(__i386__) || defined(__x86_64__)
static inline void LT_DEBUG_TRAP(void) { static inline void LT_DEBUG_TRAP(void)
__asm__ __volatile__(".inst 0xe7f001f0"); {
__asm__ __volatile__("int3");
} }
#elif defined(__alpha__) && !defined(__osf__) #elif defined(__thumb__)
static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("bpt"); } static inline void LT_DEBUG_TRAP(void)
{
#elif defined(_54_) __asm__ __volatile__(".inst 0xde01");
static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("ESTOP"); }
#elif defined(_55_)
static inline void LT_DEBUG_TRAP(void) {
__asm__ __volatile__(
";\n .if (.MNEMONIC)\n ESTOP_1\n .else\n ESTOP_1()\n .endif\n NOP");
} }
#elif defined(_64P_) #elif defined(__aarch64__)
static inline void LT_DEBUG_TRAP(void) { __asm__ __volatile__("SWBP 0"); } static inline void LT_DEBUG_TRAP(void)
{
#elif defined(_6x_) __asm__ __volatile__(".inst 0xd4200000");
static inline void LT_DEBUG_TRAP(void) {
__asm__ __volatile__("NOP\n .word 0x10000000");
} }
#elif defined(__STDC_HOSTED__) && (__STDC_HOSTED__ == 0) && defined(__GNUC__) #elif defined(__arm__)
#define LT_DEBUG_TRAP() __builtin_trap() static inline void LT_DEBUG_TRAP(void)
{
__asm__ __volatile__(".inst 0xe7f001f0");
}
#else #elif defined(__alpha__) && !defined(__osf__)
#include <signal.h> static inline void LT_DEBUG_TRAP(void)
{
__asm__ __volatile__("bpt");
}
#if defined(SIGTRAP) #elif defined(_54_)
#define LT_DEBUG_TRAP() raise(SIGTRAP) static inline void LT_DEBUG_TRAP(void)
{
__asm__ __volatile__("ESTOP");
}
#else #elif defined(_55_)
#define LT_DEBUG_TRAP() raise(SIGABRT) static inline void LT_DEBUG_TRAP(void)
{
__asm__ __volatile__(
";\n .if (.MNEMONIC)\n ESTOP_1\n .else\n ESTOP_1()\n .endif\n NOP");
}
#endif #elif defined(_64P_)
#endif static inline void LT_DEBUG_TRAP(void)
#endif {
__asm__ __volatile__("SWBP 0");
#if !defined(LT_DEBUG_TRAP) }
#if !defined(LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP)
#error \ #elif defined(_6x_)
"failed to define LT_BREAK, define LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP in Config.h to disable this error" static inline void LT_DEBUG_TRAP(void)
{
#elif defined(LIGHT_DIST) __asm__ __volatile__("NOP\n .word 0x10000000");
#ifdef _MSC_VER }
#define LT_DEBUG_TRAP() \
LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \ #elif defined(__STDC_HOSTED__) && (__STDC_HOSTED__ == 0) && defined(__GNUC__)
__FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__ #define LT_DEBUG_TRAP() __builtin_trap()
#else #else
#define LT_DEBUG_TRAP() \ #include <signal.h>
LT_FILE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
#if defined(SIGTRAP)
#endif #define LT_DEBUG_TRAP() raise(SIGTRAP)
#else /* !defined(LIGHT_DIST) */
#ifdef _MSC_VER #else
#define LT_DEBUG_TRAP() \ #define LT_DEBUG_TRAP() raise(SIGABRT)
LT_ENGINE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
__FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__ #endif
#endif
#else #endif
#define LT_DEBUG_TRAP() \
LT_ENGINE_CRITICAL("DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__) #if !defined(LT_DEBUG_TRAP)
#if !defined(LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP)
#endif #error \
#endif "failed to define LT_BREAK, define LIGHT_IGNORE_UNDEFINED_DEBUG_TRAP in Config.h to disable this error"
#endif
#elif defined(LIGHT_DIST)
#ifdef _MSC_VER
#define LT_DEBUG_TRAP() \
LOG(critical, "DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
__FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__
#else
#define LT_DEBUG_TRAP() \
LOG(critical, "DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
#endif
#else /* !defined(LIGHT_DIST) */
#ifdef _MSC_VER
#define LT_DEBUG_TRAP() \
LOG(critical, "DEBUG_TRAP REQUESTED AT: {}, FILE: {}, LINE: {}", \
__FUNCSIG__, __FILE__, __LINE__) // or __FUNCSIG__
#else
#define LT_DEBUG_TRAP() \
LOG(critical, "DEBUG_TRAP REQUESTED AT: {}", __PRETTY_FUNCTION__)
#endif
#endif
#endif
#endif #endif

250
Engine/src/Engine/Core/Application.cpp
View file

@ -1,156 +1,148 @@
#include "Application.h" #include "Application.h"
#include "Window.h"
#include "Debug/Instrumentor.h" #include "Debug/Instrumentor.h"
#include "Events/Event.h" #include "Events/Event.h"
#include "Graphics/GraphicsContext.h" #include "Graphics/GraphicsContext.h"
#include "Graphics/Renderer.h"
#include "Graphics/RenderCommand.h" #include "Graphics/RenderCommand.h"
#include "Graphics/Renderer.h"
#include "Layer/Layer.h" #include "Layer/Layer.h"
#include "Time/Timer.h" #include "Time/Timer.h"
#include "UserInterface/UserInterface.h" #include "UserInterface/UserInterface.h"
#include "Window.h"
namespace Light { namespace Light {
Application* Application::s_Context = nullptr; Application* Application::s_Context = nullptr;
Application::Application(std::string execName, std::vector<std::string> args) Application::Application(std::string execName, std::vector<std::string> args)
: m_Instrumentor(nullptr), : m_Instrumentor(nullptr), m_LayerStack(nullptr), m_Input(nullptr), m_Window(nullptr)
m_LayerStack(nullptr), {
m_Input(nullptr), ASSERT(!s_Context, "Repeated singleton construction");
m_Window(nullptr) s_Context = this;
m_Logger = Logger::Create();
LogDebugData();
m_Instrumentor = Instrumentor::Create();
m_Instrumentor->BeginSession("Logs/ProfileResults_Startup.json");
m_LayerStack = LayerStack::Create();
m_Input = Input::Create();
m_ResourceManager = ResourceManager::Create();
m_Window = Window::Create(std::bind(&Application::OnEvent, this, std::placeholders::_1));
}
Application::~Application()
{
LOG(trace, "Application::~Application()");
m_Instrumentor->EndSession(); // ProfileResults_Termination //
}
void Application::GameLoop()
{
// check
ASSERT(!m_LayerStack->IsEmpty(), "LayerStack is empty");
// log debug data
m_Logger->LogDebugData();
m_Window->GetGfxContext()->LogDebugData();
m_Window->GetGfxContext()->GetUserInterface()->LogDebugData();
// reveal window
m_Window->SetVisibility(true);
m_Instrumentor->EndSession(); // ProfileResults_GameLoop //
m_Instrumentor->BeginSession("Logs/ProfileResults_GameLoop.json");
/* game loop */
DeltaTimer deltaTimer;
while (!m_Window->IsClosed())
{ {
LT_ENGINE_ASSERT(!s_Context, "Application::Application: repeated singleton construction");
s_Context = this;
m_Logger = Logger::Create();
LogDebugData();
m_Instrumentor = Instrumentor::Create();
m_Instrumentor->BeginSession("Logs/ProfileResults_Startup.json");
m_LayerStack = LayerStack::Create();
m_Input = Input::Create();
m_ResourceManager = ResourceManager::Create();
m_Window = Window::Create(std::bind(&Application::OnEvent, this, std::placeholders::_1));
}
Application::~Application()
{
LT_ENGINE_TRACE("Application::~Application()");
m_Instrumentor->EndSession(); // ProfileResults_Termination //
}
void Application::GameLoop()
{
// check
LT_ENGINE_ASSERT(!m_LayerStack->IsEmpty(), "Application::GameLoop(pre): LayerStack is empty");
// log debug data
m_Logger->LogDebugData();
m_Window->GetGfxContext()->LogDebugData();
m_Window->GetGfxContext()->GetUserInterface()->LogDebugData();
// reveal window
m_Window->SetVisibility(true);
m_Instrumentor->EndSession(); // ProfileResults_GameLoop //
m_Instrumentor->BeginSession("Logs/ProfileResults_GameLoop.json");
/* game loop */
DeltaTimer deltaTimer;
while (!m_Window->IsClosed())
{ {
{ // update layers
// update layers LT_PROFILE_SCOPE("GameLoop::Update");
LT_PROFILE_SCOPE("GameLoop::Update");
for (auto it = m_LayerStack->begin(); it != m_LayerStack->end(); it++) for (auto it = m_LayerStack->begin(); it != m_LayerStack->end(); it++)
(*it)->OnUpdate(deltaTimer.GetDeltaTime()); (*it)->OnUpdate(deltaTimer.GetDeltaTime());
}
{
// render layers
LT_PROFILE_SCOPE("GameLoop::Render");
m_Window->GetGfxContext()->GetRenderer()->BeginFrame();
for (auto it = m_LayerStack->begin(); it != m_LayerStack->end(); it++)
(*it)->OnRender();
m_Window->GetGfxContext()->GetRenderer()->EndFrame();
}
{
// render user interface
LT_PROFILE_SCOPE("GameLoop::UserInterface");
m_Window->GetGfxContext()->GetUserInterface()->Begin();
for (auto it = m_LayerStack->begin(); it != m_LayerStack->end(); it++)
(*it)->OnUserInterfaceUpdate();
m_Window->GetGfxContext()->GetUserInterface()->End();
}
{
// poll events
LT_PROFILE_SCOPE("GameLoop::Events");
m_Window->PollEvents();
}
/// update delta time
deltaTimer.Update();
}
m_Instrumentor->EndSession(); // ProfileResults_GameLoop //
m_Instrumentor->BeginSession("Logs/ProfileResults_Termination.json");
}
void Application::Quit()
{
s_Context->m_Window->Close();
}
void Application::OnEvent(const Event& event)
{
// window
if (event.HasCategory(WindowEventCategory))
{
m_Window->OnEvent(event);
if(event.GetEventType() == EventType::WindowResized)
m_Window->GetGfxContext()->GetRenderer()->OnWindowResize((const WindowResizedEvent&)event);
} }
// input
if (event.HasCategory(InputEventCategory))
{ {
m_Input->OnEvent(event); // render layers
LT_PROFILE_SCOPE("GameLoop::Render");
m_Window->GetGfxContext()->GetRenderer()->BeginFrame();
if(!m_Input->IsReceivingGameEvents()) // return if the event is an input event and 'Input' has disabled the game events for (auto it = m_LayerStack->begin(); it != m_LayerStack->end(); it++)
return; (*it)->OnRender();
m_Window->GetGfxContext()->GetRenderer()->EndFrame();
} }
/* layers */ {
for (auto it = m_LayerStack->rbegin(); it != m_LayerStack->rend(); it++) // render user interface
if ((*it)->OnEvent(event)) return; LT_PROFILE_SCOPE("GameLoop::UserInterface");
m_Window->GetGfxContext()->GetUserInterface()->Begin();
for (auto it = m_LayerStack->begin(); it != m_LayerStack->end(); it++)
(*it)->OnUserInterfaceUpdate();
m_Window->GetGfxContext()->GetUserInterface()->End();
}
{
// poll events
LT_PROFILE_SCOPE("GameLoop::Events");
m_Window->PollEvents();
}
/// update delta time
deltaTimer.Update();
} }
void Application::LogDebugData() m_Instrumentor->EndSession(); // ProfileResults_GameLoop //
m_Instrumentor->BeginSession("Logs/ProfileResults_Termination.json");
}
void Application::Quit()
{
s_Context->m_Window->Close();
}
void Application::OnEvent(const Event& event)
{
// window
if (event.HasCategory(WindowEventCategory))
{ {
// #todo: log more information m_Window->OnEvent(event);
LT_ENGINE_INFO("________________________________________");
LT_ENGINE_INFO("Platform::"); if (event.GetEventType() == EventType::WindowResized)
LT_ENGINE_INFO(" OS: {}", LT_BUILD_PLATFORM); m_Window->GetGfxContext()->GetRenderer()->OnWindowResize((const WindowResizedEvent&)event);
LT_ENGINE_INFO(" DIR: {}", std::filesystem::current_path().generic_string());
LT_ENGINE_INFO("________________________________________");
} }
} // input
if (event.HasCategory(InputEventCategory))
{
m_Input->OnEvent(event);
if (!m_Input->IsReceivingGameEvents()) // return if the event is an input event and 'Input' has disabled the game events
return;
}
/* layers */
for (auto it = m_LayerStack->rbegin(); it != m_LayerStack->rend(); it++)
if ((*it)->OnEvent(event))
return;
}
void Application::LogDebugData()
{
// #todo: log more information
LOG(info, "________________________________________");
LOG(info, "Platform::");
LOG(info, " OS: {}", LT_BUILD_PLATFORM);
LOG(info, " DIR: {}", std::filesystem::current_path().generic_string());
LOG(info, "________________________________________");
}
} // namespace Light

78
Engine/src/Engine/Debug/Exceptions.cpp
View file

@ -10,52 +10,46 @@
namespace Light { namespace Light {
FailedEngineAssertion::FailedEngineAssertion(const char* file, int line) FailedAssertion::FailedAssertion(const char* file, int line)
{ {
LT_ENGINE_CRITICAL("FailedAssertion::FailedAssertion: engine assertion failed in: {} (line {})", file, line); LOG(critical, "Assertion failed in: {} (line {})", file, line);
} }
FailedClientAssertion::FailedClientAssertion(const char* file, int line) glException::glException(unsigned int source, unsigned int type, unsigned int id, const char* msg)
{ {
LT_ENGINE_CRITICAL("FailedClientAssertion::FailedClientAssertion: client assertion failed in: {} (line {})", file, line); // #todo: improve
} LOG(critical, "________________________________________");
LOG(critical, "glException::glException::");
glException::glException(unsigned int source, unsigned int type, unsigned int id, const char* msg) LOG(critical, " Severity: {}", Stringifier::glDebugMsgSeverity(GL_DEBUG_SEVERITY_HIGH));
{ LOG(critical, " Source : {}", Stringifier::glDebugMsgSource(source));
// #todo: improve LOG(critical, " Type : {}", Stringifier::glDebugMsgType(type));
LT_ENGINE_CRITICAL("________________________________________"); LOG(critical, " ID : {}", id);
LT_ENGINE_CRITICAL("glException::glException::"); LOG(critical, " Vendor : {}", glGetString(GL_VENDOR));
LT_ENGINE_CRITICAL(" Severity: {}", Stringifier::glDebugMsgSeverity(GL_DEBUG_SEVERITY_HIGH)); LOG(critical, " Renderer: {}", glGetString(GL_RENDERER));
LT_ENGINE_CRITICAL(" Source : {}", Stringifier::glDebugMsgSource(source)); LOG(critical, " Version : {}", glGetString(GL_VERSION));
LT_ENGINE_CRITICAL(" Type : {}", Stringifier::glDebugMsgType(type)); LOG(critical, " critical, SVersion: {}", glGetString(GL_SHADING_LANGUAGE_VERSION));
LT_ENGINE_CRITICAL(" ID : {}", id); LOG(critical, " {}", msg);
LT_ENGINE_CRITICAL(" Vendor : {}", glGetString(GL_VENDOR)); LOG(critical, "________________________________________");
LT_ENGINE_CRITICAL(" Renderer: {}", glGetString(GL_RENDERER)); }
LT_ENGINE_CRITICAL(" Version : {}", glGetString(GL_VERSION));
LT_ENGINE_CRITICAL(" SVersion: {}", glGetString(GL_SHADING_LANGUAGE_VERSION));
LT_ENGINE_CRITICAL(" {}", msg);
LT_ENGINE_CRITICAL("________________________________________");
}
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
dxException::dxException(long hr, const char* file, int line) dxException::dxException(long hr, const char* file, int line)
{ {
char* message; char* message;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, hr, nullptr, hr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)(&message), NULL, nullptr); (LPSTR)(&message), NULL, nullptr);
// #todo: improve // #todo: improve
LT_ENGINE_CRITICAL("________________________________________"); LOG(critical, "________________________________________");
LT_ENGINE_CRITICAL("dxException::dxException::"); LOG(critical, "dxException::dxException::");
LT_ENGINE_CRITICAL(" File: {}, Line: {}", file, line); LOG(critical, " File: {}, Line: {}", file, line);
LT_ENGINE_CRITICAL(" {}", message); LOG(critical, " {}", message);
LT_ENGINE_CRITICAL("________________________________________"); LOG(critical, "________________________________________");
LocalFree(message); LocalFree(message);
} }
#endif #endif
} } // namespace Light

42
Engine/src/Engine/Debug/Exceptions.h
View file

@ -1,33 +1,33 @@
#pragma once #pragma once
#define DXC(x) DXC_NO_REDIFINITION(x, __LINE__) #define DXC(x) DXC_NO_REDIFINITION(x, __LINE__)
#define DXC_NO_REDIFINITION(x, line) DXC_NO_REDIFINITION2(x, line) #define DXC_NO_REDIFINITION(x, line) DXC_NO_REDIFINITION2(x, line)
#define DXC_NO_REDIFINITION2(x, line) HRESULT hr##line; if(FAILED(hr##line = x)) throw dxException(hr##line, __FILE__, line)
#define DXC_NO_REDIFINITION2(x, line) \
HRESULT hr##line; \
if (FAILED(hr##line = x)) \
throw dxException(hr##line, __FILE__, line)
namespace Light { namespace Light {
struct FailedEngineAssertion : std::exception
{
FailedEngineAssertion(const char* file, int line);
};
struct FailedClientAssertion : std::exception struct FailedAssertion: std::exception
{ {
FailedClientAssertion(const char* file, int line); FailedAssertion(const char* file, int line);
}; };
// OpenGL // OpenGL
struct glException : std::exception struct glException: std::exception
{ {
glException(unsigned int source, unsigned int type, unsigned int id, const char* msg); glException(unsigned int source, unsigned int type, unsigned int id, const char* msg);
}; };
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
// DirectX // DirectX
struct dxException : std::exception struct dxException: std::exception
{ {
dxException(long hr, const char* file, int line); dxException(long hr, const char* file, int line);
}; };
#endif #endif
} } // namespace Light

110
Engine/src/Engine/Debug/Instrumentor.cpp
View file

@ -2,71 +2,71 @@
namespace Light { namespace Light {
Instrumentor* Instrumentor::s_Context = nullptr; Instrumentor* Instrumentor::s_Context = nullptr;
Scope<Instrumentor> Instrumentor::Create() Scope<Instrumentor> Instrumentor::Create()
{ {
return MakeScope<Instrumentor>(new Instrumentor); return MakeScope<Instrumentor>(new Instrumentor);
} }
Instrumentor::Instrumentor()
: m_CurrentSessionCount(0u)
{
// #todo: maintenance
LT_ENGINE_ASSERT(!s_Context, "Instrumentor::Instrumentor: an instance of 'Instrumentor' already exists, do not construct this class!");
s_Context = this;
}
void Instrumentor::BeginSessionImpl(const std::string& outputPath) Instrumentor::Instrumentor()
{ : m_CurrentSessionCount(0u)
std::filesystem::create_directory(outputPath.substr(0, outputPath.find_last_of('/') + 1)); {
// #todo: maintenance
ASSERT(!s_Context, "An instance of 'Instrumentor' already exists, do not construct this class!");
s_Context = this;
}
m_OutputFileStream.open(outputPath); void Instrumentor::BeginSessionImpl(const std::string& outputPath)
m_OutputFileStream << "{\"traceEvents\":["; {
} std::filesystem::create_directory(outputPath.substr(0, outputPath.find_last_of('/') + 1));
void Instrumentor::EndSessionImpl() m_OutputFileStream.open(outputPath);
{ m_OutputFileStream << "{\"traceEvents\":[";
if (m_CurrentSessionCount == 0u) }
LT_ENGINE_WARN("Instrumentor::EndSessionImpl: 0 profiling for the ended session");
m_CurrentSessionCount = 0u; void Instrumentor::EndSessionImpl()
{
if (m_CurrentSessionCount == 0u)
LOG(warn, "0 profiling for the ended session");
m_OutputFileStream << "]}"; m_CurrentSessionCount = 0u;
m_OutputFileStream.flush();
m_OutputFileStream.close();
}
void Instrumentor::SubmitScopeProfileImpl(const ScopeProfileResult& profileResult) m_OutputFileStream << "]}";
{ m_OutputFileStream.flush();
if (m_CurrentSessionCount++ == 0u) m_OutputFileStream.close();
m_OutputFileStream << "{"; }
else
m_OutputFileStream << ",{";
m_OutputFileStream << "\"name\":\"" << profileResult.name << "\","; void Instrumentor::SubmitScopeProfileImpl(const ScopeProfileResult& profileResult)
m_OutputFileStream << "\"cat\": \"scope\","; {
m_OutputFileStream << "\"ph\": \"X\","; if (m_CurrentSessionCount++ == 0u)
m_OutputFileStream << "\"ts\":" << profileResult.start << ","; m_OutputFileStream << "{";
m_OutputFileStream << "\"dur\":" << profileResult.duration << ","; else
m_OutputFileStream << "\"pid\":0,"; m_OutputFileStream << ",{";
m_OutputFileStream << "\"tid\":" << profileResult.threadID<< "";
m_OutputFileStream << "}";
}
InstrumentorTimer::InstrumentorTimer(const std::string& scopeName) m_OutputFileStream << "\"name\":\"" << profileResult.name << "\",";
: m_Result( { scopeName, 0, 0, 0 } ), m_Start(std::chrono::steady_clock::now()) m_OutputFileStream << "\"cat\": \"scope\",";
{ m_OutputFileStream << "\"ph\": \"X\",";
} m_OutputFileStream << "\"ts\":" << profileResult.start << ",";
m_OutputFileStream << "\"dur\":" << profileResult.duration << ",";
m_OutputFileStream << "\"pid\":0,";
m_OutputFileStream << "\"tid\":" << profileResult.threadID << "";
m_OutputFileStream << "}";
}
InstrumentorTimer::~InstrumentorTimer() InstrumentorTimer::InstrumentorTimer(const std::string& scopeName)
{ : m_Result({ scopeName, 0, 0, 0 }), m_Start(std::chrono::steady_clock::now())
auto end = std::chrono::steady_clock::now(); {
}
m_Result.start = std::chrono::time_point_cast<std::chrono::microseconds>(m_Start).time_since_epoch().count(); InstrumentorTimer::~InstrumentorTimer()
m_Result.duration = std::chrono::time_point_cast<std::chrono::microseconds>(end).time_since_epoch().count() - m_Result.start; {
auto end = std::chrono::steady_clock::now();
Instrumentor::SubmitScopeProfile(m_Result); m_Result.start = std::chrono::time_point_cast<std::chrono::microseconds>(m_Start).time_since_epoch().count();
} m_Result.duration = std::chrono::time_point_cast<std::chrono::microseconds>(end).time_since_epoch().count() - m_Result.start;
} Instrumentor::SubmitScopeProfile(m_Result);
}
} // namespace Light

83
Engine/src/Engine/Debug/Logger.cpp
View file

@ -1,60 +1,53 @@
#include "Logger.h" #include "Logger.h"
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/basic_file_sink.h> #include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
namespace Light { namespace Light {
Logger* Logger::s_Context = nullptr; Logger* Logger::s_Context = nullptr;
Scope<Logger> Logger::Create() Scope<Logger> Logger::Create()
{ {
return MakeScope<Logger>(new Logger()); return MakeScope<Logger>(new Logger());
} }
Logger::Logger() Logger::Logger()
: m_EngineLogger(nullptr), : m_EngineLogger(nullptr), m_FileLogger(nullptr), m_LogFilePath(LT_LOG_FILE_LOCATION)
m_ClientLogger(nullptr), {
m_FileLogger(nullptr), ASSERT(!s_Context, "An instance of 'Logger' already exists, do not construct this class!");
m_LogFilePath(LT_LOG_FILE_LOCATION) s_Context = this;
{
LT_ENGINE_ASSERT(!s_Context, "Logger::Logger: an instance of 'Logger' already exists, do not construct this class!");
s_Context = this;
// set spdlog pattern // set spdlog pattern
#if defined(LIGHT_PLATFORM_WINDOWS) // create loggers
spdlog::set_pattern("%^[%M:%S:%e] <%n>: %v%$"); spdlog::set_pattern("%^[%H:%M:%S]%g@%! ==> %v%$");
#elif defined(LIGHT_PLATFORM_LINUX)
spdlog::set_pattern("%^{%l} - [%M:%S:%e] <%n>: %v%$");
#endif
// create loggers
#ifndef LIGHT_DIST #ifndef LIGHT_DIST
m_EngineLogger = spdlog::stdout_color_mt("Engine"); spdlog::set_pattern("%^[%H:%M:%S]%! ==> %v%$");
m_ClientLogger = spdlog::stdout_color_mt("Client"); m_EngineLogger = spdlog::stdout_color_mt("Engine");
#endif #endif
m_FileLogger = spdlog::basic_logger_mt("File", m_LogFilePath);
m_FileLogger->set_pattern("%^[%M:%S:%e] <%l>: %v%$");
// set level m_FileLogger = spdlog::basic_logger_mt("File", m_LogFilePath);
#if defined(LIGHT_DEBUG) m_FileLogger->set_pattern("%^[%M:%S:%e] <%l>: %v%$");
m_EngineLogger->set_level(spdlog::level::trace);
m_ClientLogger->set_level(spdlog::level::trace); // set level
#elif defined (LIGHT_RELEASE) #if defined(LIGHT_DEBUG)
s_EngineLogger->set_level(spdlog::level::info); m_EngineLogger->set_level(spdlog::level::trace);
s_ClientLogger->set_level(spdlog::level::info); m_ClientLogger->set_level(spdlog::level::trace);
#elif defined(LIGHT_RELEASE)
s_EngineLogger->set_level(spdlog::level::info);
s_ClientLogger->set_level(spdlog::level::info);
#endif #endif
} }
void Logger::LogDebugData() void Logger::LogDebugData()
{ {
// #todo: improve // #todo: improve
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
LT_ENGINE_INFO("Logger::"); LOG(info, "Logger::");
LT_ENGINE_INFO(" ClientLevel : {}", Stringifier::spdlogLevel(m_ClientLogger->level())); LOG(info, " EngineLevel : {}", Stringifier::spdlogLevel(m_EngineLogger->level()));
LT_ENGINE_INFO(" EngineLevel : {}", Stringifier::spdlogLevel(m_EngineLogger->level())); LOG(info, " FileLevel : {}", Stringifier::spdlogLevel(m_FileLogger->level()));
LT_ENGINE_INFO(" FileLevel : {}", Stringifier::spdlogLevel(m_FileLogger->level())); LOG(info, " DefaultLevel: {}", Stringifier::spdlogLevel(spdlog::get_level()));
LT_ENGINE_INFO(" DefaultLevel: {}", Stringifier::spdlogLevel(spdlog::get_level())); LOG(info, "________________________________________");
LT_ENGINE_INFO("________________________________________"); }
}
} } // namespace Light

84
Engine/src/Engine/Debug/Logger.h
View file

@ -1,73 +1,43 @@
#pragma once #pragma once
#ifndef LIGHT_LOGGER_H #ifndef LIGHT_LOGGER_H
#define LIGHT_LOGGER_H #define LIGHT_LOGGER_H
#include "Base/Base.h" #include "Base/Base.h"
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
// LOGGER MACROS // #define LT_LOG_FILE_LOCATION "Logs/Logger.txt"
#define LT_LOG_FILE_LOCATION "Logs/Logger.txt" #ifndef LIGHT_DIST
#define LOG(logLevel, ...) SPDLOG_LOGGER_CALL(::Light::Logger::GetEngineLogger(), spdlog::level::logLevel, __VA_ARGS__)
// File #else
#define LT_FILE_INFO(...) ::Light::Logger::GetFileLogger()->log(spdlog::level::info , __VA_ARGS__) #define LOG(logLevel, ...) SPDLOG_LOGGER_CALL(::Light::Logger::GetFileLogger(), spdlog::level::logLevel, __VA_ARGS__)
#define LT_FILE_WARN(...) ::Light::Logger::GetFileLogger()->log(spdlog::level::warn , __VA_ARGS__) #endif
#define LT_FILE_ERROR(...) ::Light::Logger::GetFileLogger()->log(spdlog::level::err , __VA_ARGS__)
#define LT_FILE_CRITICAL(...) ::Light::Logger::GetFileLogger()->log(spdlog::level::critical, __VA_ARGS__)
#ifndef LIGHT_DIST
// Engine
#define LT_ENGINE_TRACE(...) ::Light::Logger::GetEngineLogger()->log(spdlog::level::trace , __VA_ARGS__)
#define LT_ENGINE_INFO(...) ::Light::Logger::GetEngineLogger()->log(spdlog::level::info , __VA_ARGS__)
#define LT_ENGINE_WARN(...) ::Light::Logger::GetEngineLogger()->log(spdlog::level::warn , __VA_ARGS__)
#define LT_ENGINE_ERROR(...) ::Light::Logger::GetEngineLogger()->log(spdlog::level::err , __VA_ARGS__)
#define LT_ENGINE_CRITICAL(...) ::Light::Logger::GetEngineLogger()->log(spdlog::level::critical, __VA_ARGS__)
// Client
#define LT_CLIENT_TRACE(...) ::Light::Logger::GetClientLogger()->log(spdlog::level::trace , __VA_ARGS__)
#define LT_CLIENT_INFO(...) ::Light::Logger::GetClientLogger()->log(spdlog::level::info , __VA_ARGS__)
#define LT_CLIENT_WARN(...) ::Light::Logger::GetClientLogger()->log(spdlog::level::warn , __VA_ARGS__)
#define LT_CLIENT_ERROR(...) ::Light::Logger::GetClientLogger()->log(spdlog::level::err , __VA_ARGS__)
#define LT_CLIENT_CRITICAL(...) ::Light::Logger::GetClientLogger()->log(spdlog::level::critical, __VA_ARGS__)
#else
#define LT_ENGINE_TRACE(...)
#define LT_ENGINE_INFO(...)
#define LT_ENGINE_WARN(...)
#define LT_ENGINE_ERROR(...)
#define LT_ENGINE_CRITICAL(...)
#define LT_CLIENT_TRACE(...)
#define LT_CLIENT_INFO(...)
#define LT_CLIENT_WARN(...)
#define LT_CLIENT_ERROR(...)
#define LT_CLIENT_CRITICAL(...)
#endif
namespace Light { namespace Light {
// #todo: extend // #todo: extend
class Logger /* singleton */ class Logger /* singleton */
{ {
private: private:
static Logger* s_Context; static Logger* s_Context;
private: private:
Ref<spdlog::logger> m_EngineLogger, m_ClientLogger, m_FileLogger; Ref<spdlog::logger> m_EngineLogger, m_FileLogger;
std::string m_LogFilePath; std::string m_LogFilePath;
public: public:
static Scope<Logger> Create(); static Scope<Logger> Create();
static inline Ref<spdlog::logger> GetEngineLogger() { return s_Context->m_EngineLogger; } static inline Ref<spdlog::logger> GetEngineLogger() { return s_Context->m_EngineLogger; }
static inline Ref<spdlog::logger> GetClientLogger() { return s_Context->m_ClientLogger; } static inline Ref<spdlog::logger> GetFileLogger() { return s_Context->m_FileLogger; }
static inline Ref<spdlog::logger> GetFileLogger() { return s_Context->m_FileLogger; }
void LogDebugData(); void LogDebugData();
private: private:
Logger(); Logger();
}; };
} } // namespace Light
#endif #endif

23
Engine/src/Engine/Graphics/Blender.cpp
View file

@ -1,4 +1,5 @@
#include "Blender.h" #include "Blender.h"
#include "OpenGL/glBlender.h" #include "OpenGL/glBlender.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -10,19 +11,19 @@
namespace Light { namespace Light {
Scope<Blender> Blender::Create(Ref<SharedContext> sharedContext) Scope<Blender> Blender::Create(Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateScope<glBlender>();
case GraphicsAPI::OpenGL:
return CreateScope<glBlender>();
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateScope<dxBlender>(std::static_pointer_cast<dxSharedContext>(sharedContext));) return CreateScope<dxBlender>(std::static_pointer_cast<dxSharedContext>(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "Blender::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
}
} }
}
} } // namespace Light

84
Engine/src/Engine/Graphics/Buffers.cpp
View file

@ -1,6 +1,6 @@
#include "Buffers.h" #include "Buffers.h"
#include "OpenGL/glBuffers.h"
#include "OpenGL/glBuffers.h"
#include "SharedContext.h" #include "SharedContext.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -12,58 +12,58 @@
namespace Light { namespace Light {
//================================================== CONSTANT_BUFFER ==================================================// //================================================== CONSTANT_BUFFER ==================================================//
Scope<ConstantBuffer> ConstantBuffer::Create(ConstantBufferIndex index, unsigned int size, Ref<SharedContext> sharedContext) Scope<ConstantBuffer> ConstantBuffer::Create(ConstantBufferIndex index, unsigned int size, Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateScope<glConstantBuffer>(index, size);
case GraphicsAPI::OpenGL:
return CreateScope<glConstantBuffer>(index, size);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateScope<dxConstantBuffer>(index, size, std::static_pointer_cast<dxSharedContext>(sharedContext));) return CreateScope<dxConstantBuffer>(index, size, std::static_pointer_cast<dxSharedContext>(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "ConstantBuffer::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
//================================================== CONSTANT_BUFFER ==================================================// }
//================================================== CONSTANT_BUFFER ==================================================//
//================================================== VERTEX_BUFFER ==================================================// //================================================== VERTEX_BUFFER ==================================================//
Ref<VertexBuffer> VertexBuffer::Create(float* vertices, unsigned int stride, unsigned int count, Ref<SharedContext> sharedContext) Ref<VertexBuffer> VertexBuffer::Create(float* vertices, unsigned int stride, unsigned int count, Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateRef<glVertexBuffer>(vertices, stride, count);
case GraphicsAPI::OpenGL:
return CreateRef<glVertexBuffer>(vertices, stride, count);
case GraphicsAPI::DirectX: LT_WIN(
return CreateRef<dxVertexBuffer>(vertices, stride, count, std::static_pointer_cast<dxSharedContext>(sharedContext));)
default: case GraphicsAPI::DirectX: LT_WIN(
LT_ENGINE_ASSERT(false, "VertexBuffer::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); return CreateRef<dxVertexBuffer>(vertices, stride, count, std::static_pointer_cast<dxSharedContext>(sharedContext));)
return nullptr;
} default:
ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr;
} }
//================================================== VERTEX_BUFFER ==================================================// }
//================================================== VERTEX_BUFFER ==================================================//
//======================================== INDEX_BUFFER ========================================// //======================================== INDEX_BUFFER ========================================//
Ref<IndexBuffer> IndexBuffer::Create(unsigned int* indices, unsigned int count, Ref<SharedContext> sharedContext) Ref<IndexBuffer> IndexBuffer::Create(unsigned int* indices, unsigned int count, Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateRef<glIndexBuffer>(indices, count);
case GraphicsAPI::OpenGL:
return CreateRef<glIndexBuffer>(indices, count);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateRef<dxIndexBuffer>(indices, count, std::dynamic_pointer_cast<dxSharedContext>(sharedContext));) return CreateRef<dxIndexBuffer>(indices, count, std::dynamic_pointer_cast<dxSharedContext>(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "IndexBuffer::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
//======================================== INDEX_BUFFER ========================================// }
//======================================== INDEX_BUFFER ========================================//
} } // namespace Light

25
Engine/src/Engine/Graphics/Framebuffer.cpp
View file

@ -1,4 +1,5 @@
#include "Framebuffer.h" #include "Framebuffer.h"
#include "OpenGL/glFramebuffer.h" #include "OpenGL/glFramebuffer.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -10,20 +11,20 @@
namespace Light { namespace Light {
Ref<Framebuffer> Framebuffer::Create(const FramebufferSpecification& specification, Ref<SharedContext> sharedContext) Ref<Framebuffer> Framebuffer::Create(const FramebufferSpecification& specification, Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateRef<glFramebuffer>(specification);
case GraphicsAPI::OpenGL:
return CreateRef<glFramebuffer>(specification);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateRef<dxFramebuffer>(specification, std::static_pointer_cast<dxSharedContext>(sharedContext));) return CreateRef<dxFramebuffer>(specification, std::static_pointer_cast<dxSharedContext>(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "Shader::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
}
} } // namespace Light

113
Engine/src/Engine/Graphics/GraphicsContext.cpp
View file

@ -1,4 +1,5 @@
#include "GraphicsContext.h" #include "GraphicsContext.h"
#include "OpenGL/glGraphicsContext.h" #include "OpenGL/glGraphicsContext.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -6,75 +7,73 @@
#include "DirectX/dxSharedContext.h" #include "DirectX/dxSharedContext.h"
#endif #endif
#include "Blender.h" // required for forward declaration #include "Blender.h" // required for forward declaration
#include "Buffers.h" // required for forward declaration #include "Buffers.h" // required for forward declaration
#include "Renderer.h" // required for forward declaration #include "RenderCommand.h" // required for forward declaration
#include "RenderCommand.h" // required for forward declaration #include "Renderer.h" // required for forward declaration
#include "UserInterface/UserInterface.h" // required for forward declaration #include "UserInterface/UserInterface.h" // required for forward declaration
#include "Utility/ResourceManager.h" // required for forward declaration
#include "Utility/ResourceManager.h" // required for forward declaration
namespace Light { namespace Light {
GraphicsContext* GraphicsContext::s_Context = nullptr; GraphicsContext* GraphicsContext::s_Context = nullptr;
GraphicsContext::~GraphicsContext() GraphicsContext::~GraphicsContext()
{
}
Scope<GraphicsContext> GraphicsContext::Create(GraphicsAPI api, GLFWwindow* windowHandle)
{
// terminate 'GraphicsContext' dependent classes
if (s_Context)
{ {
s_Context->m_Renderer.reset();
s_Context->m_UserInterface.reset();
delete s_Context;
} }
Scope<GraphicsContext> GraphicsContext::Create(GraphicsAPI api, GLFWwindow* windowHandle) // determine the default api
if (api == GraphicsAPI::Default)
{ {
// terminate 'GraphicsContext' dependent classes
if (s_Context)
{
s_Context->m_Renderer.reset();
s_Context->m_UserInterface.reset();
delete s_Context;
}
// determine the default api
if (api == GraphicsAPI::Default)
{
#if defined(LIGHT_PLATFORM_WINDOWS) #if defined(LIGHT_PLATFORM_WINDOWS)
api = GraphicsAPI::DirectX; api = GraphicsAPI::DirectX;
#elif defined(LIGHT_PLATFORM_LINUX) #elif defined(LIGHT_PLATFORM_LINUX)
api = GraphicsAPI::OpenGL; api = GraphicsAPI::OpenGL;
#elif defined(LIGHT_PLATFORM_MAC) #elif defined(LIGHT_PLATFORM_MAC)
api = GraphicsAPI::OpenGL; api = GraphicsAPI::OpenGL;
#endif #endif
}
// create gfx context
Scope<GraphicsContext> scopeGfx;
switch (api)
{
// opengl
case GraphicsAPI::OpenGL:
scopeGfx = CreateScope<glGraphicsContext>(windowHandle);
s_Context = scopeGfx.get();
break;
// directx
case GraphicsAPI::DirectX: LT_WIN(
scopeGfx = CreateScope<dxGraphicsContext>(windowHandle);
s_Context = scopeGfx.get();
break;)
default:
LT_ENGINE_ASSERT(false, "GraphicsContext::Create: invalid/unsupported 'GraphicsAPI' {}", Stringifier::GraphicsAPIToString(api));
return nullptr;
}
// create 'GraphicsContext' dependent classes
s_Context->m_UserInterface = UserInterface::Create(windowHandle, s_Context->m_SharedContext);
s_Context->m_Renderer = Renderer::Create(windowHandle, s_Context->m_SharedContext);
// check
LT_ENGINE_ASSERT(s_Context->m_UserInterface, "GraphicsContext::Create: failed to create UserInterface");
LT_ENGINE_ASSERT(s_Context->m_Renderer, "GraphicsContext::Create: failed to create Renderer");
return std::move(scopeGfx);
} }
} // create gfx context
Scope<GraphicsContext> scopeGfx;
switch (api)
{
// opengl
case GraphicsAPI::OpenGL:
scopeGfx = CreateScope<glGraphicsContext>(windowHandle);
s_Context = scopeGfx.get();
break;
// directx
case GraphicsAPI::DirectX: LT_WIN(
scopeGfx = CreateScope<dxGraphicsContext>(windowHandle);
s_Context = scopeGfx.get();
break;)
default:
ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", Stringifier::GraphicsAPIToString(api));
return nullptr;
}
// create 'GraphicsContext' dependent classes
s_Context->m_UserInterface = UserInterface::Create(windowHandle, s_Context->m_SharedContext);
s_Context->m_Renderer = Renderer::Create(windowHandle, s_Context->m_SharedContext);
// check
ASSERT(s_Context->m_UserInterface, "Failed to create UserInterface");
ASSERT(s_Context->m_Renderer, "Failed to create Renderer");
return std::move(scopeGfx);
}
} // namespace Light

25
Engine/src/Engine/Graphics/RenderCommand.cpp
View file

@ -1,4 +1,5 @@
#include "RenderCommand.h" #include "RenderCommand.h"
#include "OpenGL/glRenderCommand.h" #include "OpenGL/glRenderCommand.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -10,20 +11,20 @@
namespace Light { namespace Light {
Scope<RenderCommand> RenderCommand::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext) Scope<RenderCommand> RenderCommand::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateScope<glRenderCommand>(windowHandle);
case GraphicsAPI::OpenGL:
return CreateScope<glRenderCommand>(windowHandle);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateScope<dxRenderCommand>((std::static_pointer_cast<dxSharedContext>)(sharedContext));) return CreateScope<dxRenderCommand>((std::static_pointer_cast<dxSharedContext>)(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "RenderCommand::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
}
} } // namespace Light

12
Engine/src/Engine/Graphics/Renderer.cpp
View file

@ -19,7 +19,7 @@ Renderer* Renderer::s_Context = nullptr;
Renderer::Renderer(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext) Renderer::Renderer(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
: m_QuadRenderer(LT_MAX_QUAD_RENDERER_VERTICES, sharedContext), m_TextureRenderer(LT_MAX_TEXTURE_RENDERER_VERTICES, sharedContext), m_TintedTextureRenderer(LT_MAX_TINTED_TEXTURE_RENDERER_VERTICES, sharedContext), m_ViewProjectionBuffer(nullptr), m_RenderCommand(nullptr), m_Blender(nullptr), m_DefaultFramebufferCamera(nullptr), m_TargetFramebuffer(nullptr), m_ShouldClearBackbuffer(false) : m_QuadRenderer(LT_MAX_QUAD_RENDERER_VERTICES, sharedContext), m_TextureRenderer(LT_MAX_TEXTURE_RENDERER_VERTICES, sharedContext), m_TintedTextureRenderer(LT_MAX_TINTED_TEXTURE_RENDERER_VERTICES, sharedContext), m_ViewProjectionBuffer(nullptr), m_RenderCommand(nullptr), m_Blender(nullptr), m_DefaultFramebufferCamera(nullptr), m_TargetFramebuffer(nullptr), m_ShouldClearBackbuffer(false)
{ {
LT_ENGINE_ASSERT(!s_Context, "Renderer::Renderer: an instance of 'Renderer' already exists, do not construct this class!"); ASSERT(!s_Context, "An instance of 'Renderer' already exists, do not construct this class!");
s_Context = this; s_Context = this;
m_ViewProjectionBuffer = ConstantBuffer::Create(ConstantBufferIndex::ViewProjection, sizeof(glm::mat4), sharedContext); m_ViewProjectionBuffer = ConstantBuffer::Create(ConstantBufferIndex::ViewProjection, sizeof(glm::mat4), sharedContext);
@ -87,7 +87,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint)
// advance // advance
if (!m_QuadRenderer.Advance()) if (!m_QuadRenderer.Advance())
{ {
LT_ENGINE_WARN("Renderer::DrawQuadImpl: exceeded LT_MAX_QUAD_RENDERER_VERTICES: {}", LT_MAX_QUAD_RENDERER_VERTICES); LOG(warn, "Exceeded LT_MAX_QUAD_RENDERER_VERTICES: {}", LT_MAX_QUAD_RENDERER_VERTICES);
FlushScene(); FlushScene();
} }
} }
@ -97,7 +97,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint)
void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture) void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture)
{ {
// #todo: implement a proper binding // #todo: implement a proper binding
LT_ENGINE_ASSERT(texture, "Invalid texture passed to Renderer::DrawQuadImpl"); ASSERT(texture, "Texture passed to Renderer::DrawQuadImpl");
texture->Bind(); texture->Bind();
// locals // locals
@ -122,7 +122,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture)
// advance // advance
if (!m_TextureRenderer.Advance()) if (!m_TextureRenderer.Advance())
{ {
LT_ENGINE_WARN("Renderer::DrawQuadImpl: exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES); LOG(warn, "Exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES);
FlushScene(); FlushScene();
} }
} }
@ -130,7 +130,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, Ref<Texture> texture)
void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint, Ref<Texture> texture) void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint, Ref<Texture> texture)
{ {
// #todo: implement a proper binding // #todo: implement a proper binding
LT_ENGINE_ASSERT(texture, "Invalid texture passed to Renderer::DrawQuadImpl"); ASSERT(texture, "Texture passed to Renderer::DrawQuadImpl");
texture->Bind(); texture->Bind();
// locals // locals
@ -159,7 +159,7 @@ void Renderer::DrawQuadImpl(const glm::mat4& transform, const glm::vec4& tint, R
// advance // advance
if (!m_TintedTextureRenderer.Advance()) if (!m_TintedTextureRenderer.Advance())
{ {
LT_ENGINE_WARN("Renderer::DrawQuadImpl: exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES); LOG(warn, "Exceeded LT_MAX_TEXTURE_RENDERER_VERTICES: {}", LT_MAX_TEXTURE_RENDERER_VERTICES);
FlushScene(); FlushScene();
} }
} }

103
Engine/src/Engine/Graphics/RendererPrograms/QuadRendererProgram.cpp
View file

@ -1,67 +1,58 @@
#include "QuadRendererProgram.h" #include "QuadRendererProgram.h"
#include "Camera/Camera.h" #include "Camera/Camera.h"
#include "Graphics/Shader.h"
#include "Graphics/Buffers.h" #include "Graphics/Buffers.h"
#include "Graphics/Shader.h"
#include "Graphics/VertexLayout.h" #include "Graphics/VertexLayout.h"
#include "Utility/ResourceManager.h" #include "Utility/ResourceManager.h"
namespace Light { namespace Light {
QuadRendererProgram::QuadRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext) QuadRendererProgram::QuadRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
: m_Shader(nullptr), : m_Shader(nullptr), m_IndexBuffer(nullptr), m_VertexLayout(nullptr), m_MapCurrent(nullptr), m_MapEnd(nullptr), m_QuadCount(0u), m_MaxVertices(maxVertices)
m_IndexBuffer(nullptr), {
m_VertexLayout(nullptr), // #todo: don't use relative path
m_MapCurrent(nullptr), ResourceManager::LoadShader("LT_ENGINE_RESOURCES_QUAD_SHADER", "Assets/Shaders/Quad/Quad_VS.glsl", "Assets/Shaders/Quad/Quad_PS.glsl");
m_MapEnd(nullptr),
m_QuadCount(0u),
m_MaxVertices(maxVertices)
{
// #todo: don't use relative path
ResourceManager::LoadShader("LT_ENGINE_RESOURCES_QUAD_SHADER", "Assets/Shaders/Quad/Quad_VS.glsl", "Assets/Shaders/Quad/Quad_PS.glsl");
m_Shader = ResourceManager::GetShader("LT_ENGINE_RESOURCES_QUAD_SHADER");
m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(QuadVertexData), maxVertices, sharedContext));
m_IndexBuffer = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 },
{ "COLOR" , VertexElementType::Float4 }}, sharedContext));
}
bool QuadRendererProgram::Advance()
{
m_MapCurrent += 4;
if (m_MapCurrent >= m_MapEnd)
{
LT_ENGINE_WARN("QuadRendererProgram::Advance: 'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
return false;
}
m_QuadCount++;
return true;
}
void QuadRendererProgram::Map()
{
m_QuadCount = 0u;
m_MapCurrent = (QuadRendererProgram::QuadVertexData*)m_VertexBuffer->Map();
m_MapEnd = m_MapCurrent + m_MaxVertices;
}
void QuadRendererProgram::UnMap()
{
m_VertexBuffer->UnMap();
}
void QuadRendererProgram::Bind()
{
m_Shader->Bind();
m_VertexLayout->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
}
m_Shader = ResourceManager::GetShader("LT_ENGINE_RESOURCES_QUAD_SHADER");
m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(QuadVertexData), maxVertices, sharedContext));
m_IndexBuffer = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 }, { "COLOR", VertexElementType::Float4 } }, sharedContext));
} }
bool QuadRendererProgram::Advance()
{
m_MapCurrent += 4;
if (m_MapCurrent >= m_MapEnd)
{
LOG(warn, "'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
return false;
}
m_QuadCount++;
return true;
}
void QuadRendererProgram::Map()
{
m_QuadCount = 0u;
m_MapCurrent = (QuadRendererProgram::QuadVertexData*)m_VertexBuffer->Map();
m_MapEnd = m_MapCurrent + m_MaxVertices;
}
void QuadRendererProgram::UnMap()
{
m_VertexBuffer->UnMap();
}
void QuadRendererProgram::Bind()
{
m_Shader->Bind();
m_VertexLayout->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
}
} // namespace Light

101
Engine/src/Engine/Graphics/RendererPrograms/TextureRendererProgram.cpp
View file

@ -1,66 +1,57 @@
#include "TextureRendererProgram.h" #include "TextureRendererProgram.h"
#include "Camera/Camera.h" #include "Camera/Camera.h"
#include "Graphics/Shader.h"
#include "Graphics/Buffers.h" #include "Graphics/Buffers.h"
#include "Graphics/Shader.h"
#include "Graphics/VertexLayout.h" #include "Graphics/VertexLayout.h"
#include "Utility/ResourceManager.h" #include "Utility/ResourceManager.h"
namespace Light { namespace Light {
TextureRendererProgram::TextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext) TextureRendererProgram::TextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
: m_Shader(nullptr), : m_Shader(nullptr), m_IndexBuffer(nullptr), m_VertexLayout(nullptr), m_MapCurrent(nullptr), m_MapEnd(nullptr), m_QuadCount(0u), m_MaxVertices(maxVertices)
m_IndexBuffer(nullptr), {
m_VertexLayout(nullptr), // #todo: don't use relative path
m_MapCurrent(nullptr), ResourceManager::LoadShader("LT_ENGINE_RESOURCES_TEXTURE_SHADER", "Assets/Shaders/Texture/Texture_VS.glsl", "Assets/Shaders/Texture/Texture_PS.glsl");
m_MapEnd(nullptr),
m_QuadCount(0u),
m_MaxVertices(maxVertices)
{
// #todo: don't use relative path
ResourceManager::LoadShader("LT_ENGINE_RESOURCES_TEXTURE_SHADER", "Assets/Shaders/Texture/Texture_VS.glsl", "Assets/Shaders/Texture/Texture_PS.glsl");
m_Shader = ResourceManager::GetShader("LT_ENGINE_RESOURCES_TEXTURE_SHADER");
m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(TextureVertexData), maxVertices, sharedContext));
m_IndexBuffer = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 },
{ "TEXCOORD", VertexElementType::Float2 }}, sharedContext));
}
bool TextureRendererProgram::Advance()
{
if (m_MapCurrent + 4 >= m_MapEnd)
{
LT_ENGINE_WARN("TextureRendererProgram::Advance: 'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
return false;
}
m_MapCurrent += 4;
m_QuadCount++;
return true;
}
void TextureRendererProgram::Map()
{
m_QuadCount = 0u;
m_MapCurrent = (TextureRendererProgram::TextureVertexData*)m_VertexBuffer->Map();
m_MapEnd = m_MapCurrent + m_MaxVertices;
}
void TextureRendererProgram::UnMap()
{
m_VertexBuffer->UnMap();
}
void TextureRendererProgram::Bind()
{
m_Shader->Bind();
m_VertexLayout->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
}
m_Shader = ResourceManager::GetShader("LT_ENGINE_RESOURCES_TEXTURE_SHADER");
m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(TextureVertexData), maxVertices, sharedContext));
m_IndexBuffer = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 }, { "TEXCOORD", VertexElementType::Float2 } }, sharedContext));
} }
bool TextureRendererProgram::Advance()
{
if (m_MapCurrent + 4 >= m_MapEnd)
{
LOG(warn, "'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
return false;
}
m_MapCurrent += 4;
m_QuadCount++;
return true;
}
void TextureRendererProgram::Map()
{
m_QuadCount = 0u;
m_MapCurrent = (TextureRendererProgram::TextureVertexData*)m_VertexBuffer->Map();
m_MapEnd = m_MapCurrent + m_MaxVertices;
}
void TextureRendererProgram::UnMap()
{
m_VertexBuffer->UnMap();
}
void TextureRendererProgram::Bind()
{
m_Shader->Bind();
m_VertexLayout->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
}
} // namespace Light

104
Engine/src/Engine/Graphics/RendererPrograms/TintedTextureRendererProgram.cpp
View file

@ -1,68 +1,58 @@
#include "TintedTextureRendererProgram.h" #include "TintedTextureRendererProgram.h"
#include "Camera/Camera.h" #include "Camera/Camera.h"
#include "Graphics/Shader.h"
#include "Graphics/Buffers.h" #include "Graphics/Buffers.h"
#include "Graphics/Shader.h"
#include "Graphics/VertexLayout.h" #include "Graphics/VertexLayout.h"
#include "Utility/ResourceManager.h" #include "Utility/ResourceManager.h"
namespace Light { namespace Light {
TintedTextureRendererProgram::TintedTextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext) TintedTextureRendererProgram::TintedTextureRendererProgram(unsigned int maxVertices, Ref<SharedContext> sharedContext)
: m_Shader(nullptr), : m_Shader(nullptr), m_IndexBuffer(nullptr), m_VertexLayout(nullptr), m_MapCurrent(nullptr), m_MapEnd(nullptr), m_QuadCount(0u), m_MaxVertices(maxVertices)
m_IndexBuffer(nullptr), {
m_VertexLayout(nullptr), // #todo: don't use relative path
m_MapCurrent(nullptr), ResourceManager::LoadShader("LT_ENGINE_RESOURCES_TINTED_TEXTURE_SHADER", "Assets/Shaders/TintedTexture/TintedTexture_VS.glsl", "Assets/Shaders/TintedTexture/TintedTexture_PS.glsl");
m_MapEnd(nullptr),
m_QuadCount(0u),
m_MaxVertices(maxVertices)
{
// #todo: don't use relative path
ResourceManager::LoadShader("LT_ENGINE_RESOURCES_TINTED_TEXTURE_SHADER", "Assets/Shaders/TintedTexture/TintedTexture_VS.glsl", "Assets/Shaders/TintedTexture/TintedTexture_PS.glsl");
m_Shader = ResourceManager::GetShader("LT_ENGINE_RESOURCES_TINTED_TEXTURE_SHADER");
m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(TintedTextureVertexData), maxVertices, sharedContext));
m_IndexBuffer = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 },
{ "TINT" , VertexElementType::Float4 },
{ "TEXCOORD", VertexElementType::Float2 }}, sharedContext));
}
bool TintedTextureRendererProgram::Advance()
{
m_MapCurrent += 4;
if (m_MapCurrent >= m_MapEnd)
{
LT_ENGINE_WARN("TintedTextureRendererProgram::Advance: 'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
return false;
}
m_QuadCount++;
return true;
}
void TintedTextureRendererProgram::Map()
{
m_QuadCount = 0u;
m_MapCurrent = (TintedTextureRendererProgram::TintedTextureVertexData*)m_VertexBuffer->Map();
m_MapEnd = m_MapCurrent + m_MaxVertices;
}
void TintedTextureRendererProgram::UnMap()
{
m_VertexBuffer->UnMap();
}
void TintedTextureRendererProgram::Bind()
{
m_Shader->Bind();
m_VertexLayout->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
}
m_Shader = ResourceManager::GetShader("LT_ENGINE_RESOURCES_TINTED_TEXTURE_SHADER");
m_VertexBuffer = Ref<VertexBuffer>(VertexBuffer::Create(nullptr, sizeof(TintedTextureVertexData), maxVertices, sharedContext));
m_IndexBuffer = Ref<IndexBuffer>(IndexBuffer::Create(nullptr, (maxVertices / 4) * 6, sharedContext));
m_VertexLayout = Ref<VertexLayout>(VertexLayout::Create(m_VertexBuffer, m_Shader, { { "POSITION", VertexElementType::Float4 }, { "TINT", VertexElementType::Float4 }, { "TEXCOORD", VertexElementType::Float2 } }, sharedContext));
} }
bool TintedTextureRendererProgram::Advance()
{
m_MapCurrent += 4;
if (m_MapCurrent >= m_MapEnd)
{
LOG(warn, "'VertexBuffer' map went beyond 'MaxVertices': {}", m_MaxVertices);
return false;
}
m_QuadCount++;
return true;
}
void TintedTextureRendererProgram::Map()
{
m_QuadCount = 0u;
m_MapCurrent = (TintedTextureRendererProgram::TintedTextureVertexData*)m_VertexBuffer->Map();
m_MapEnd = m_MapCurrent + m_MaxVertices;
}
void TintedTextureRendererProgram::UnMap()
{
m_VertexBuffer->UnMap();
}
void TintedTextureRendererProgram::Bind()
{
m_Shader->Bind();
m_VertexLayout->Bind();
m_VertexBuffer->Bind();
m_IndexBuffer->Bind();
}
} // namespace Light

27
Engine/src/Engine/Graphics/Shader.cpp
View file

@ -1,4 +1,5 @@
#include "Shader.h" #include "Shader.h"
#include "OpenGL/glShader.h" #include "OpenGL/glShader.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -10,21 +11,21 @@
namespace Light { namespace Light {
Ref<Shader> Shader::Create(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<SharedContext> sharedContext) Ref<Shader> Shader::Create(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<SharedContext> sharedContext)
{
// load shader source
switch (GraphicsContext::GetGraphicsAPI())
{ {
// load shader source case GraphicsAPI::OpenGL:
switch (GraphicsContext::GetGraphicsAPI()) return CreateRef<glShader>(vertexFile, pixelFile);
{
case GraphicsAPI::OpenGL:
return CreateRef<glShader>(vertexFile, pixelFile);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateRef<dxShader>(vertexFile, pixelFile, std::static_pointer_cast<dxSharedContext>(sharedContext));) return CreateRef<dxShader>(vertexFile, pixelFile, std::static_pointer_cast<dxSharedContext>(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "Shader::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
}
} } // namespace Light

33
Engine/src/Engine/Graphics/Texture.cpp
View file

@ -1,4 +1,5 @@
#include "Texture.h" #include "Texture.h"
#include "OpenGL/glTexture.h" #include "OpenGL/glTexture.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -10,25 +11,25 @@
namespace Light { namespace Light {
Ref<Texture>Texture::Create(unsigned int width, unsigned int height, unsigned int components, unsigned char* pixels, Ref<SharedContext> sharedContext, const std::string& filePath) Ref<Texture> Texture::Create(unsigned int width, unsigned int height, unsigned int components, unsigned char* pixels, Ref<SharedContext> sharedContext, const std::string& filePath)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateRef<glTexture>(width, height, components, pixels, filePath);
case GraphicsAPI::OpenGL:
return CreateRef<glTexture>(width, height, components, pixels, filePath);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateRef<dxTexture>(width, height, components, pixels, std::static_pointer_cast<dxSharedContext>(sharedContext), filePath);) return CreateRef<dxTexture>(width, height, components, pixels, std::static_pointer_cast<dxSharedContext>(sharedContext), filePath);)
default: default:
LT_ENGINE_ASSERT(false, "Texture::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
}
Texture::Texture(const std::string& filePath): Texture::Texture(const std::string& filePath)
m_FilePath(filePath) : m_FilePath(filePath)
{ {
} }
} } // namespace Light

25
Engine/src/Engine/Graphics/VertexLayout.cpp
View file

@ -1,4 +1,5 @@
#include "VertexLayout.h" #include "VertexLayout.h"
#include "OpenGL/glVertexLayout.h" #include "OpenGL/glVertexLayout.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -10,20 +11,20 @@
namespace Light { namespace Light {
Ref<VertexLayout> VertexLayout::Create(Ref<VertexBuffer> vertexBuffer, Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<SharedContext> sharedContext) Ref<VertexLayout> VertexLayout::Create(Ref<VertexBuffer> vertexBuffer, Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<SharedContext> sharedContext)
{
switch (GraphicsContext::GetGraphicsAPI())
{ {
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::OpenGL:
{ return CreateRef<glVertexLayout>(vertexBuffer, elements);
case GraphicsAPI::OpenGL:
return CreateRef<glVertexLayout>(vertexBuffer, elements);
case GraphicsAPI::DirectX: LT_WIN( case GraphicsAPI::DirectX: LT_WIN(
return CreateRef<dxVertexLayout>(shader, elements, std::static_pointer_cast<dxSharedContext>(sharedContext));) return CreateRef<dxVertexLayout>(shader, elements, std::static_pointer_cast<dxSharedContext>(sharedContext));)
default: default:
LT_ENGINE_ASSERT(false, "VertexLayout::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI()); ASSERT(false, "Invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr; return nullptr;
}
} }
}
} } // namespace Light

259
Engine/src/Engine/Input/Input.cpp
View file

@ -1,160 +1,153 @@
#include "ltpch.h"
#include "Input.h" #include "Input.h"
#include "Events/Event.h"
#include "Events/CharEvent.h" #include "Events/CharEvent.h"
#include "Events/MouseEvents.h" #include "Events/Event.h"
#include "Events/KeyboardEvents.h" #include "Events/KeyboardEvents.h"
#include "Events/MouseEvents.h"
#include "Input/KeyCodes.h"
#include "ltpch.h"
#include <imgui.h> #include <imgui.h>
#include "Input/KeyCodes.h"
namespace Light { namespace Light {
Input* Input::s_Context = nullptr; Input* Input::s_Context = nullptr;
Scope<Input> Input::Create() Scope<Input> Input::Create()
{ {
return MakeScope(new Input); return MakeScope(new Input);
} }
Input::Input() Input::Input()
: m_KeyboadKeys{}, : m_KeyboadKeys {}, m_MouseButtons {}, m_MousePosition {}, m_MouseDelta {}, m_MouseWheelDelta {}, m_UserInterfaceEvents(true), m_GameEvents(true)
m_MouseButtons{}, {
m_MousePosition{}, ASSERT(!s_Context, "Input::Input: an instance of 'Input' already exists, do not construct this class!");
m_MouseDelta{}, s_Context = this;
m_MouseWheelDelta{},
m_UserInterfaceEvents(true),
m_GameEvents(true)
{
LT_ENGINE_ASSERT(!s_Context, "Input::Input: an instance of 'Input' already exists, do not construct this class!");
s_Context = this;
RestartInputState();
}
void Input::ReceiveUserInterfaceEventsImpl(bool receive, bool toggle /* = false */)
{
m_UserInterfaceEvents = toggle ? !m_UserInterfaceEvents : receive;
}
void Input::ReceieveGameEventsImpl(bool receive, bool toggle /*= false*/)
{
bool prev = m_GameEvents;
m_GameEvents = toggle ? !m_UserInterfaceEvents : receive;
if (m_GameEvents != prev)
RestartInputState(); RestartInputState();
} }
void Input::ReceiveUserInterfaceEventsImpl(bool receive, bool toggle /* = false */) void Input::RestartInputState()
{
m_KeyboadKeys.fill(false);
m_MouseButtons.fill(false);
m_MousePosition = glm::vec2(0.0f);
m_MouseDelta = glm::vec2(0.0f);
m_MouseWheelDelta = 0.0f;
}
void Input::OnEvent(const Event& inputEvent)
{
ImGuiIO& io = ImGui::GetIO();
switch (inputEvent.GetEventType())
{ {
m_UserInterfaceEvents = toggle ? !m_UserInterfaceEvents : receive; //** MOUSE_EVENTS **//
} case EventType::MouseMoved:
void Input::ReceieveGameEventsImpl(bool receive, bool toggle /*= false*/)
{ {
bool prev = m_GameEvents; const MouseMovedEvent& event = (const MouseMovedEvent&)inputEvent;
m_GameEvents = toggle ? !m_UserInterfaceEvents : receive;
if(m_GameEvents != prev) if (m_GameEvents)
RestartInputState(); {
m_MouseDelta = event.GetPosition() - m_MousePosition;
m_MousePosition = event.GetPosition();
}
if (m_UserInterfaceEvents)
io.MousePos = ImVec2(event.GetX(), event.GetY());
return;
} }
case EventType::ButtonPressed:
void Input::RestartInputState()
{ {
m_KeyboadKeys.fill(false); const ButtonPressedEvent& event = (const ButtonPressedEvent&)inputEvent;
m_MouseButtons.fill(false);
m_MousePosition = glm::vec2(0.0f); if (m_GameEvents)
m_MouseDelta = glm::vec2(0.0f); m_MouseButtons[event.GetButton()] = true;
m_MouseWheelDelta = 0.0f;
if (m_UserInterfaceEvents)
io.MouseDown[event.GetButton()] = true;
return;
} }
case EventType::ButtonReleased:
void Input::OnEvent(const Event& inputEvent)
{ {
ImGuiIO& io = ImGui::GetIO(); const ButtonReleasedEvent& event = (const ButtonReleasedEvent&)inputEvent;
switch (inputEvent.GetEventType())
{
//** MOUSE_EVENTS **//
case EventType::MouseMoved:
{
const MouseMovedEvent& event = (const MouseMovedEvent&)inputEvent;
if (m_GameEvents) if (m_GameEvents)
{ m_MouseButtons[event.GetButton()] = false;
m_MouseDelta = event.GetPosition() - m_MousePosition;
m_MousePosition = event.GetPosition();
}
if(m_UserInterfaceEvents) if (m_UserInterfaceEvents)
io.MousePos = ImVec2(event.GetX(), event.GetY()); io.MouseDown[event.GetButton()] = false;
return; return;
}
case EventType::ButtonPressed:
{
const ButtonPressedEvent& event = (const ButtonPressedEvent&)inputEvent;
if(m_GameEvents)
m_MouseButtons[event.GetButton()] = true;
if (m_UserInterfaceEvents)
io.MouseDown[event.GetButton()] = true;
return;
}
case EventType::ButtonReleased:
{
const ButtonReleasedEvent& event = (const ButtonReleasedEvent&)inputEvent;
if (m_GameEvents)
m_MouseButtons[event.GetButton()] = false;
if (m_UserInterfaceEvents)
io.MouseDown[event.GetButton()] = false;
return;
}
case EventType::WheelScrolled:
{
const WheelScrolledEvent& event = (const WheelScrolledEvent&)inputEvent;
if (m_GameEvents)
m_MouseWheelDelta = event.GetOffset();
if (m_UserInterfaceEvents)
io.MouseWheel = event.GetOffset();
return;
}
//** KEYBOARD_EVENTS **//
case EventType::KeyPressed:
{
const KeyPressedEvent& event = (const KeyPressedEvent&)inputEvent;
if (m_GameEvents)
m_KeyboadKeys[event.GetKey()] = true;
if (m_UserInterfaceEvents)
{
io.KeysDown[event.GetKey()] = true;
//if (event.GetKey() == Key::BackSpace)
// io.AddInputCharacter(Key::BackSpace);
}
return;
}
case EventType::KeyReleased:
{
const KeyReleasedEvent& event = (const KeyReleasedEvent&)inputEvent;
if (m_GameEvents)
m_KeyboadKeys[event.GetKey()] = false;
if (m_UserInterfaceEvents)
io.KeysDown[event.GetKey()] = false;
return;
}
case EventType::SetChar:
{
if(m_UserInterfaceEvents)
{
const SetCharEvent& event = (const SetCharEvent&)inputEvent;
io.AddInputCharacter(event.GetCharacter());
}
return;
}
}
} }
case EventType::WheelScrolled:
{
const WheelScrolledEvent& event = (const WheelScrolledEvent&)inputEvent;
} if (m_GameEvents)
m_MouseWheelDelta = event.GetOffset();
if (m_UserInterfaceEvents)
io.MouseWheel = event.GetOffset();
return;
}
//** KEYBOARD_EVENTS **//
case EventType::KeyPressed:
{
const KeyPressedEvent& event = (const KeyPressedEvent&)inputEvent;
if (m_GameEvents)
m_KeyboadKeys[event.GetKey()] = true;
if (m_UserInterfaceEvents)
{
io.KeysDown[event.GetKey()] = true;
//if (event.GetKey() == Key::BackSpace)
// io.AddInputCharacter(Key::BackSpace);
}
return;
}
case EventType::KeyReleased:
{
const KeyReleasedEvent& event = (const KeyReleasedEvent&)inputEvent;
if (m_GameEvents)
m_KeyboadKeys[event.GetKey()] = false;
if (m_UserInterfaceEvents)
io.KeysDown[event.GetKey()] = false;
return;
}
case EventType::SetChar:
{
if (m_UserInterfaceEvents)
{
const SetCharEvent& event = (const SetCharEvent&)inputEvent;
io.AddInputCharacter(event.GetCharacter());
}
return;
}
}
}
} // namespace Light

73
Engine/src/Engine/Layer/LayerStack.cpp
View file

@ -1,54 +1,51 @@
#include "LayerStack.h" #include "LayerStack.h"
#include "Layer.h"
#include "Events/Event.h" #include "Events/Event.h"
#include "Events/MouseEvents.h"
#include "Events/KeyboardEvents.h" #include "Events/KeyboardEvents.h"
#include "Events/MouseEvents.h"
#include "Events/WindowEvents.h" #include "Events/WindowEvents.h"
#include "Layer.h"
namespace Light { namespace Light {
LayerStack* LayerStack::s_Context = nullptr; LayerStack* LayerStack::s_Context = nullptr;
Scope<LayerStack> LayerStack::Create() Scope<LayerStack> LayerStack::Create()
{ {
return MakeScope<LayerStack>(new LayerStack()); return MakeScope<LayerStack>(new LayerStack());
} }
LayerStack::LayerStack() LayerStack::LayerStack()
: m_Layers{}, : m_Layers {}, m_Begin(), m_End()
m_Begin(), {
m_End() ASSERT(!s_Context, "An instance of 'LayerStack' already exists, do not construct this class!")
{ s_Context = this;
LT_ENGINE_ASSERT(!s_Context, "LayerStack::LayerStack: an instance of 'LayerStack' already exists, do not construct this class!") }
s_Context = this;
}
LayerStack::~LayerStack() LayerStack::~LayerStack()
{ {
for (Layer* layer : m_Layers) for (Layer* layer : m_Layers)
delete layer; delete layer;
} }
void LayerStack::AttachLayerImpl(Layer* layer) void LayerStack::AttachLayerImpl(Layer* layer)
{ {
// #todo: handle attaching layer inside a for loop // #todo: handle attaching layer inside a for loop
m_Layers.push_back(layer); m_Layers.push_back(layer);
m_Begin = m_Layers.begin(); m_Begin = m_Layers.begin();
m_End = m_Layers.end(); m_End = m_Layers.end();
LT_ENGINE_TRACE("LayerStack::PushLayer: Attached [{}]", layer->GetName()); LOG(trace, "Attached [{}]", layer->GetName());
} }
void LayerStack::DetachLayerImpl(Layer* layer) void LayerStack::DetachLayerImpl(Layer* layer)
{ {
// #todo: handle detaching layer inside a for loop // #todo: handle detaching layer inside a for loop
m_Layers.erase(std::find(m_Layers.begin(), m_Layers.end(), layer)); m_Layers.erase(std::find(m_Layers.begin(), m_Layers.end(), layer));
m_Begin = m_Layers.begin(); m_Begin = m_Layers.begin();
m_End = m_Layers.end(); m_End = m_Layers.end();
LT_ENGINE_TRACE("LayerStack::PushLayer: Detached[{}]", layer->GetName()); LOG(trace, "Detached [{}]", layer->GetName());
} }
} } // namespace Light

211
Engine/src/Engine/Scene/Scene.cpp
View file

@ -2,122 +2,109 @@
#include "Components.h" #include "Components.h"
#include "Entity.h" #include "Entity.h"
#include "Graphics/Renderer.h" #include "Graphics/Renderer.h"
#include <glm/glm.hpp> #include <glm/glm.hpp>
namespace Light { namespace Light {
Scene::Scene() Scene::Scene()
: m_Registry() : m_Registry()
{ {
}
Scene::~Scene()
{
}
void Scene::OnCreate()
{
/* native scripts */
{
m_Registry.view<NativeScriptComponent>().
each([](NativeScriptComponent& nsc)
{
if (nsc.instance == nullptr)
{
nsc.instance = nsc.CreateInstance();
nsc.instance->OnCreate();
}
});
}
}
void Scene::OnUpdate(float deltaTime)
{
/* native scripts */
{
m_Registry.view<NativeScriptComponent>().
each([=](NativeScriptComponent& nsc)
{
nsc.instance->OnUpdate(deltaTime);
});
}
}
void Scene::OnRender(const Ref<Framebuffer>& targetFrameBuffer /* = nullptr */)
{
Camera* sceneCamera = nullptr;
TransformComponent* sceneCameraTransform;
/* scene camera */
{
m_Registry.group(entt::get<TransformComponent, CameraComponent>).
each([&](TransformComponent& transformComp, CameraComponent& cameraComp)
{
if (cameraComp.isPrimary)
{
sceneCamera = &cameraComp.camera;
sceneCameraTransform = &transformComp;
}
});
}
/* draw quads */
{
if (sceneCamera)
{
Renderer::BeginScene(sceneCamera, *sceneCameraTransform, targetFrameBuffer);
m_Registry.group(entt::get<TransformComponent, SpriteRendererComponent>).
each([](TransformComponent& transformComp, SpriteRendererComponent& spriteRendererComp)
{
Renderer::DrawQuad(transformComp, spriteRendererComp.tint, spriteRendererComp.texture);
});
Renderer::EndScene();
}
}
}
Entity Scene::CreateEntity(const std::string& name, const TransformComponent& transform)
{
return CreateEntityWithUUID(name, UUID(), transform);
}
Entity Scene::GetEntityByTag(const std::string& tag)
{
// TagComponent tagComp(tag);
// entt::entity entity = entt::to_entity(m_Registry, tagComp);
Entity entity;
m_Registry.view<TagComponent>().
each([&](TagComponent& tagComp)
{
if (tagComp.tag == tag)
entity = Entity(entt::to_entity(m_Registry, tagComp), this);
});
if (entity.IsValid())
return entity;
else {
LT_ENGINE_ERROR("Scene::GetEntityByTag: failed to find entity by tag: {}", tag);
return Entity();
}
}
Entity Scene::CreateEntityWithUUID(const std::string& name, UUID uuid, const TransformComponent& transform)
{
Entity entity { m_Registry.create(), this };
entity.AddComponent<TagComponent>(name);
entity.AddComponent<TransformComponent>(transform);
entity.AddComponent<UUIDComponent>(uuid);
return entity;
}
} }
Scene::~Scene()
{
}
void Scene::OnCreate()
{
/* native scripts */
{
m_Registry.view<NativeScriptComponent>().each([](NativeScriptComponent& nsc) {
if (nsc.instance == nullptr)
{
nsc.instance = nsc.CreateInstance();
nsc.instance->OnCreate();
}
});
}
}
void Scene::OnUpdate(float deltaTime)
{
/* native scripts */
{
m_Registry.view<NativeScriptComponent>().each([=](NativeScriptComponent& nsc) {
nsc.instance->OnUpdate(deltaTime);
});
}
}
void Scene::OnRender(const Ref<Framebuffer>& targetFrameBuffer /* = nullptr */)
{
Camera* sceneCamera = nullptr;
TransformComponent* sceneCameraTransform;
/* scene camera */
{
m_Registry.group(entt::get<TransformComponent, CameraComponent>).each([&](TransformComponent& transformComp, CameraComponent& cameraComp) {
if (cameraComp.isPrimary)
{
sceneCamera = &cameraComp.camera;
sceneCameraTransform = &transformComp;
}
});
}
/* draw quads */
{
if (sceneCamera)
{
Renderer::BeginScene(sceneCamera, *sceneCameraTransform, targetFrameBuffer);
m_Registry.group(entt::get<TransformComponent, SpriteRendererComponent>).each([](TransformComponent& transformComp, SpriteRendererComponent& spriteRendererComp) {
Renderer::DrawQuad(transformComp, spriteRendererComp.tint, spriteRendererComp.texture);
});
Renderer::EndScene();
}
}
}
Entity Scene::CreateEntity(const std::string& name, const TransformComponent& transform)
{
return CreateEntityWithUUID(name, UUID(), transform);
}
Entity Scene::GetEntityByTag(const std::string& tag)
{
// TagComponent tagComp(tag);
// entt::entity entity = entt::to_entity(m_Registry, tagComp);
Entity entity;
m_Registry.view<TagComponent>().each([&](TagComponent& tagComp) {
if (tagComp.tag == tag)
entity = Entity(entt::to_entity(m_Registry, tagComp), this);
});
if (entity.IsValid())
return entity;
else
{
ASSERT("Scene::GetEntityByTag: failed to find entity by tag: {}", tag);
return Entity();
}
}
Entity Scene::CreateEntityWithUUID(const std::string& name, UUID uuid, const TransformComponent& transform)
{
Entity entity { m_Registry.create(), this };
entity.AddComponent<TagComponent>(name);
entity.AddComponent<TransformComponent>(transform);
entity.AddComponent<UUIDComponent>(uuid);
return entity;
}
} // namespace Light

322
Engine/src/Engine/UserInterface/UserInterface.cpp
View file

@ -1,4 +1,5 @@
#include "UserInterface.h" #include "UserInterface.h"
#include "OpenGL/glUserInterface.h" #include "OpenGL/glUserInterface.h"
#ifdef LIGHT_PLATFORM_WINDOWS #ifdef LIGHT_PLATFORM_WINDOWS
@ -6,217 +7,216 @@
#include "DirectX/dxSharedContext.h" #include "DirectX/dxSharedContext.h"
#endif #endif
#include "Events/Event.h"
#include "Events/CharEvent.h" #include "Events/CharEvent.h"
#include "Events/MouseEvents.h" #include "Events/Event.h"
#include "Events/KeyboardEvents.h" #include "Events/KeyboardEvents.h"
#include "Events/MouseEvents.h"
#include "Graphics/GraphicsContext.h" #include "Graphics/GraphicsContext.h"
#include "Input/KeyCodes.h" #include "Input/KeyCodes.h"
#include <imgui.h> #include <imgui.h>
namespace Light { namespace Light {
UserInterface* UserInterface::s_Context = nullptr; UserInterface* UserInterface::s_Context = nullptr;
Scope<UserInterface> UserInterface::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext) Scope<UserInterface> UserInterface::Create(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
{
Scope<UserInterface> scopeUserInterface = nullptr;
switch (GraphicsContext::GetGraphicsAPI())
{ {
Scope<UserInterface> scopeUserInterface = nullptr; case GraphicsAPI::OpenGL:
scopeUserInterface = CreateScope<glUserInterface>();
break;
switch (GraphicsContext::GetGraphicsAPI()) case GraphicsAPI::DirectX:
{ LT_WIN(
case GraphicsAPI::OpenGL: scopeUserInterface = CreateScope<dxUserInterface>();)
scopeUserInterface = CreateScope<glUserInterface>(); break;
break;
case GraphicsAPI::DirectX: LT_WIN( default:
scopeUserInterface = CreateScope<dxUserInterface>();) ASSERT(false, "UserInterface::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
break; return nullptr;
default:
LT_ENGINE_ASSERT(false, "UserInterface::Create: invalid/unsupported 'GraphicsAPI' {}", GraphicsContext::GetGraphicsAPI());
return nullptr;
}
scopeUserInterface->Init(windowHandle, sharedContext);
return std::move(scopeUserInterface);
} }
UserInterface::UserInterface() scopeUserInterface->Init(windowHandle, sharedContext);
: m_DockspaceFlags(ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar | return std::move(scopeUserInterface);
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | }
ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus )
{
LT_ENGINE_ASSERT(!s_Context, "UserInterface::UserInterface: an instance of 'UserInterface' already exists, do not construct this class!");
s_Context = this;
}
void UserInterface::Init(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext) UserInterface::UserInterface()
{ : m_DockspaceFlags(ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar |
// create context ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
IMGUI_CHECKVERSION(); ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus)
ImGui::CreateContext(); {
ASSERT(!s_Context, "UserInterface::UserInterface: an instance of 'UserInterface' already exists, do not construct this class!");
s_Context = this;
}
// configure io void UserInterface::Init(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
ImGuiIO& io = ImGui::GetIO(); {
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // create context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // configure io
io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
io.ConfigFlags |= ImGuiBackendFlags_PlatformHasViewports; io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
io.ConfigFlags |= ImGuiBackendFlags_RendererHasViewports; io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
// #todo: handle this in a better way io.ConfigFlags |= ImGuiBackendFlags_PlatformHasViewports;
if (std::filesystem::exists("user_gui_layout.ini")) io.ConfigFlags |= ImGuiBackendFlags_RendererHasViewports;
io.IniFilename = "user_gui_layout.ini";
else
io.IniFilename = "default_gui_layout.ini";
// style // #todo: handle this in a better way
ImGui::StyleColorsDark(); if (std::filesystem::exists("user_gui_layout.ini"))
io.IniFilename = "user_gui_layout.ini";
else
io.IniFilename = "default_gui_layout.ini";
PlatformImplementation(windowHandle, sharedContext); // style
ImGui::StyleColorsDark();
// keyboard map PlatformImplementation(windowHandle, sharedContext);
io.KeyMap[ImGuiKey_Tab] = Key::Tab;
io.KeyMap[ImGuiKey_LeftArrow] = Key::LeftArrow;
io.KeyMap[ImGuiKey_RightArrow] = Key::RightArrow;
io.KeyMap[ImGuiKey_UpArrow] = Key::UpArrow;
io.KeyMap[ImGuiKey_DownArrow] = Key::DownArrow;
io.KeyMap[ImGuiKey_PageUp] = Key::PageUp;
io.KeyMap[ImGuiKey_PageDown] = Key::PageDown;
io.KeyMap[ImGuiKey_Home] = Key::Home;
io.KeyMap[ImGuiKey_End] = Key::End;
io.KeyMap[ImGuiKey_Insert] = Key::Insert;
io.KeyMap[ImGuiKey_Delete] = Key::Delete;
io.KeyMap[ImGuiKey_Backspace] = Key::BackSpace;
io.KeyMap[ImGuiKey_Space] = Key::Space;
io.KeyMap[ImGuiKey_Enter] = Key::Enter;
io.KeyMap[ImGuiKey_Escape] = Key::Escape;
io.KeyMap[ImGuiKey_KeyPadEnter] = Key::Enter;
io.KeyMap[ImGuiKey_A] = Key::A;
io.KeyMap[ImGuiKey_C] = Key::C;
io.KeyMap[ImGuiKey_V] = Key::V;
io.KeyMap[ImGuiKey_X] = Key::X;
io.KeyMap[ImGuiKey_Y] = Key::Y;
io.KeyMap[ImGuiKey_Z] = Key::Z;
io.Fonts->AddFontFromFileTTF("Assets//Fonts/OpenSans/OpenSans-Bold.ttf", 18.0f); // keyboard map
io.FontDefault = io.Fonts->AddFontFromFileTTF("Assets/Fonts/OpenSans/OpenSans-Regular.ttf", 18.0f); io.KeyMap[ImGuiKey_Tab] = Key::Tab;
io.KeyMap[ImGuiKey_LeftArrow] = Key::LeftArrow;
io.KeyMap[ImGuiKey_RightArrow] = Key::RightArrow;
io.KeyMap[ImGuiKey_UpArrow] = Key::UpArrow;
io.KeyMap[ImGuiKey_DownArrow] = Key::DownArrow;
io.KeyMap[ImGuiKey_PageUp] = Key::PageUp;
io.KeyMap[ImGuiKey_PageDown] = Key::PageDown;
io.KeyMap[ImGuiKey_Home] = Key::Home;
io.KeyMap[ImGuiKey_End] = Key::End;
io.KeyMap[ImGuiKey_Insert] = Key::Insert;
io.KeyMap[ImGuiKey_Delete] = Key::Delete;
io.KeyMap[ImGuiKey_Backspace] = Key::BackSpace;
io.KeyMap[ImGuiKey_Space] = Key::Space;
io.KeyMap[ImGuiKey_Enter] = Key::Enter;
io.KeyMap[ImGuiKey_Escape] = Key::Escape;
io.KeyMap[ImGuiKey_KeyPadEnter] = Key::Enter;
io.KeyMap[ImGuiKey_A] = Key::A;
io.KeyMap[ImGuiKey_C] = Key::C;
io.KeyMap[ImGuiKey_V] = Key::V;
io.KeyMap[ImGuiKey_X] = Key::X;
io.KeyMap[ImGuiKey_Y] = Key::Y;
io.KeyMap[ImGuiKey_Z] = Key::Z;
SetDarkThemeColors(); io.Fonts->AddFontFromFileTTF("Assets//Fonts/OpenSans/OpenSans-Bold.ttf", 18.0f);
} io.FontDefault = io.Fonts->AddFontFromFileTTF("Assets/Fonts/OpenSans/OpenSans-Regular.ttf", 18.0f);
void UserInterface::DockspaceBegin() SetDarkThemeColors();
{ }
ImGuiViewport* viewport = ImGui::GetMainViewport();
ImGui::SetNextWindowPos(viewport->Pos);
ImGui::SetNextWindowSize(viewport->Size);
ImGui::SetNextWindowViewport(viewport->ID);
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f); void UserInterface::DockspaceBegin()
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f); {
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f)); ImGuiViewport* viewport = ImGui::GetMainViewport();
ImGui::Begin("Dockspace", (bool*)0, s_Context->m_DockspaceFlags); ImGui::SetNextWindowPos(viewport->Pos);
ImGui::PopStyleVar(3); ImGui::SetNextWindowSize(viewport->Size);
ImGui::SetNextWindowViewport(viewport->ID);
ImGuiStyle& style = ImGui::GetStyle(); ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
float minWinSizeX = style.WindowMinSize.x; ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
style.WindowMinSize.x = 370.0f; ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
ImGui::DockSpace(ImGui::GetID("MyDockSpace"), ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_None | ImGuiWindowFlags_NoBackground); ImGui::Begin("Dockspace", (bool*)0, s_Context->m_DockspaceFlags);
style.WindowMinSize.x = minWinSizeX; ImGui::PopStyleVar(3);
}
void UserInterface::DockspaceEnd() ImGuiStyle& style = ImGui::GetStyle();
{ float minWinSizeX = style.WindowMinSize.x;
ImGui::End(); style.WindowMinSize.x = 370.0f;
} ImGui::DockSpace(ImGui::GetID("MyDockSpace"), ImVec2(0.0f, 0.0f), ImGuiDockNodeFlags_None | ImGuiWindowFlags_NoBackground);
style.WindowMinSize.x = minWinSizeX;
}
void UserInterface::SetDarkThemeColors() void UserInterface::DockspaceEnd()
{ {
ImGuiStyle& style = ImGui::GetStyle(); ImGui::End();
ImVec4 (&colors)[55] = style.Colors; }
style.WindowPadding = ImVec2(0.0f, 0.0f); void UserInterface::SetDarkThemeColors()
{
ImGuiStyle& style = ImGui::GetStyle();
ImVec4(&colors)[55] = style.Colors;
colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f); style.WindowPadding = ImVec2(0.0f, 0.0f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
colors[ImGuiCol_WindowBg] = ImVec4(0.10f, 0.10f, 0.11f, 1.00f); colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
colors[ImGuiCol_Border] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f); colors[ImGuiCol_WindowBg] = ImVec4(0.10f, 0.10f, 0.11f, 1.00f);
colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
colors[ImGuiCol_FrameBg] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f); colors[ImGuiCol_Border] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
colors[ImGuiCol_FrameBgHovered] = ImVec4(0.30f, 0.31f, 0.31f, 1.00f); colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_FrameBgActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_TitleBg] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f); colors[ImGuiCol_FrameBg] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f);
colors[ImGuiCol_TitleBgActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f); colors[ImGuiCol_FrameBgHovered] = ImVec4(0.30f, 0.31f, 0.31f, 1.00f);
colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f); colors[ImGuiCol_FrameBgActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_MenuBarBg] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f); colors[ImGuiCol_TitleBg] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_TitleBgActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.53f); colors[ImGuiCol_MenuBarBg] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f); colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);
colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
colors[ImGuiCol_SliderGrab] = ImVec4(0.24f, 0.52f, 0.88f, 1.00f); colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_SliderGrabActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_Button] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f); colors[ImGuiCol_SliderGrab] = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);
colors[ImGuiCol_ButtonHovered] = ImVec4(0.30f, 0.31f, 0.31f, 1.00f); colors[ImGuiCol_SliderGrabActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_ButtonActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_Header] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f); colors[ImGuiCol_Button] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f);
colors[ImGuiCol_HeaderHovered] = ImVec4(0.30f, 0.31f, 0.31f, 1.00f); colors[ImGuiCol_ButtonHovered] = ImVec4(0.30f, 0.31f, 0.31f, 1.00f);
colors[ImGuiCol_HeaderActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f); colors[ImGuiCol_ButtonActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_Separator] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f); colors[ImGuiCol_Header] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f);
colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f); colors[ImGuiCol_HeaderHovered] = ImVec4(0.30f, 0.31f, 0.31f, 1.00f);
colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f); colors[ImGuiCol_HeaderActive] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_ResizeGrip] = ImVec4(0.26f, 0.59f, 0.98f, 0.20f); colors[ImGuiCol_Separator] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f); colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);
colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f); colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);
colors[ImGuiCol_Tab] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f); colors[ImGuiCol_ResizeGrip] = ImVec4(0.26f, 0.59f, 0.98f, 0.20f);
colors[ImGuiCol_TabHovered] = ImVec4(0.38f, 0.38f, 0.38f, 1.00f); colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
colors[ImGuiCol_TabActive] = ImVec4(0.28f, 0.28f, 0.28f, 1.00f); colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
colors[ImGuiCol_TabUnfocused] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_TabUnfocusedActive] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f);
colors[ImGuiCol_DockingPreview] = ImVec4(0.26f, 0.59f, 0.98f, 0.70f); colors[ImGuiCol_Tab] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f); colors[ImGuiCol_TabHovered] = ImVec4(0.38f, 0.38f, 0.38f, 1.00f);
colors[ImGuiCol_TabActive] = ImVec4(0.28f, 0.28f, 0.28f, 1.00f);
colors[ImGuiCol_TabUnfocused] = ImVec4(0.15f, 0.15f, 0.15f, 1.00f);
colors[ImGuiCol_TabUnfocusedActive] = ImVec4(0.20f, 0.20f, 0.21f, 1.00f);
colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f); colors[ImGuiCol_DockingPreview] = ImVec4(0.26f, 0.59f, 0.98f, 0.70f);
colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f); colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
colors[ImGuiCol_TableHeaderBg] = ImVec4(0.19f, 0.19f, 0.20f, 1.00f); colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.35f, 1.00f); colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
colors[ImGuiCol_TableBorderLight] = ImVec4(0.23f, 0.23f, 0.25f, 1.00f); colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f); colors[ImGuiCol_TableHeaderBg] = ImVec4(0.19f, 0.19f, 0.20f, 1.00f);
colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.35f, 1.00f);
colors[ImGuiCol_TableBorderLight] = ImVec4(0.23f, 0.23f, 0.25f, 1.00f);
colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f); colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
colors[ImGuiCol_NavHighlight] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f); colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f); colors[ImGuiCol_NavHighlight] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
} colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
} colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
}
} // namespace Light

90
Engine/src/Engine/Utility/FileManager.cpp
View file

@ -4,56 +4,56 @@
namespace Light { namespace Light {
BasicFileHandle FileManager::ReadTextFile(const std::string& path) BasicFileHandle FileManager::ReadTextFile(const std::string& path)
{
// parse path info
std::string name = path.substr(0, path.find('.') + -1);
std::string extension = path.substr(path.find('.') + 1);
// open file
std::ifstream file(path.c_str(), std::ios_base::in | std::ios_base::binary);
// check
if (!file)
{ {
// parse path info LOG(warn, "Failed to load text file: {}", path);
std::string name = path.substr(0, path.find('.') + -1);
std::string extension = path.substr(path.find('.') + 1);
// open file
std::ifstream file(path.c_str(), std::ios_base::in | std::ios_base::binary);
// check
if (!file)
{
LT_ENGINE_WARN("FileManager::ReadTextFile: failed to load text file: {}", path);
file.close();
return NULL;
}
// fetch file size
file.seekg(0, std::ios::end);
uint32_t size = file.tellg();
file.seekg(0, std::ios::beg);
if (!size)
LT_ENGINE_WARN("FileManager::ReadTextFile: empty text file: {}", path);
// read file
uint8_t* data = new uint8_t[size];
file.read(reinterpret_cast<char*>(data), size);
file.close(); file.close();
return BasicFileHandle(data, size, path, name, extension); return NULL;
} }
ImageFileHandle FileManager::ReadImageFile(const std::string& path, int32_t desiredComponents) // fetch file size
{ file.seekg(0, std::ios::end);
// parse path info uint32_t size = file.tellg();
std::string name = path.substr(0, path.find('.') + -1); file.seekg(0, std::ios::beg);
std::string extension = path.substr(path.find('.') + 1);
// load image if (!size)
int32_t width = 0, height = 0, fetchedComponents = 0; LOG(warn, "Empty text file: {}", path);
uint8_t* pixels = stbi_load(path.c_str(), &width, &height, &fetchedComponents, desiredComponents);
// check // read file
if(!pixels) uint8_t* data = new uint8_t[size];
LT_ENGINE_WARN("FileManager::LoadImageFile: failed to load image file: <{}>", path); file.read(reinterpret_cast<char*>(data), size);
else if (fetchedComponents != desiredComponents)
LT_ENGINE_WARN("FileManager::LoadImageFile: mismatch of fetched/desired components: <{}> ({}/{})", name + '.' + extension, fetchedComponents, desiredComponents);
return ImageFileHandle(pixels, width * height, path, name, extension, width, height, fetchedComponents, desiredComponents); file.close();
} return BasicFileHandle(data, size, path, name, extension);
}
} ImageFileHandle FileManager::ReadImageFile(const std::string& path, int32_t desiredComponents)
{
// parse path info
std::string name = path.substr(0, path.find('.') + -1);
std::string extension = path.substr(path.find('.') + 1);
// load image
int32_t width = 0, height = 0, fetchedComponents = 0;
uint8_t* pixels = stbi_load(path.c_str(), &width, &height, &fetchedComponents, desiredComponents);
// check
if (!pixels)
LOG(warn, "Failed to load image file: <{}>", path);
else if (fetchedComponents != desiredComponents)
LOG(warn, "Mismatch of fetched/desired components: <{}> ({}/{})", name + '.' + extension, fetchedComponents, desiredComponents);
return ImageFileHandle(pixels, width * height, path, name, extension, width, height, fetchedComponents, desiredComponents);
}
} // namespace Light

118
Engine/src/Engine/Utility/ResourceManager.cpp
View file

@ -1,74 +1,72 @@
#include "ResourceManager.h" #include "ResourceManager.h"
#include "FileManager.h" #include "FileManager.h"
#include "Graphics/GraphicsContext.h" #include "Graphics/GraphicsContext.h"
#include "Graphics/Shader.h" #include "Graphics/Shader.h"
#include "Graphics/Texture.h" #include "Graphics/Texture.h"
namespace Light { namespace Light {
ResourceManager* ResourceManager::s_Context = nullptr; ResourceManager* ResourceManager::s_Context = nullptr;
Scope<ResourceManager> ResourceManager::Create() Scope<ResourceManager> ResourceManager::Create()
{
return MakeScope(new ResourceManager());
}
ResourceManager::ResourceManager()
: m_Shaders {}, m_Textures {}
{
ASSERT(!s_Context, "Repeated singleton construction");
s_Context = this;
}
void ResourceManager::LoadShaderImpl(const std::string& name, const std::string& vertexPath, const std::string& pixelPath)
{
// check
ASSERT(s_Context, "Uninitliazed singleton");
ASSERT(!vertexPath.empty(), "Empty 'vertexPath'");
ASSERT(!pixelPath.empty(), "Empty 'pixelPath'");
// load files
BasicFileHandle vertexFile = FileManager::ReadTextFile(vertexPath);
BasicFileHandle pixelFile = FileManager::ReadTextFile(pixelPath);
// check
ASSERT(vertexFile.IsValid(), "Failed to read vertex file: {}", vertexPath);
ASSERT(pixelFile.IsValid(), "Failed to read vertex file: {}", pixelPath);
// create shader
m_Shaders[name] = Ref<Shader>(Shader::Create(vertexFile, pixelFile, GraphicsContext::GetSharedContext()));
// free file
vertexFile.Release();
pixelFile.Release();
}
void ResourceManager::LoadTextureImpl(const std::string& name, const std::string& path, unsigned int desiredComponents /* = 4u */)
{
ASSERT(s_Context, "Uninitliazed singleton");
// load file
ImageFileHandle imgFile = FileManager::ReadImageFile(path, desiredComponents);
// create texture
m_Textures[name] = Ref<Texture>(Texture::Create(imgFile.GetWidth(), imgFile.GetHeight(), imgFile.GetComponents(), imgFile.GetData(), GraphicsContext::GetSharedContext(), path));
// free file
imgFile.Release();
}
void ResourceManager::ReleaseTextureImpl(const std::string& name)
{
if (!m_Textures[name])
{ {
return MakeScope(new ResourceManager()); LOG(warn, "Failed to find texture named: {}", name);
return;
} }
ResourceManager::ResourceManager() : m_Textures[name] = nullptr;
m_Shaders{}, }
m_Textures{}
{
LT_ENGINE_ASSERT(!s_Context, "ResourceManager::ResourceManager: repeated singleton construction");
s_Context = this;
}
void ResourceManager::LoadShaderImpl(const std::string& name, const std::string& vertexPath, const std::string& pixelPath) } // namespace Light
{
// check
LT_ENGINE_ASSERT(s_Context, "ResourceManager::LoadShaderImpl: uninitliazed singleton");
LT_ENGINE_ASSERT(!vertexPath.empty(), "ResourceManager::LoadShaderImpl: empty 'vertexPath'");
LT_ENGINE_ASSERT(!pixelPath.empty(), "ResourceManager::LoadShaderImpl: empty 'pixelPath'");
// load files
BasicFileHandle vertexFile = FileManager::ReadTextFile(vertexPath);
BasicFileHandle pixelFile = FileManager::ReadTextFile(pixelPath);
// check
LT_ENGINE_ASSERT(vertexFile.IsValid(), "ResourceManager::LoadShaderImpl: failed to read vertex file: {}", vertexPath);
LT_ENGINE_ASSERT(pixelFile.IsValid(), "ResourceManager::LoadShaderImpl: failed to read vertex file: {}", pixelPath);
// create shader
m_Shaders[name] = Ref<Shader>(Shader::Create(vertexFile, pixelFile, GraphicsContext::GetSharedContext()));
// free file
vertexFile.Release();
pixelFile.Release();
}
void ResourceManager::LoadTextureImpl(const std::string& name, const std::string& path, unsigned int desiredComponents /* = 4u */)
{
LT_ENGINE_ASSERT(s_Context, "ResourceManager::LoadShaderImpl: uninitliazed singleton");
// load file
ImageFileHandle imgFile = FileManager::ReadImageFile(path, desiredComponents);
// create texture
m_Textures[name] = Ref<Texture>(Texture::Create(imgFile.GetWidth(), imgFile.GetHeight(), imgFile.GetComponents(), imgFile.GetData(), GraphicsContext::GetSharedContext(), path));
// free file
imgFile.Release();
}
void ResourceManager::ReleaseTextureImpl(const std::string& name)
{
if (!m_Textures[name])
{
LT_ENGINE_WARN("ResourceManager::ReleaseTextureImpl: failed to find texture named: {}", name);
return;
}
m_Textures[name] = nullptr;
}
}

479
Engine/src/Engine/Utility/Serializer.cpp
View file

@ -1,285 +1,282 @@
#include "Serializer.h" #include "Serializer.h"
#include "Scene/Components.h"
#include "Graphics/Texture.h" #include "Graphics/Texture.h"
#include "Scene/Components.h"
#include "Utility/ResourceManager.h" #include "Utility/ResourceManager.h"
namespace YAML { namespace YAML {
template<> template<>
struct convert<glm::vec3> struct convert<glm::vec3>
{
static Node encode(const glm::vec3& rhs)
{ {
static Node encode(const glm::vec3 & rhs) Node node;
{ node.push_back(rhs.x);
Node node; node.push_back(rhs.y);
node.push_back(rhs.x); node.push_back(rhs.z);
node.push_back(rhs.y); return node;
node.push_back(rhs.z); }
return node;
}
static bool decode(const Node& node, glm::vec3& rhs) static bool decode(const Node& node, glm::vec3& rhs)
{
if (!node.IsSequence() || node.size() != 3)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
rhs.z = node[2].as<float>();
return true;
}
};
template<>
struct convert<glm::vec4>
{ {
static Node encode(const glm::vec4& rhs) if (!node.IsSequence() || node.size() != 3)
{ return false;
Node node;
node.push_back(rhs.x);
node.push_back(rhs.y);
node.push_back(rhs.z);
node.push_back(rhs.w);
return node;
}
static bool decode(const Node& node, glm::vec4& rhs) rhs.x = node[0].as<float>();
{ rhs.y = node[1].as<float>();
if (!node.IsSequence() || node.size() != 4) rhs.z = node[2].as<float>();
return false; return true;
}
};
rhs.x = node[0].as<float>(); template<>
rhs.y = node[1].as<float>(); struct convert<glm::vec4>
rhs.z = node[2].as<float>(); {
rhs.w = node[3].as<float>(); static Node encode(const glm::vec4& rhs)
return true; {
} Node node;
}; node.push_back(rhs.x);
} node.push_back(rhs.y);
node.push_back(rhs.z);
node.push_back(rhs.w);
return node;
}
static bool decode(const Node& node, glm::vec4& rhs)
{
if (!node.IsSequence() || node.size() != 4)
return false;
rhs.x = node[0].as<float>();
rhs.y = node[1].as<float>();
rhs.z = node[2].as<float>();
rhs.w = node[3].as<float>();
return true;
}
};
} // namespace YAML
namespace Light { namespace Light {
static YAML::Emitter& operator << (YAML::Emitter& out, const glm::vec3& v) static YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec3& v)
{ {
out << YAML::Flow; out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq; out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
return out; return out;
} }
static YAML::Emitter& operator << (YAML::Emitter& out, const glm::vec4& v) static YAML::Emitter& operator<<(YAML::Emitter& out, const glm::vec4& v)
{ {
out << YAML::Flow; out << YAML::Flow;
out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq; out << YAML::BeginSeq << v.x << v.y << v.z << v.w << YAML::EndSeq;
return out; return out;
} }
SceneSerializer::SceneSerializer(const Ref<Scene>& scene): SceneSerializer::SceneSerializer(const Ref<Scene>& scene)
m_Scene(scene) : m_Scene(scene)
{ {
} }
void SceneSerializer::Serialize(const std::string& filePath) void SceneSerializer::Serialize(const std::string& filePath)
{ {
YAML::Emitter out; YAML::Emitter out;
out << YAML::BeginMap; // Scene out << YAML::BeginMap; // Scene
out << YAML::Key << "Scene" << YAML::Value << "Untitled"; out << YAML::Key << "Scene" << YAML::Value << "Untitled";
out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq; out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
m_Scene->m_Registry.each([&](auto entityID) m_Scene->m_Registry.each([&](auto entityID) {
Entity entity = { entityID, m_Scene.get() };
if (!entity.IsValid())
return;
SerializeEntity(out, entity);
});
out << YAML::EndSeq;
out << YAML::EndMap;
std::filesystem::create_directories(filePath.substr(0ull, filePath.find_last_of('\\')));
std::ofstream fout(filePath);
if (!fout.is_open())
LOG(trace, "Failed to create fout at: {}", filePath);
fout << out.c_str();
}
bool SceneSerializer::Deserialize(const std::string& filePath)
{
std::ifstream stream(filePath);
std::stringstream ss;
ss << stream.rdbuf();
YAML::Node data = YAML::Load(ss.str());
if (!data["Scene"])
return false;
std::string sceneName = data["Scene"].as<std::string>();
LOG(trace, "Deserializing scene: '{}'", sceneName);
auto entities = data["Entities"];
if (entities)
{
/* #TEMPORARY SOLUTION# */
std::unordered_set<std::string> texturePaths;
/* #TEMPORARY SOLUTION# */
for (auto entity : entities)
{ {
Entity entity = { entityID, m_Scene.get() }; uint64_t uuid = entity["Entity"].as<uint64_t>(); // #todo
if (!entity.IsValid())
return;
SerializeEntity(out, entity); std::string name;
}); auto tagComponent = entity["TagComponent"];
out << YAML::EndSeq; if (tagComponent)
out << YAML::EndMap; name = tagComponent["Tag"].as<std::string>();
std::filesystem::create_directories(filePath.substr(0ull, filePath.find_last_of('\\'))); LOG(trace, "Deserialized entity '{}' : '{}'", uuid, name);
std::ofstream fout(filePath); Entity deserializedEntity = m_Scene->CreateEntityWithUUID(name, uuid);
if (!fout.is_open())
LT_ENGINE_ERROR("SceneSerializer::Serialize: failed to create fout at: {}", filePath);
fout << out.c_str();
}
bool SceneSerializer::Deserialize(const std::string& filePath) TagComponent gg = deserializedEntity.GetComponent<TagComponent>();
{ LOG(trace, gg.tag);
std::ifstream stream(filePath); auto transformComponent = entity["TransformComponent"];
std::stringstream ss; if (transformComponent)
ss << stream.rdbuf();
YAML::Node data = YAML::Load(ss.str());
if (!data["Scene"])
return false;
std::string sceneName = data["Scene"].as<std::string>();
LT_ENGINE_TRACE("SceneSerializer::Deserialize: Deserializing scene: '{}'", sceneName);
auto entities = data["Entities"];
if (entities)
{
/* #TEMPORARY SOLUTION# */
std::unordered_set<std::string> texturePaths;
/* #TEMPORARY SOLUTION# */
for (auto entity : entities)
{ {
uint64_t uuid = entity["Entity"].as<uint64_t>(); // #todo auto& entityTransforomComponent = deserializedEntity.GetComponent<TransformComponent>();
std::string name; entityTransforomComponent.translation = transformComponent["Translation"].as<glm::vec3>();
auto tagComponent = entity["TagComponent"]; entityTransforomComponent.rotation = transformComponent["Rotation"].as<glm::vec3>();
if (tagComponent) entityTransforomComponent.scale = transformComponent["Scale"].as<glm::vec3>();
name = tagComponent["Tag"].as<std::string>();
LT_ENGINE_TRACE("SceneSerializer::Deserialize: Deserialized entity '{}' : '{}'", uuid, name);
Entity deserializedEntity = m_Scene->CreateEntityWithUUID(name, uuid);
TagComponent gg = deserializedEntity.GetComponent<TagComponent>();
LT_ENGINE_TRACE(gg.tag);
auto transformComponent = entity["TransformComponent"];
if (transformComponent)
{
auto& entityTransforomComponent = deserializedEntity.GetComponent<TransformComponent>();
entityTransforomComponent.translation = transformComponent["Translation"].as<glm::vec3>();
entityTransforomComponent.rotation = transformComponent["Rotation"].as<glm::vec3>();
entityTransforomComponent.scale = transformComponent["Scale"].as<glm::vec3>();
}
/* #TEMPORARY SOLUTION# */
auto spriteRendererComponent = entity["SpriteRendererComponent"];
if (spriteRendererComponent)
{
auto& entitySpriteRendererComponent = deserializedEntity.AddComponent<SpriteRendererComponent>();
entitySpriteRendererComponent.tint = spriteRendererComponent["Tint"].as<glm::vec4>();
std::string texturePath = spriteRendererComponent["Texture"].as<std::string>();
if (!texturePaths.contains(texturePath))
{
ResourceManager::LoadTexture(texturePath, texturePath);
texturePaths.insert(texturePath);
}
entitySpriteRendererComponent.texture = ResourceManager::GetTexture(texturePath);
}
/* #TEMPORARY SOLUTION# */
auto cameraComponent = entity["CameraComponent"];
if(cameraComponent)
{
auto& entityCameraComponent = deserializedEntity.AddComponent<CameraComponent>();
const auto& cameraSpecifications = cameraComponent["Camera"];
entityCameraComponent.camera.SetProjectionType((SceneCamera::ProjectionType)cameraSpecifications["ProjectionType"].as<int>());
entityCameraComponent.camera.SetOrthographicSize(cameraSpecifications["OrthographicSize"].as<float>());
entityCameraComponent.camera.SetOrthographicNearPlane(cameraSpecifications["OrthographicNearPlane"].as<float>());
entityCameraComponent.camera.SetOrthographicFarPlane(cameraSpecifications["OrthographicFarPlane"].as<float>());
entityCameraComponent.camera.SetPerspectiveVerticalFOV(cameraSpecifications["PerspectiveVerticalFOV"].as<float>());
entityCameraComponent.camera.SetPerspectiveNearPlane(cameraSpecifications["PerspectiveNearPlane"].as<float>());
entityCameraComponent.camera.SetPerspectiveFarPlane(cameraSpecifications["PerspectiveFarPlane"].as<float>());
entityCameraComponent.camera.SetBackgroundColor(cameraSpecifications["BackgroundColor"].as<glm::vec4>());
entityCameraComponent.isPrimary = cameraComponent["IsPrimary"].as<bool>();
}
} }
return true; /* #TEMPORARY SOLUTION# */
auto spriteRendererComponent = entity["SpriteRendererComponent"];
if (spriteRendererComponent)
{
auto& entitySpriteRendererComponent = deserializedEntity.AddComponent<SpriteRendererComponent>();
entitySpriteRendererComponent.tint = spriteRendererComponent["Tint"].as<glm::vec4>();
std::string texturePath = spriteRendererComponent["Texture"].as<std::string>();
if (!texturePaths.contains(texturePath))
{
ResourceManager::LoadTexture(texturePath, texturePath);
texturePaths.insert(texturePath);
}
entitySpriteRendererComponent.texture = ResourceManager::GetTexture(texturePath);
}
/* #TEMPORARY SOLUTION# */
auto cameraComponent = entity["CameraComponent"];
if (cameraComponent)
{
auto& entityCameraComponent = deserializedEntity.AddComponent<CameraComponent>();
const auto& cameraSpecifications = cameraComponent["Camera"];
entityCameraComponent.camera.SetProjectionType((SceneCamera::ProjectionType)cameraSpecifications["ProjectionType"].as<int>());
entityCameraComponent.camera.SetOrthographicSize(cameraSpecifications["OrthographicSize"].as<float>());
entityCameraComponent.camera.SetOrthographicNearPlane(cameraSpecifications["OrthographicNearPlane"].as<float>());
entityCameraComponent.camera.SetOrthographicFarPlane(cameraSpecifications["OrthographicFarPlane"].as<float>());
entityCameraComponent.camera.SetPerspectiveVerticalFOV(cameraSpecifications["PerspectiveVerticalFOV"].as<float>());
entityCameraComponent.camera.SetPerspectiveNearPlane(cameraSpecifications["PerspectiveNearPlane"].as<float>());
entityCameraComponent.camera.SetPerspectiveFarPlane(cameraSpecifications["PerspectiveFarPlane"].as<float>());
entityCameraComponent.camera.SetBackgroundColor(cameraSpecifications["BackgroundColor"].as<glm::vec4>());
entityCameraComponent.isPrimary = cameraComponent["IsPrimary"].as<bool>();
}
} }
return false; return true;
} }
void SceneSerializer::SerializeBinary(const std::string& filePath) return false;
}
void SceneSerializer::SerializeBinary(const std::string& filePath)
{
LOG(err, "NO_IMPLEMENT");
}
bool SceneSerializer::DeserializeBinary(const std::string& filePath)
{
LOG(err, "NO_IMPLEMENT");
return false;
}
void SceneSerializer::SerializeEntity(YAML::Emitter& out, Entity entity)
{
out << YAML::BeginMap; // entity
out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID(); // dummy uuid
if (entity.HasComponent<TagComponent>())
{ {
LT_ENGINE_ERROR("SceneSerializer::SerializeRuntime: NO_IMPLEMENT"); out << YAML::Key << "TagComponent";
out << YAML::BeginMap; // tag component
auto& tagComponent = entity.GetComponent<TagComponent>().tag;
out << YAML::Key << "Tag" << YAML::Value << tagComponent;
out << YAML::EndMap; // tag component
} }
bool SceneSerializer::DeserializeBinary(const std::string& filePath) if (entity.HasComponent<TransformComponent>())
{ {
LT_ENGINE_ERROR("SceneSerializer::DeserializeBinary: NO_IMPLEMENT"); out << YAML::Key << "TransformComponent";
return false; out << YAML::BeginMap; // transform component
auto& transformComponent = entity.GetComponent<TransformComponent>();
out << YAML::Key << "Translation" << YAML::Value << transformComponent.translation;
out << YAML::Key << "Rotation" << YAML::Value << transformComponent.rotation;
out << YAML::Key << "Scale" << YAML::Value << transformComponent.scale;
out << YAML::EndMap; // transform component;
} }
void SceneSerializer::SerializeEntity(YAML::Emitter& out, Entity entity) if (entity.HasComponent<SpriteRendererComponent>())
{ {
out << YAML::BeginMap; // entity out << YAML::Key << "SpriteRendererComponent";
out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID(); // dummy uuid out << YAML::BeginMap; // sprite renderer component;
if (entity.HasComponent<TagComponent>()) auto& spriteRendererComponent = entity.GetComponent<SpriteRendererComponent>();
{
out << YAML::Key << "TagComponent";
out << YAML::BeginMap; // tag component
auto& tagComponent = entity.GetComponent<TagComponent>().tag; out << YAML::Key << "Texture" << YAML::Value << spriteRendererComponent.texture->GetFilePath();
out << YAML::Key << "Tag" << YAML::Value << tagComponent; out << YAML::Key << "Tint" << YAML::Value << spriteRendererComponent.tint;
out << YAML::EndMap; // tag component out << YAML::EndMap; // sprite renderer component
}
if (entity.HasComponent<TransformComponent>())
{
out << YAML::Key << "TransformComponent";
out << YAML::BeginMap; // transform component
auto& transformComponent = entity.GetComponent<TransformComponent>();
out << YAML::Key << "Translation" << YAML::Value << transformComponent.translation;
out << YAML::Key << "Rotation" << YAML::Value << transformComponent.rotation;
out << YAML::Key << "Scale" << YAML::Value << transformComponent.scale;
out << YAML::EndMap; // transform component;
}
if (entity.HasComponent<SpriteRendererComponent>())
{
out << YAML::Key << "SpriteRendererComponent";
out << YAML::BeginMap; // sprite renderer component;
auto& spriteRendererComponent = entity.GetComponent<SpriteRendererComponent>();
out << YAML::Key << "Texture" << YAML::Value << spriteRendererComponent.texture->GetFilePath();
out << YAML::Key << "Tint" << YAML::Value << spriteRendererComponent.tint;
out << YAML::EndMap; // sprite renderer component
}
// #todo:
// if(entity.HasComponent<NativeScriptComponent>())
if (entity.HasComponent<CameraComponent>())
{
out << YAML::Key << "CameraComponent";
out << YAML::BeginMap; // camera component
auto& cameraComponent = entity.GetComponent<CameraComponent>();
out << YAML::Key << "Camera" << YAML::Value;
out << YAML::BeginMap; // camera
out << YAML::Key << "OrthographicSize" << YAML::Value << cameraComponent.camera.GetOrthographicSize();
out << YAML::Key << "OrthographicFarPlane" << YAML::Value << cameraComponent.camera.GetOrthographicFarPlane();
out << YAML::Key << "OrthographicNearPlane" << YAML::Value << cameraComponent.camera.GetOrthographicNearPlane();
out << YAML::Key << "PerspectiveVerticalFOV" << YAML::Value << cameraComponent.camera.GetPerspectiveVerticalFOV();
out << YAML::Key << "PerspectiveFarPlane" << YAML::Value << cameraComponent.camera.GetPerspectiveFarPlane();
out << YAML::Key << "PerspectiveNearPlane" << YAML::Value << cameraComponent.camera.GetPerspectiveNearPlane();
out << YAML::Key << "ProjectionType" << YAML::Value << (int)cameraComponent.camera.GetProjectionType();
out << YAML::Key << "BackgroundColor" << YAML::Value << cameraComponent.camera.GetBackgroundColor();
out << YAML::EndMap; // camera
out << YAML::Key << "IsPrimary" << YAML::Value << cameraComponent.isPrimary;
out << YAML::EndMap; // camera component
}
out << YAML::EndMap; // entity
} }
} // #todo:
// if(entity.HasComponent<NativeScriptComponent>())
if (entity.HasComponent<CameraComponent>())
{
out << YAML::Key << "CameraComponent";
out << YAML::BeginMap; // camera component
auto& cameraComponent = entity.GetComponent<CameraComponent>();
out << YAML::Key << "Camera" << YAML::Value;
out << YAML::BeginMap; // camera
out << YAML::Key << "OrthographicSize" << YAML::Value << cameraComponent.camera.GetOrthographicSize();
out << YAML::Key << "OrthographicFarPlane" << YAML::Value << cameraComponent.camera.GetOrthographicFarPlane();
out << YAML::Key << "OrthographicNearPlane" << YAML::Value << cameraComponent.camera.GetOrthographicNearPlane();
out << YAML::Key << "PerspectiveVerticalFOV" << YAML::Value << cameraComponent.camera.GetPerspectiveVerticalFOV();
out << YAML::Key << "PerspectiveFarPlane" << YAML::Value << cameraComponent.camera.GetPerspectiveFarPlane();
out << YAML::Key << "PerspectiveNearPlane" << YAML::Value << cameraComponent.camera.GetPerspectiveNearPlane();
out << YAML::Key << "ProjectionType" << YAML::Value << (int)cameraComponent.camera.GetProjectionType();
out << YAML::Key << "BackgroundColor" << YAML::Value << cameraComponent.camera.GetBackgroundColor();
out << YAML::EndMap; // camera
out << YAML::Key << "IsPrimary" << YAML::Value << cameraComponent.isPrimary;
out << YAML::EndMap; // camera component
}
out << YAML::EndMap; // entity
}
} // namespace Light

300
Engine/src/Platform/GraphicsAPI/DirectX/dxBuffers.cpp
View file

@ -1,170 +1,164 @@
#include "dxBuffers.h" #include "dxBuffers.h"
#include "dxSharedContext.h" #include "dxSharedContext.h"
namespace Light { namespace Light {
//======================================== CONSTANT_BUFFER ========================================// //======================================== CONSTANT_BUFFER ========================================//
dxConstantBuffer::dxConstantBuffer(ConstantBufferIndex index, unsigned int size, Ref<dxSharedContext> sharedContext) dxConstantBuffer::dxConstantBuffer(ConstantBufferIndex index, unsigned int size, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext), : m_Context(sharedContext), m_Buffer(nullptr), m_Map {}, m_Index(static_cast<int>(index))
m_Buffer(nullptr), {
m_Map{}, D3D11_BUFFER_DESC bDesc = {};
m_Index(static_cast<int>(index))
bDesc.ByteWidth = size;
bDesc.Usage = D3D11_USAGE_DYNAMIC;
bDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
HRESULT hr;
DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, nullptr, &m_Buffer));
m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
}
void dxConstantBuffer::Bind()
{
m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
}
void* dxConstantBuffer::Map()
{
m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
m_Context->GetDeviceContext()->Map(m_Buffer.Get(), NULL, D3D11_MAP_WRITE_DISCARD, NULL, &m_Map);
return m_Map.pData;
}
void dxConstantBuffer::UnMap()
{
m_Context->GetDeviceContext()->Unmap(m_Buffer.Get(), NULL);
}
//======================================== CONSTANT_BUFFER ========================================//
//================================================== VERTEX_BUFFER ==================================================//
dxVertexBuffer::dxVertexBuffer(float* vertices, unsigned int stride, unsigned int count, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext), m_Buffer(nullptr), m_Map {}, m_Stride(stride)
{
// buffer desc
D3D11_BUFFER_DESC bDesc = {};
bDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bDesc.Usage = D3D11_USAGE_DYNAMIC;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bDesc.ByteWidth = count * stride;
bDesc.StructureByteStride = stride;
// create buffer
HRESULT hr;
DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, nullptr, &m_Buffer));
}
dxVertexBuffer::~dxVertexBuffer()
{
UnBind();
}
void* dxVertexBuffer::Map()
{
m_Context->GetDeviceContext()->Map(m_Buffer.Get(), NULL, D3D11_MAP_WRITE_DISCARD, NULL, &m_Map);
return m_Map.pData;
}
void dxVertexBuffer::UnMap()
{
m_Context->GetDeviceContext()->Unmap(m_Buffer.Get(), NULL);
}
void dxVertexBuffer::Bind()
{
static const unsigned int offset = 0u;
m_Context->GetDeviceContext()->IASetVertexBuffers(0u, 1u, m_Buffer.GetAddressOf(), &m_Stride, &offset);
}
void dxVertexBuffer::UnBind()
{
static const unsigned int offset = 0u;
static ID3D11Buffer* buffer = nullptr;
m_Context->GetDeviceContext()->IASetVertexBuffers(0u, 1u, &buffer, &m_Stride, &offset);
}
//================================================== VERTEX_BUFFER ==================================================//
//======================================== INDEX_BUFFER ========================================//
dxIndexBuffer::dxIndexBuffer(unsigned int* indices, unsigned int count, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext), m_Buffer(nullptr)
{
// generate indices if not provided
bool hasIndices = !!indices;
if (!hasIndices)
{ {
D3D11_BUFFER_DESC bDesc = {}; // check
if (count % 6 != 0)
bDesc.ByteWidth = size;
bDesc.Usage = D3D11_USAGE_DYNAMIC;
bDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
HRESULT hr;
DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, nullptr, &m_Buffer));
m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
}
void dxConstantBuffer::Bind()
{
m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
}
void* dxConstantBuffer::Map()
{
m_Context->GetDeviceContext()->VSSetConstantBuffers(m_Index, 1u, m_Buffer.GetAddressOf());
m_Context->GetDeviceContext()->Map(m_Buffer.Get(), NULL, D3D11_MAP_WRITE_DISCARD, NULL, &m_Map);
return m_Map.pData;
}
void dxConstantBuffer::UnMap()
{
m_Context->GetDeviceContext()->Unmap(m_Buffer.Get(), NULL);
}
//======================================== CONSTANT_BUFFER ========================================//
//================================================== VERTEX_BUFFER ==================================================//
dxVertexBuffer::dxVertexBuffer(float* vertices, unsigned int stride, unsigned int count, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext),
m_Buffer(nullptr),
m_Map{},
m_Stride(stride)
{
// buffer desc
D3D11_BUFFER_DESC bDesc = {};
bDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bDesc.Usage = D3D11_USAGE_DYNAMIC;
bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bDesc.ByteWidth = count * stride;
bDesc.StructureByteStride = stride;
// create buffer
HRESULT hr;
DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, nullptr, &m_Buffer));
}
dxVertexBuffer::~dxVertexBuffer()
{
UnBind();
}
void* dxVertexBuffer::Map()
{
m_Context->GetDeviceContext()->Map(m_Buffer.Get(), NULL, D3D11_MAP_WRITE_DISCARD, NULL, &m_Map);
return m_Map.pData;
}
void dxVertexBuffer::UnMap()
{
m_Context->GetDeviceContext()->Unmap(m_Buffer.Get(), NULL);
}
void dxVertexBuffer::Bind()
{
static const unsigned int offset = 0u;
m_Context->GetDeviceContext()->IASetVertexBuffers(0u, 1u, m_Buffer.GetAddressOf(), &m_Stride, &offset);
}
void dxVertexBuffer::UnBind()
{
static const unsigned int offset = 0u;
static ID3D11Buffer* buffer = nullptr;
m_Context->GetDeviceContext()->IASetVertexBuffers(0u, 1u, &buffer, &m_Stride, &offset);
}
//================================================== VERTEX_BUFFER ==================================================//
//======================================== INDEX_BUFFER ========================================//
dxIndexBuffer::dxIndexBuffer(unsigned int* indices, unsigned int count, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext),
m_Buffer(nullptr)
{
// generate indices if not provided
bool hasIndices = !!indices;
if (!hasIndices)
{ {
// check LOG(warn, "'indices' can only be null if count is multiple of 6");
if (count % 6 != 0) LOG(warn, "Adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
{ count = count + (6 - (count % 6));
LT_ENGINE_WARN("dxIndexBuffer::dxIndexBuffer: 'indices' can only be null if count is multiple of 6");
LT_ENGINE_WARN("dxIndexBuffer::dxIndexBuffer: adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
count = count + (6 - (count % 6));
}
// create indices
indices = new unsigned int[count];
unsigned int offset = 0;
for (unsigned int i = 0; i < count; i += 6)
{
indices[i + 0] = offset + 0u;
indices[i + 1] = offset + 3u;
indices[i + 2] = offset + 2u;
indices[i + 3] = offset + 2u;
indices[i + 4] = offset + 1u;
indices[i + 5] = offset + 0u;
offset += 4u;
}
} }
// buffer desc // create indices
D3D11_BUFFER_DESC bDesc = {}; indices = new unsigned int[count];
bDesc.BindFlags = D3D11_BIND_INDEX_BUFFER; unsigned int offset = 0;
bDesc.Usage = D3D11_USAGE_DEFAULT; for (unsigned int i = 0; i < count; i += 6)
{
indices[i + 0] = offset + 0u;
indices[i + 1] = offset + 3u;
indices[i + 2] = offset + 2u;
bDesc.ByteWidth = count * sizeof(unsigned int); indices[i + 3] = offset + 2u;
bDesc.StructureByteStride = sizeof(unsigned int); indices[i + 4] = offset + 1u;
indices[i + 5] = offset + 0u;
// subresource data offset += 4u;
D3D11_SUBRESOURCE_DATA sDesc = {}; }
sDesc.pSysMem = indices;
// create buffer
HRESULT hr;
DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, &sDesc, &m_Buffer));
// delete indices
if (!hasIndices)
delete[] indices;
} }
dxIndexBuffer::~dxIndexBuffer() // buffer desc
{ D3D11_BUFFER_DESC bDesc = {};
UnBind(); bDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
} bDesc.Usage = D3D11_USAGE_DEFAULT;
void dxIndexBuffer::Bind() bDesc.ByteWidth = count * sizeof(unsigned int);
{ bDesc.StructureByteStride = sizeof(unsigned int);
m_Context->GetDeviceContext()->IASetIndexBuffer(m_Buffer.Get(), DXGI_FORMAT_R32_UINT, 0u);
}
void dxIndexBuffer::UnBind() // subresource data
{ D3D11_SUBRESOURCE_DATA sDesc = {};
static const unsigned int offset = 0u; sDesc.pSysMem = indices;
static ID3D11Buffer* buffer = nullptr;
m_Context->GetDeviceContext()->IASetIndexBuffer(buffer, DXGI_FORMAT_R32_UINT, offset); // create buffer
} HRESULT hr;
//======================================== INDEX_BUFFER ========================================// DXC(m_Context->GetDevice()->CreateBuffer(&bDesc, &sDesc, &m_Buffer));
} // delete indices
if (!hasIndices)
delete[] indices;
}
dxIndexBuffer::~dxIndexBuffer()
{
UnBind();
}
void dxIndexBuffer::Bind()
{
m_Context->GetDeviceContext()->IASetIndexBuffer(m_Buffer.Get(), DXGI_FORMAT_R32_UINT, 0u);
}
void dxIndexBuffer::UnBind()
{
static const unsigned int offset = 0u;
static ID3D11Buffer* buffer = nullptr;
m_Context->GetDeviceContext()->IASetIndexBuffer(buffer, DXGI_FORMAT_R32_UINT, offset);
}
//======================================== INDEX_BUFFER ========================================//
} // namespace Light

149
Engine/src/Platform/GraphicsAPI/DirectX/dxFramebuffer.cpp
View file

@ -1,99 +1,94 @@
#include "dxFramebuffer.h" #include "dxFramebuffer.h"
#include "dxSharedContext.h" #include "dxSharedContext.h"
namespace Light { namespace Light {
dxFramebuffer::dxFramebuffer(const FramebufferSpecification& specification, Ref<dxSharedContext> sharedContext) dxFramebuffer::dxFramebuffer(const FramebufferSpecification& specification, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext), : m_Context(sharedContext), m_Specification(specification), m_RenderTargetView(nullptr), m_ColorAttachment(nullptr), m_DepthStencilAttachment(nullptr), m_ShaderResourceView(nullptr), m_DepthStencilView(nullptr)
m_Specification(specification), {
m_RenderTargetView(nullptr), HRESULT hr;
m_ColorAttachment(nullptr),
m_DepthStencilAttachment(nullptr),
m_ShaderResourceView(nullptr),
m_DepthStencilView(nullptr)
{
HRESULT hr;
D3D11_TEXTURE2D_DESC t2dDesc = {}; D3D11_TEXTURE2D_DESC t2dDesc = {};
t2dDesc.Width = specification.width; t2dDesc.Width = specification.width;
t2dDesc.Height = specification.height; t2dDesc.Height = specification.height;
t2dDesc.MipLevels = 1; t2dDesc.MipLevels = 1;
t2dDesc.ArraySize = 1; t2dDesc.ArraySize = 1;
t2dDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; t2dDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
t2dDesc.SampleDesc.Count = 1u; t2dDesc.SampleDesc.Count = 1u;
t2dDesc.SampleDesc.Quality = 0u; t2dDesc.SampleDesc.Quality = 0u;
t2dDesc.Usage = D3D11_USAGE_DEFAULT; t2dDesc.Usage = D3D11_USAGE_DEFAULT;
t2dDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE; t2dDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
t2dDesc.CPUAccessFlags = NULL; t2dDesc.CPUAccessFlags = NULL;
t2dDesc.MiscFlags = NULL; t2dDesc.MiscFlags = NULL;
DXC(m_Context->GetDevice()->CreateTexture2D(&t2dDesc, nullptr, &m_ColorAttachment)); DXC(m_Context->GetDevice()->CreateTexture2D(&t2dDesc, nullptr, &m_ColorAttachment));
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.Format = t2dDesc.Format; srvDesc.Format = t2dDesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = 1; srvDesc.Texture2D.MipLevels = 1;
srvDesc.Texture2D.MostDetailedMip = 0; srvDesc.Texture2D.MostDetailedMip = 0;
DXC(m_Context->GetDevice()->CreateShaderResourceView(m_ColorAttachment.Get(), &srvDesc, &m_ShaderResourceView)); DXC(m_Context->GetDevice()->CreateShaderResourceView(m_ColorAttachment.Get(), &srvDesc, &m_ShaderResourceView));
D3D11_RENDER_TARGET_VIEW_DESC rtvDesc = {}; D3D11_RENDER_TARGET_VIEW_DESC rtvDesc = {};
rtvDesc.Format = t2dDesc.Format; rtvDesc.Format = t2dDesc.Format;
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtvDesc.Texture2D.MipSlice = 0u; rtvDesc.Texture2D.MipSlice = 0u;
DXC(m_Context->GetDevice()->CreateRenderTargetView(m_ColorAttachment.Get(), &rtvDesc, &m_RenderTargetView)); DXC(m_Context->GetDevice()->CreateRenderTargetView(m_ColorAttachment.Get(), &rtvDesc, &m_RenderTargetView));
} }
void dxFramebuffer::BindAsTarget(const glm::vec4& clearColor) void dxFramebuffer::BindAsTarget(const glm::vec4& clearColor)
{ {
FLOAT color[] = { FLOAT color[] = {
clearColor.r, clearColor.r,
clearColor.g, clearColor.g,
clearColor.b, clearColor.b,
clearColor.a, clearColor.a,
}; };
m_Context->GetDeviceContext()->OMSetRenderTargets(1u, m_RenderTargetView.GetAddressOf(), nullptr); m_Context->GetDeviceContext()->OMSetRenderTargets(1u, m_RenderTargetView.GetAddressOf(), nullptr);
m_Context->GetDeviceContext()->ClearRenderTargetView(m_RenderTargetView.Get(), color); m_Context->GetDeviceContext()->ClearRenderTargetView(m_RenderTargetView.Get(), color);
D3D11_VIEWPORT viewport; D3D11_VIEWPORT viewport;
viewport.TopLeftX = 0; viewport.TopLeftX = 0;
viewport.TopLeftY = 0; viewport.TopLeftY = 0;
viewport.Width = m_Specification.width; viewport.Width = m_Specification.width;
viewport.Height = m_Specification.height; viewport.Height = m_Specification.height;
viewport.MinDepth = 0.0f; viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f; viewport.MaxDepth = 1.0f;
// set viewport // set viewport
m_Context->GetDeviceContext()->RSSetViewports(1u, &viewport); m_Context->GetDeviceContext()->RSSetViewports(1u, &viewport);
} }
void dxFramebuffer::BindAsResource() void dxFramebuffer::BindAsResource()
{ {
LT_ENGINE_ERROR("dxFramebuffer::BindAsResource: NO_IMPLEMENT"); LOG(err, "NO_IMPLEMENT");
} }
void dxFramebuffer::Resize(const glm::uvec2& size) void dxFramebuffer::Resize(const glm::uvec2& size)
{ {
m_Specification.width = std::clamp(size.x, 1u, 16384u); m_Specification.width = std::clamp(size.x, 1u, 16384u);
m_Specification.height= std::clamp(size.y, 1u, 16384u); m_Specification.height = std::clamp(size.y, 1u, 16384u);
D3D11_TEXTURE2D_DESC textureDesc; D3D11_TEXTURE2D_DESC textureDesc;
D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
m_ColorAttachment->GetDesc(&textureDesc); m_ColorAttachment->GetDesc(&textureDesc);
m_RenderTargetView->GetDesc(&rtvDesc); m_RenderTargetView->GetDesc(&rtvDesc);
m_ShaderResourceView->GetDesc(&srvDesc); m_ShaderResourceView->GetDesc(&srvDesc);
textureDesc.Width = m_Specification.width; textureDesc.Width = m_Specification.width;
textureDesc.Height = m_Specification.height; textureDesc.Height = m_Specification.height;
HRESULT hr; HRESULT hr;
DXC(m_Context->GetDevice()->CreateTexture2D(&textureDesc, nullptr, &m_ColorAttachment)); DXC(m_Context->GetDevice()->CreateTexture2D(&textureDesc, nullptr, &m_ColorAttachment));
DXC(m_Context->GetDevice()->CreateRenderTargetView(m_ColorAttachment.Get(), &rtvDesc, &m_RenderTargetView)); DXC(m_Context->GetDevice()->CreateRenderTargetView(m_ColorAttachment.Get(), &rtvDesc, &m_RenderTargetView));
DXC(m_Context->GetDevice()->CreateShaderResourceView(m_ColorAttachment.Get(), &srvDesc, &m_ShaderResourceView)); DXC(m_Context->GetDevice()->CreateShaderResourceView(m_ColorAttachment.Get(), &srvDesc, &m_ShaderResourceView));
} }
} } // namespace Light

238
Engine/src/Platform/GraphicsAPI/DirectX/dxGraphicsContext.cpp
View file

@ -1,16 +1,13 @@
#include "dxGraphicsContext.h" #include "dxGraphicsContext.h"
#include "dxSharedContext.h"
#include "Events/WindowEvents.h" #include "Events/WindowEvents.h"
#include "Graphics/Blender.h" // required for forward declaration
#include "Graphics/Blender.h" // required for forward declaration #include "Graphics/Buffers.h" // required for forward declaration
#include "Graphics/Buffers.h" // required for forward declaration #include "Graphics/RenderCommand.h" // required for forward declaration
#include "Graphics/Renderer.h" // required for forward declaration #include "Graphics/Renderer.h" // required for forward declaration
#include "Graphics/RenderCommand.h" // required for forward declaration
#include "UserInterface/UserInterface.h" // required for forward declaration #include "UserInterface/UserInterface.h" // required for forward declaration
#include "Utility/ResourceManager.h" // required for forward declaration
#include "Utility/ResourceManager.h" // required for forward declaration #include "dxSharedContext.h"
#define GLFW_EXPOSE_NATIVE_WIN32 #define GLFW_EXPOSE_NATIVE_WIN32
#include <glfw/glfw3.h> #include <glfw/glfw3.h>
@ -18,149 +15,146 @@
namespace Light { namespace Light {
dxGraphicsContext::dxGraphicsContext(GLFWwindow* windowHandle) dxGraphicsContext::dxGraphicsContext(GLFWwindow* windowHandle)
: m_WindowHandle(windowHandle), : m_WindowHandle(windowHandle), m_DebugInterface(nullptr)
m_DebugInterface(nullptr) {
{ // set 'GraphicsAPI';
// set 'GraphicsAPI'; m_GraphicsAPI = GraphicsAPI::DirectX;
m_GraphicsAPI = GraphicsAPI::DirectX;
m_SharedContext = std::make_shared<dxSharedContext>();
// setup stuff m_SharedContext = std::make_shared<dxSharedContext>();
SetupDeviceAndSwapChain(windowHandle);
SetupRenderTargets();
SetupDebugInterface();
}
void dxGraphicsContext::SetupDeviceAndSwapChain(GLFWwindow* windowHandle) // setup stuff
{ SetupDeviceAndSwapChain(windowHandle);
Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext); SetupRenderTargets();
SetupDebugInterface();
}
// swap chain desc void dxGraphicsContext::SetupDeviceAndSwapChain(GLFWwindow* windowHandle)
DXGI_SWAP_CHAIN_DESC sd = { 0 }; {
Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
// buffer desc // swap chain desc
sd.BufferDesc.Width = 1u; DXGI_SWAP_CHAIN_DESC sd = { 0 };
sd.BufferDesc.Height = 1u;
sd.BufferDesc.RefreshRate.Numerator = NULL; // :#todo
sd.BufferDesc.RefreshRate.Denominator = NULL; // :#todo
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// sample desc (for multi sampling) #todo: implement multi-samplingz // buffer desc
sd.SampleDesc.Count = 1u; sd.BufferDesc.Width = 1u;
sd.SampleDesc.Quality = 0u; sd.BufferDesc.Height = 1u;
sd.BufferDesc.RefreshRate.Numerator = NULL; // :#todo
sd.BufferDesc.RefreshRate.Denominator = NULL; // :#todo
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
// #todo: support swap chains with more than 1 back-buffer // sample desc (for multi sampling) #todo: implement multi-samplingz
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.SampleDesc.Count = 1u;
sd.BufferCount = 1u; sd.SampleDesc.Quality = 0u;
// #todo: don't handle Windows's window with glfw, create it yourself // #todo: support swap chains with more than 1 back-buffer
sd.OutputWindow = static_cast<HWND>(glfwGetWin32Window(windowHandle)); sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.Windowed = true; sd.BufferCount = 1u;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; // #todo: don't handle Windows's window with glfw, create it yourself
sd.OutputWindow = static_cast<HWND>(glfwGetWin32Window(windowHandle));
sd.Windowed = true;
sd.Flags = NULL; sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
// determine device flags sd.Flags = NULL;
UINT flags = NULL;
// determine device flags
UINT flags = NULL;
#ifdef LIGHT_DEBUG #ifdef LIGHT_DEBUG
flags = D3D11_CREATE_DEVICE_DEBUG; flags = D3D11_CREATE_DEVICE_DEBUG;
#endif #endif
// create device and swap chain // create device and swap chain
DXC(D3D11CreateDeviceAndSwapChain(nullptr, DXC(D3D11CreateDeviceAndSwapChain(nullptr,
D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_HARDWARE,
NULL, NULL,
flags, flags,
nullptr, nullptr,
NULL, NULL,
D3D11_SDK_VERSION, D3D11_SDK_VERSION,
&sd, &sd,
&context->GetSwapChainRef(), &context->GetSwapChainRef(),
&context->GetDeviceRef(), &context->GetDeviceRef(),
nullptr, nullptr,
&context->GetDeviceContextRef())); &context->GetDeviceContextRef()));
}
} void dxGraphicsContext::SetupRenderTargets()
{
Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
void dxGraphicsContext::SetupRenderTargets() // set primitive topology
{ context->GetDeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
// set primitive topology // create render target view
context->GetDeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); Microsoft::WRL::ComPtr<ID3D11Resource> backBuffer;
// create render target view DXC(context->GetSwapChain()->GetBuffer(0u, __uuidof(ID3D11Resource), &backBuffer));
Microsoft::WRL::ComPtr<ID3D11Resource> backBuffer; DXC(context->GetDevice()->CreateRenderTargetView(backBuffer.Get(), nullptr, &context->GetRenderTargetViewRef()));
DXC(context->GetSwapChain()->GetBuffer(0u, __uuidof(ID3D11Resource), &backBuffer)); // set render target view
DXC(context->GetDevice()->CreateRenderTargetView(backBuffer.Get(), nullptr, &context->GetRenderTargetViewRef())); context->GetDeviceContext()->OMSetRenderTargets(1u, context->GetRenderTargetView().GetAddressOf(), nullptr);
}
// set render target view void dxGraphicsContext::SetupDebugInterface()
context->GetDeviceContext()->OMSetRenderTargets(1u, context->GetRenderTargetView().GetAddressOf(), nullptr); {
}
void dxGraphicsContext::SetupDebugInterface()
{
#ifdef LIGHT_DEBUG #ifdef LIGHT_DEBUG
Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext); Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
HRESULT hr; HRESULT hr;
Microsoft::WRL::ComPtr<ID3D11Debug> debugInterface = nullptr; Microsoft::WRL::ComPtr<ID3D11Debug> debugInterface = nullptr;
DXC(context->GetDevice()->QueryInterface(__uuidof(ID3D11Debug), &debugInterface)); DXC(context->GetDevice()->QueryInterface(__uuidof(ID3D11Debug), &debugInterface));
Microsoft::WRL::ComPtr<ID3D11InfoQueue> infoQueue = nullptr; Microsoft::WRL::ComPtr<ID3D11InfoQueue> infoQueue = nullptr;
DXC(debugInterface->QueryInterface(__uuidof(ID3D11InfoQueue), &infoQueue)); DXC(debugInterface->QueryInterface(__uuidof(ID3D11InfoQueue), &infoQueue));
infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true); infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true); infoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
D3D11_MESSAGE_ID hide[] = D3D11_MESSAGE_ID hide[] = {
{ D3D11_MESSAGE_ID_UNKNOWN,
D3D11_MESSAGE_ID_UNKNOWN, // #todo: add more messages here as needed
// #todo: add more messages here as needed };
};
D3D11_INFO_QUEUE_FILTER filter = { }; D3D11_INFO_QUEUE_FILTER filter = {};
filter.DenyList.NumIDs = _countof(hide); filter.DenyList.NumIDs = _countof(hide);
filter.DenyList.pIDList = hide; filter.DenyList.pIDList = hide;
infoQueue->AddStorageFilterEntries(&filter); infoQueue->AddStorageFilterEntries(&filter);
infoQueue->Release(); infoQueue->Release();
#endif #endif
} }
void dxGraphicsContext::LogDebugData() void dxGraphicsContext::LogDebugData()
{ {
Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext); Ref<dxSharedContext> context = std::static_pointer_cast<dxSharedContext>(m_SharedContext);
// locals // locals
IDXGIDevice* DXGIDevice; IDXGIDevice* DXGIDevice;
IDXGIAdapter* DXGIAdapter; IDXGIAdapter* DXGIAdapter;
DXGI_ADAPTER_DESC DXGIAdapterDesc; DXGI_ADAPTER_DESC DXGIAdapterDesc;
context->GetDevice()->QueryInterface(__uuidof(IDXGIDevice), (void**)&DXGIDevice); context->GetDevice()->QueryInterface(__uuidof(IDXGIDevice), (void**)&DXGIDevice);
DXGIDevice->GetAdapter(&DXGIAdapter); DXGIDevice->GetAdapter(&DXGIAdapter);
DXGIAdapter->GetDesc(&DXGIAdapterDesc); DXGIAdapter->GetDesc(&DXGIAdapterDesc);
// get the adapter's description // get the adapter's description
char DefChar = ' '; char DefChar = ' ';
char ch[180]; char ch[180];
WideCharToMultiByte(CP_ACP, 0, DXGIAdapterDesc.Description, -1, ch, 180, &DefChar, NULL); WideCharToMultiByte(CP_ACP, 0, DXGIAdapterDesc.Description, -1, ch, 180, &DefChar, NULL);
std::string adapterDesc(ch); std::string adapterDesc(ch);
// release memory // release memory
DXGIDevice->Release(); DXGIDevice->Release();
DXGIAdapter->Release(); DXGIAdapter->Release();
// #todo: log more information // #todo: log more information
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
LT_ENGINE_INFO("dxGraphicsContext:"); LOG(info, "dxGraphicsContext:");
LT_ENGINE_INFO(" Renderer: {}", adapterDesc); LOG(info, " Renderer: {}", adapterDesc);
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
} }
} } // namespace Light

129
Engine/src/Platform/GraphicsAPI/DirectX/dxRenderCommand.cpp
View file

@ -1,91 +1,92 @@
#include "dxRenderCommand.h" #include "dxRenderCommand.h"
#include "dxSharedContext.h" #include "dxSharedContext.h"
namespace Light { namespace Light {
dxRenderCommand::dxRenderCommand(Ref<dxSharedContext> sharedContext) dxRenderCommand::dxRenderCommand(Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext) : m_Context(sharedContext)
{ {
} }
void dxRenderCommand::SwapBuffers() void dxRenderCommand::SwapBuffers()
{ {
#ifdef LIGHT_DEBUG #ifdef LIGHT_DEBUG
HRESULT hr; HRESULT hr;
if (FAILED(hr = m_Context->GetSwapChain()->Present(1u, 0u))) if (FAILED(hr = m_Context->GetSwapChain()->Present(1u, 0u)))
{
if (hr == DXGI_ERROR_DEVICE_REMOVED)
{ {
if (hr == DXGI_ERROR_DEVICE_REMOVED) LOG(critical, "dxRenderCommand::SwapBuffers: DeviceRemoved:");
{ LOG(critical, " {}", m_Context->GetDevice()->GetDeviceRemovedReason());
LT_ENGINE_CRITICAL("dxRenderCommand::SwapBuffers: DeviceRemoved:"); throw dxException(hr, __FILE__, __LINE__);
LT_ENGINE_CRITICAL(" {}", m_Context->GetDevice()->GetDeviceRemovedReason());
throw dxException(hr, __FILE__, __LINE__);
}
} }
}
#else #else
m_Context->GetSwapChain()->Present(0u, 0u); m_Context->GetSwapChain()->Present(0u, 0u);
#endif #endif
} }
void dxRenderCommand::ClearBackBuffer(const glm::vec4& clearColor) void dxRenderCommand::ClearBackBuffer(const glm::vec4& clearColor)
{ {
m_Context->GetDeviceContext()->ClearRenderTargetView(m_Context->GetRenderTargetView().Get(), &clearColor[0]); m_Context->GetDeviceContext()->ClearRenderTargetView(m_Context->GetRenderTargetView().Get(), &clearColor[0]);
} }
void dxRenderCommand::Draw(unsigned int count) void dxRenderCommand::Draw(unsigned int count)
{ {
m_Context->GetDeviceContext()->Draw(count, 0u); m_Context->GetDeviceContext()->Draw(count, 0u);
} }
void dxRenderCommand::DrawIndexed(unsigned int count) void dxRenderCommand::DrawIndexed(unsigned int count)
{ {
m_Context->GetDeviceContext()->DrawIndexed(count, 0u, 0u); m_Context->GetDeviceContext()->DrawIndexed(count, 0u, 0u);
} }
void dxRenderCommand::DefaultTargetFramebuffer() void dxRenderCommand::DefaultTargetFramebuffer()
{ {
m_Context->GetDeviceContext()->OMSetRenderTargets(1, m_Context->GetRenderTargetView().GetAddressOf(), nullptr); m_Context->GetDeviceContext()->OMSetRenderTargets(1, m_Context->GetRenderTargetView().GetAddressOf(), nullptr);
} }
void dxRenderCommand::SetViewport(unsigned int x, unsigned int y, unsigned int width, unsigned int height) void dxRenderCommand::SetViewport(unsigned int x, unsigned int y, unsigned int width, unsigned int height)
{ {
// #todo: maybe call this somewhere else?? // #todo: maybe call this somewhere else??
SetResolution(width, height); SetResolution(width, height);
// create viewport // create viewport
D3D11_VIEWPORT viewport; D3D11_VIEWPORT viewport;
viewport.TopLeftX = x; viewport.TopLeftX = x;
viewport.TopLeftY = y; viewport.TopLeftY = y;
viewport.Width = width; viewport.Width = width;
viewport.Height = height; viewport.Height = height;
viewport.MinDepth = 0.0f; viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f; viewport.MaxDepth = 1.0f;
// set viewport // set viewport
m_Context->GetDeviceContext()->RSSetViewports(1u, &viewport); m_Context->GetDeviceContext()->RSSetViewports(1u, &viewport);
} }
void dxRenderCommand::SetResolution(unsigned int width, unsigned int height) void dxRenderCommand::SetResolution(unsigned int width, unsigned int height)
{ {
HRESULT hr; HRESULT hr;
// remove render target // remove render target
ID3D11RenderTargetView* nullViews[] = { nullptr }; ID3D11RenderTargetView* nullViews[] = { nullptr };
m_Context->GetDeviceContext()->OMSetRenderTargets(1u, nullViews, nullptr); m_Context->GetDeviceContext()->OMSetRenderTargets(1u, nullViews, nullptr);
m_Context->GetRenderTargetViewRef().Reset(); m_Context->GetRenderTargetViewRef().Reset();
// resize buffer // resize buffer
DXC(m_Context->GetSwapChain()->ResizeBuffers(0u, width, height, DXGI_FORMAT_R8G8B8A8_UNORM, NULL)); DXC(m_Context->GetSwapChain()->ResizeBuffers(0u, width, height, DXGI_FORMAT_R8G8B8A8_UNORM, NULL));
// create render target // create render target
Microsoft::WRL::ComPtr<ID3D11Resource> backBuffer = nullptr; Microsoft::WRL::ComPtr<ID3D11Resource> backBuffer = nullptr;
DXC(m_Context->GetSwapChain()->GetBuffer(0u, __uuidof(ID3D11Resource), &backBuffer)); DXC(m_Context->GetSwapChain()->GetBuffer(0u, __uuidof(ID3D11Resource), &backBuffer));
DXC(m_Context->GetDevice()->CreateRenderTargetView(backBuffer.Get(), nullptr, &m_Context->GetRenderTargetViewRef())); DXC(m_Context->GetDevice()->CreateRenderTargetView(backBuffer.Get(), nullptr, &m_Context->GetRenderTargetViewRef()));
// set render target // set render target
m_Context->GetDeviceContext()->OMSetRenderTargets(1u, m_Context->GetRenderTargetView().GetAddressOf(), nullptr); m_Context->GetDeviceContext()->OMSetRenderTargets(1u, m_Context->GetRenderTargetView().GetAddressOf(), nullptr);
} }
} } // namespace Light

64
Engine/src/Platform/GraphicsAPI/DirectX/dxShader.cpp
View file

@ -1,47 +1,45 @@
#include "dxShader.h" #include "dxShader.h"
#include "dxSharedContext.h" #include "dxSharedContext.h"
#include <d3dcompiler.h> #include <d3dcompiler.h>
namespace Light { namespace Light {
dxShader::dxShader(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<dxSharedContext> sharedContext) dxShader::dxShader(BasicFileHandle vertexFile, BasicFileHandle pixelFile, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext), : m_Context(sharedContext), m_VertexShader(nullptr), m_PixelShader(nullptr), m_VertexBlob(nullptr)
m_VertexShader(nullptr), {
m_PixelShader(nullptr), Microsoft::WRL::ComPtr<ID3DBlob> ps = nullptr, vsErr = nullptr, psErr = nullptr;
m_VertexBlob(nullptr)
{
Microsoft::WRL::ComPtr<ID3DBlob> ps = nullptr, vsErr = nullptr, psErr = nullptr;
// compile shaders (we don't use DXC here because if D3DCompile fails it throws a dxException without logging the vsErr/psErr // compile shaders (we don't use DXC here because if D3DCompile fails it throws a dxException without logging the vsErr/psErr
D3DCompile(vertexFile.GetData(), vertexFile.GetSize(), NULL, nullptr, nullptr, "main", "vs_4_0", NULL, NULL, &m_VertexBlob, &vsErr); D3DCompile(vertexFile.GetData(), vertexFile.GetSize(), NULL, nullptr, nullptr, "main", "vs_4_0", NULL, NULL, &m_VertexBlob, &vsErr);
D3DCompile(pixelFile.GetData(), pixelFile.GetSize(), NULL, nullptr, nullptr, "main", "ps_4_0", NULL, NULL, &ps, &psErr); D3DCompile(pixelFile.GetData(), pixelFile.GetSize(), NULL, nullptr, nullptr, "main", "ps_4_0", NULL, NULL, &ps, &psErr);
// check // check
LT_ENGINE_ASSERT(!vsErr.Get(), "dxShader::dxShader: vertex shader compile error: {}", (char*)vsErr->GetBufferPointer()); ASSERT(!vsErr.Get(), "Vertex shader compile error: {}", (char*)vsErr->GetBufferPointer());
LT_ENGINE_ASSERT(!psErr.Get(), "dxShader::dxShader: pixels shader compile error: {}", (char*)psErr->GetBufferPointer()); ASSERT(!psErr.Get(), "Pixels shader compile error: {}", (char*)psErr->GetBufferPointer());
// create shaders // create shaders
HRESULT hr; HRESULT hr;
DXC(m_Context->GetDevice()->CreateVertexShader(m_VertexBlob->GetBufferPointer(), m_VertexBlob->GetBufferSize(), NULL, &m_VertexShader)); DXC(m_Context->GetDevice()->CreateVertexShader(m_VertexBlob->GetBufferPointer(), m_VertexBlob->GetBufferSize(), NULL, &m_VertexShader));
DXC(m_Context->GetDevice()->CreatePixelShader(ps->GetBufferPointer(), ps->GetBufferSize(), NULL, &m_PixelShader)); DXC(m_Context->GetDevice()->CreatePixelShader(ps->GetBufferPointer(), ps->GetBufferSize(), NULL, &m_PixelShader));
} }
dxShader::~dxShader() dxShader::~dxShader()
{ {
UnBind(); UnBind();
} }
void dxShader::Bind() void dxShader::Bind()
{ {
m_Context->GetDeviceContext()->VSSetShader(m_VertexShader.Get(), nullptr, 0u); m_Context->GetDeviceContext()->VSSetShader(m_VertexShader.Get(), nullptr, 0u);
m_Context->GetDeviceContext()->PSSetShader(m_PixelShader.Get(), nullptr, 0u); m_Context->GetDeviceContext()->PSSetShader(m_PixelShader.Get(), nullptr, 0u);
} }
void dxShader::UnBind() void dxShader::UnBind()
{ {
m_Context->GetDeviceContext()->VSSetShader(nullptr, nullptr, 0u); m_Context->GetDeviceContext()->VSSetShader(nullptr, nullptr, 0u);
m_Context->GetDeviceContext()->PSSetShader(nullptr, nullptr, 0u); m_Context->GetDeviceContext()->PSSetShader(nullptr, nullptr, 0u);
} }
} } // namespace Light

89
Engine/src/Platform/GraphicsAPI/DirectX/dxUserInterface.cpp
View file

@ -1,65 +1,64 @@
#include "dxUserInterface.h" #include "dxUserInterface.h"
#include "dxSharedContext.h"
#include "Input/KeyCodes.h" #include "Input/KeyCodes.h"
#include "dxSharedContext.h"
#define GLFW_EXPOSE_NATIVE_WIN32 #define GLFW_EXPOSE_NATIVE_WIN32
#include <backends/imgui_impl_dx11.h>
#include <backends/imgui_impl_win32.h>
#include <glfw/glfw3.h> #include <glfw/glfw3.h>
#include <glfw/glfw3native.h> #include <glfw/glfw3native.h>
#include <imgui.h> #include <imgui.h>
#include <backends/imgui_impl_win32.h>
#include <backends/imgui_impl_dx11.h>
namespace Light { namespace Light {
void dxUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext) void dxUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
{ {
ImGuiIO& io = ImGui::GetIO(); ImGuiIO& io = ImGui::GetIO();
Ref<dxSharedContext> context = std::dynamic_pointer_cast<dxSharedContext>(sharedContext); Ref<dxSharedContext> context = std::dynamic_pointer_cast<dxSharedContext>(sharedContext);
ImGui_ImplWin32_Init(glfwGetWin32Window(windowHandle)); ImGui_ImplWin32_Init(glfwGetWin32Window(windowHandle));
ImGui_ImplDX11_Init(context->GetDevice().Get(), context->GetDeviceContext().Get()); ImGui_ImplDX11_Init(context->GetDevice().Get(), context->GetDeviceContext().Get());
} }
dxUserInterface::~dxUserInterface() dxUserInterface::~dxUserInterface()
{ {
// #todo: handle this in a better way // #todo: handle this in a better way
ImGuiIO& io = ImGui::GetIO(); ImGuiIO& io = ImGui::GetIO();
if (io.IniFilename == "default_gui_layout.ini") if (io.IniFilename == "default_gui_layout.ini")
io.IniFilename = "user_gui_layout.ini"; io.IniFilename = "user_gui_layout.ini";
ImGui_ImplDX11_Shutdown(); ImGui_ImplDX11_Shutdown();
ImGui_ImplWin32_Shutdown(); ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext(); ImGui::DestroyContext();
} }
void dxUserInterface::Begin() void dxUserInterface::Begin()
{ {
ImGui_ImplDX11_NewFrame(); ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame(); ImGui_ImplWin32_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
} }
void dxUserInterface::End() void dxUserInterface::End()
{ {
ImGui::Render(); ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData()); ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
ImGui::UpdatePlatformWindows(); ImGui::UpdatePlatformWindows();
ImGui::RenderPlatformWindowsDefault(); ImGui::RenderPlatformWindowsDefault();
} }
void dxUserInterface::LogDebugData() void dxUserInterface::LogDebugData()
{ {
// #todo: improve // #todo: improve
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
LT_ENGINE_INFO("UserInterface::"); LOG(info, "UserInterface::");
LT_ENGINE_INFO(" API : ImGui"); LOG(info, " API : ImGui");
LT_ENGINE_INFO(" Version: {}", ImGui::GetVersion()); LOG(info, " Version: {}", ImGui::GetVersion());
LT_ENGINE_INFO(" GraphicsAPI : DirectX"); LOG(info, " GraphicsAPI : DirectX");
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
} }
} } // namespace Light

153
Engine/src/Platform/GraphicsAPI/DirectX/dxVertexLayout.cpp
View file

@ -1,89 +1,88 @@
#include "dxVertexLayout.h" #include "dxVertexLayout.h"
#include "dxSharedContext.h"
#include "dxShader.h" #include "dxShader.h"
#include "dxSharedContext.h"
namespace Light { namespace Light {
dxVertexLayout::dxVertexLayout(Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<dxSharedContext> sharedContext) dxVertexLayout::dxVertexLayout(Ref<Shader> shader, const std::vector<std::pair<std::string, VertexElementType>>& elements, Ref<dxSharedContext> sharedContext)
: m_Context(sharedContext), : m_Context(sharedContext), m_InputLayout(nullptr)
m_InputLayout(nullptr) {
// occupy space for input elements
std::vector<D3D11_INPUT_ELEMENT_DESC> inputElementsDesc;
inputElementsDesc.reserve(elements.size());
// extract elements desc
for (const auto& element : elements)
{ {
// occupy space for input elements inputElementsDesc.emplace_back(D3D11_INPUT_ELEMENT_DESC { element.first.c_str(),
std::vector<D3D11_INPUT_ELEMENT_DESC> inputElementsDesc; NULL,
inputElementsDesc.reserve(elements.size()); GetDxgiFormat(element.second),
0u,
// extract elements desc D3D11_APPEND_ALIGNED_ELEMENT,
for (const auto& element : elements) D3D11_INPUT_PER_VERTEX_DATA,
{ 0u });
inputElementsDesc.emplace_back(D3D11_INPUT_ELEMENT_DESC{ element.first.c_str(),
NULL,
GetDxgiFormat(element.second),
0u,
D3D11_APPEND_ALIGNED_ELEMENT,
D3D11_INPUT_PER_VERTEX_DATA,
0u });
}
Ref<dxShader> dxpShader = std::dynamic_pointer_cast<dxShader>(shader);
LT_ENGINE_ASSERT(dxpShader, "dxVertexLayout::dxVertexLayout: failed to cast 'Shader' to 'dxShader'");
// create input layout (vertex layout)
HRESULT hr;
DXC(m_Context->GetDevice()->CreateInputLayout(&inputElementsDesc[0], inputElementsDesc.size(), dxpShader->GetVertexBlob().Get()->GetBufferPointer(), dxpShader->GetVertexBlob().Get()->GetBufferSize(), &m_InputLayout));
} }
dxVertexLayout::~dxVertexLayout() Ref<dxShader> dxpShader = std::dynamic_pointer_cast<dxShader>(shader);
ASSERT(dxpShader, "Failed to cast 'Shader' to 'dxShader'");
// create input layout (vertex layout)
HRESULT hr;
DXC(m_Context->GetDevice()->CreateInputLayout(&inputElementsDesc[0], inputElementsDesc.size(), dxpShader->GetVertexBlob().Get()->GetBufferPointer(), dxpShader->GetVertexBlob().Get()->GetBufferSize(), &m_InputLayout));
}
dxVertexLayout::~dxVertexLayout()
{
UnBind();
}
void dxVertexLayout::Bind()
{
m_Context->GetDeviceContext()->IASetInputLayout(m_InputLayout.Get());
}
void dxVertexLayout::UnBind()
{
m_Context->GetDeviceContext()->IASetInputLayout(nullptr);
}
DXGI_FORMAT dxVertexLayout::GetDxgiFormat(VertexElementType type)
{
switch (type)
{ {
UnBind(); /* byte */
case Light::VertexElementType::Byte1: return DXGI_FORMAT_R8_SINT;
case Light::VertexElementType::Byte2: return DXGI_FORMAT_R8G8_SINT;
case Light::VertexElementType::Byte4: return DXGI_FORMAT_R8_SINT;
/* ubyte */
case Light::VertexElementType::UByte1: return DXGI_FORMAT_R8_UINT;
case Light::VertexElementType::UByte2: return DXGI_FORMAT_R8G8_UINT;
case Light::VertexElementType::UByte4: return DXGI_FORMAT_R8G8B8A8_UINT;
/* int */
case Light::VertexElementType::Int1: return DXGI_FORMAT_R32_SINT;
case Light::VertexElementType::Int2: return DXGI_FORMAT_R32G32_SINT;
case Light::VertexElementType::Int3: return DXGI_FORMAT_R32G32B32_SINT;
case Light::VertexElementType::Int4: return DXGI_FORMAT_R32G32B32A32_SINT;
/* uint */
case Light::VertexElementType::UInt1: return DXGI_FORMAT_R32_UINT;
case Light::VertexElementType::UInt2: return DXGI_FORMAT_R32G32_UINT;
case Light::VertexElementType::UInt3: return DXGI_FORMAT_R32G32B32_UINT;
case Light::VertexElementType::UInt4: return DXGI_FORMAT_R32G32B32A32_UINT;
/* float */
case Light::VertexElementType::Float1: return DXGI_FORMAT_R32_FLOAT;
case Light::VertexElementType::Float2: return DXGI_FORMAT_R32G32_FLOAT;
case Light::VertexElementType::Float3: return DXGI_FORMAT_R32G32B32_FLOAT;
case Light::VertexElementType::Float4: return DXGI_FORMAT_R32G32B32A32_FLOAT;
default:
ASSERT(false, "Invalid 'VertexElementType'");
return DXGI_FORMAT_UNKNOWN;
} }
}
void dxVertexLayout::Bind() } // namespace Light
{
m_Context->GetDeviceContext()->IASetInputLayout(m_InputLayout.Get());
}
void dxVertexLayout::UnBind()
{
m_Context->GetDeviceContext()->IASetInputLayout(nullptr);
}
DXGI_FORMAT dxVertexLayout::GetDxgiFormat(VertexElementType type)
{
switch (type)
{
/* byte */
case Light::VertexElementType::Byte1: return DXGI_FORMAT_R8_SINT;
case Light::VertexElementType::Byte2: return DXGI_FORMAT_R8G8_SINT;
case Light::VertexElementType::Byte4: return DXGI_FORMAT_R8_SINT;
/* ubyte */
case Light::VertexElementType::UByte1: return DXGI_FORMAT_R8_UINT;
case Light::VertexElementType::UByte2: return DXGI_FORMAT_R8G8_UINT;
case Light::VertexElementType::UByte4: return DXGI_FORMAT_R8G8B8A8_UINT;
/* int */
case Light::VertexElementType::Int1: return DXGI_FORMAT_R32_SINT;
case Light::VertexElementType::Int2: return DXGI_FORMAT_R32G32_SINT;
case Light::VertexElementType::Int3: return DXGI_FORMAT_R32G32B32_SINT;
case Light::VertexElementType::Int4: return DXGI_FORMAT_R32G32B32A32_SINT;
/* uint */
case Light::VertexElementType::UInt1: return DXGI_FORMAT_R32_UINT;
case Light::VertexElementType::UInt2: return DXGI_FORMAT_R32G32_UINT;
case Light::VertexElementType::UInt3: return DXGI_FORMAT_R32G32B32_UINT;
case Light::VertexElementType::UInt4: return DXGI_FORMAT_R32G32B32A32_UINT;
/* float */
case Light::VertexElementType::Float1: return DXGI_FORMAT_R32_FLOAT;
case Light::VertexElementType::Float2: return DXGI_FORMAT_R32G32_FLOAT;
case Light::VertexElementType::Float3: return DXGI_FORMAT_R32G32B32_FLOAT;
case Light::VertexElementType::Float4: return DXGI_FORMAT_R32G32B32A32_FLOAT;
default:
LT_ENGINE_ASSERT(false, "dxVertexLayout::GetDxgiFormat: invalid 'VertexElementType'");
return DXGI_FORMAT_UNKNOWN;
}
}
}

207
Engine/src/Platform/GraphicsAPI/OpenGL/glBuffers.cpp
View file

@ -4,129 +4,128 @@
namespace Light { namespace Light {
//==================== CONSTANT_BUFFER ====================// //==================== CONSTANT_BUFFER ====================//
glConstantBuffer::glConstantBuffer(ConstantBufferIndex index, unsigned int size) glConstantBuffer::glConstantBuffer(ConstantBufferIndex index, unsigned int size)
: m_BufferID(NULL), : m_BufferID(NULL), m_Index(static_cast<int>(index))
m_Index(static_cast<int>(index)) {
{ glCreateBuffers(1, &m_BufferID);
glCreateBuffers(1, &m_BufferID); glNamedBufferData(m_BufferID, size, nullptr, GL_DYNAMIC_DRAW);
glNamedBufferData(m_BufferID, size, nullptr, GL_DYNAMIC_DRAW);
Bind(); Bind();
} }
glConstantBuffer::~glConstantBuffer() glConstantBuffer::~glConstantBuffer()
{ {
glDeleteBuffers(1, &m_BufferID); glDeleteBuffers(1, &m_BufferID);
} }
void glConstantBuffer::Bind() void glConstantBuffer::Bind()
{ {
glBindBufferBase(GL_UNIFORM_BUFFER, m_Index, m_BufferID); glBindBufferBase(GL_UNIFORM_BUFFER, m_Index, m_BufferID);
} }
void* glConstantBuffer::Map() void* glConstantBuffer::Map()
{ {
void* map = glMapNamedBuffer(m_BufferID, GL_WRITE_ONLY); void* map = glMapNamedBuffer(m_BufferID, GL_WRITE_ONLY);
return map; return map;
} }
void glConstantBuffer::UnMap() void glConstantBuffer::UnMap()
{ {
glUnmapNamedBuffer(m_BufferID); glUnmapNamedBuffer(m_BufferID);
} }
//==================== CONSTANT_BUFFER ====================// //==================== CONSTANT_BUFFER ====================//
//==================== VERTEX_BUFFER ====================// //==================== VERTEX_BUFFER ====================//
glVertexBuffer::glVertexBuffer(float* vertices, unsigned int stride, unsigned int count) glVertexBuffer::glVertexBuffer(float* vertices, unsigned int stride, unsigned int count)
: m_BufferID(NULL) : m_BufferID(NULL)
{ {
glCreateBuffers(1, &m_BufferID); glCreateBuffers(1, &m_BufferID);
glNamedBufferData(m_BufferID, stride * count, vertices, GL_DYNAMIC_DRAW); glNamedBufferData(m_BufferID, stride * count, vertices, GL_DYNAMIC_DRAW);
} }
glVertexBuffer::~glVertexBuffer() glVertexBuffer::~glVertexBuffer()
{ {
glDeleteBuffers(1, &m_BufferID); glDeleteBuffers(1, &m_BufferID);
} }
void glVertexBuffer::Bind() void glVertexBuffer::Bind()
{ {
glBindBuffer(GL_ARRAY_BUFFER, m_BufferID); glBindBuffer(GL_ARRAY_BUFFER, m_BufferID);
} }
void glVertexBuffer::UnBind() void glVertexBuffer::UnBind()
{ {
glBindBuffer(GL_ARRAY_BUFFER, NULL); glBindBuffer(GL_ARRAY_BUFFER, NULL);
} }
void* glVertexBuffer::Map() void* glVertexBuffer::Map()
{ {
return glMapNamedBuffer(m_BufferID, GL_WRITE_ONLY); return glMapNamedBuffer(m_BufferID, GL_WRITE_ONLY);
} }
void glVertexBuffer::UnMap() void glVertexBuffer::UnMap()
{ {
glUnmapNamedBuffer(m_BufferID); glUnmapNamedBuffer(m_BufferID);
} }
//==================== VERTEX_BUFFER ====================// //==================== VERTEX_BUFFER ====================//
//==================== INDEX_BUFFER ====================// //==================== INDEX_BUFFER ====================//
glIndexBuffer::glIndexBuffer(unsigned int* indices, unsigned int count) glIndexBuffer::glIndexBuffer(unsigned int* indices, unsigned int count)
: m_BufferID(NULL) : m_BufferID(NULL)
{
// generate indices if not provided
bool hasIndices = !!indices;
if (!hasIndices)
{ {
// generate indices if not provided // check
bool hasIndices = !!indices; if (count % 6 != 0)
if (!hasIndices)
{ {
// check LOG(warn, "'indices' can only be null if count is multiple of 6");
if (count % 6 != 0) LOG(warn, "Adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
{ count = count + (6 - (count % 6));
LT_ENGINE_WARN("glIndexBuffer::dxIndexBuffer: 'indices' can only be null if count is multiple of 6");
LT_ENGINE_WARN("glIndexBuffer::glIndexBuffer: adding {} to 'count' -> {}", (6 - (count % 6)), count + (6 - (count % 6)));
count = count + (6 - (count % 6));
}
// create indices
indices = new unsigned int[count];
unsigned int offset = 0u;
for (unsigned int i = 0u; i < count; i += 6u)
{
indices[i + 0] = offset + 0u;
indices[i + 1] = offset + 1u;
indices[i + 2] = offset + 2u;
indices[i + 3] = offset + 2u;
indices[i + 4] = offset + 3u;
indices[i + 5] = offset + 0u;
offset += 4u;
}
} }
// create buffer // create indices
glCreateBuffers(1, &m_BufferID); indices = new unsigned int[count];
glNamedBufferData(m_BufferID, count * sizeof(unsigned int), indices, GL_STATIC_DRAW); unsigned int offset = 0u;
for (unsigned int i = 0u; i < count; i += 6u)
{
indices[i + 0] = offset + 0u;
indices[i + 1] = offset + 1u;
indices[i + 2] = offset + 2u;
// delete indices indices[i + 3] = offset + 2u;
if (!hasIndices) indices[i + 4] = offset + 3u;
delete[] indices; indices[i + 5] = offset + 0u;
offset += 4u;
}
} }
glIndexBuffer::~glIndexBuffer() // create buffer
{ glCreateBuffers(1, &m_BufferID);
glDeleteBuffers(1, &m_BufferID); glNamedBufferData(m_BufferID, count * sizeof(unsigned int), indices, GL_STATIC_DRAW);
}
void glIndexBuffer::Bind() // delete indices
{ if (!hasIndices)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_BufferID); delete[] indices;
} }
void glIndexBuffer::UnBind() glIndexBuffer::~glIndexBuffer()
{ {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL); glDeleteBuffers(1, &m_BufferID);
} }
//==================== INDEX_BUFFER ====================//
} void glIndexBuffer::Bind()
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_BufferID);
}
void glIndexBuffer::UnBind()
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);
}
//==================== INDEX_BUFFER ====================//
} // namespace Light

106
Engine/src/Platform/GraphicsAPI/OpenGL/glFramebuffer.cpp
View file

@ -1,76 +1,72 @@
#include "glFramebuffer.h" #include "glFramebuffer.h"
#include <glad/glad.h> #include <glad/glad.h>
#include <glm/glm.hpp> #include <glm/glm.hpp>
namespace Light { namespace Light {
glFramebuffer::glFramebuffer(const FramebufferSpecification& specification) glFramebuffer::glFramebuffer(const FramebufferSpecification& specification)
: m_Specification(specification), : m_Specification(specification), m_BufferID(NULL), m_ColorAttachmentID(NULL), m_DepthStencilAttachmentID(NULL)
m_BufferID(NULL), {
m_ColorAttachmentID(NULL), Resize({ specification.width, specification.height });
m_DepthStencilAttachmentID(NULL) }
{
Resize({ specification.width, specification.height });
}
glFramebuffer::~glFramebuffer() glFramebuffer::~glFramebuffer()
{
glDeleteFramebuffers(1, &m_BufferID);
glDeleteTextures(1, &m_ColorAttachmentID);
// glDeleteTextures(1, &m_DepthStencilAttachmentID);
}
void glFramebuffer::BindAsTarget(const glm::vec4& clearColor)
{
// #todo: use viewport instead of default x=0, y=0
glBindFramebuffer(GL_FRAMEBUFFER, m_BufferID);
glViewport(0, 0, m_Specification.width, m_Specification.height);
glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
glClear(GL_COLOR_BUFFER_BIT);
}
void glFramebuffer::BindAsResource()
{
LOG(err, "NO_IMPLEMENT!");
}
void glFramebuffer::Resize(const glm::uvec2& size)
{
if (m_BufferID)
{ {
glDeleteFramebuffers(1, &m_BufferID); glDeleteFramebuffers(1, &m_BufferID);
glDeleteTextures(1, &m_ColorAttachmentID); glDeleteTextures(1, &m_ColorAttachmentID);
// glDeleteTextures(1, &m_DepthStencilAttachmentID); // glDeleteTextures(1, &m_DepthStencilAttachmentID);
} }
void glFramebuffer::BindAsTarget(const glm::vec4& clearColor) m_Specification.width = std::clamp(size.x, 1u, (unsigned int)GL_MAX_TEXTURE_SIZE);
{ m_Specification.height = std::clamp(size.y, 1u, (unsigned int)GL_MAX_TEXTURE_SIZE);
// #todo: use viewport instead of default x=0, y=0
glBindFramebuffer(GL_FRAMEBUFFER, m_BufferID);
glViewport(0, 0, m_Specification.width, m_Specification.height);
glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a); glCreateFramebuffers(1, &m_BufferID);
glClear(GL_COLOR_BUFFER_BIT); glBindFramebuffer(GL_FRAMEBUFFER, m_BufferID);
}
void glFramebuffer::BindAsResource() // create color attachment
{ glCreateTextures(GL_TEXTURE_2D, 1, &m_ColorAttachmentID);
LT_ENGINE_ERROR("glFramebuffer::BindAsResource: NO_IMPLEMENT!"); glBindTexture(GL_TEXTURE_2D, m_ColorAttachmentID);
} glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Specification.width, m_Specification.height, NULL, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTextureParameteri(m_ColorAttachmentID, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteri(m_ColorAttachmentID, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_ColorAttachmentID, 0);
void glFramebuffer::Resize(const glm::uvec2& size) // glTextureStorage2D(m_ColorAttachmentID, 0, GL_RGBA8, m_Specification.width, m_Specification.height);
{
if (m_BufferID)
{
glDeleteFramebuffers(1, &m_BufferID);
glDeleteTextures(1, &m_ColorAttachmentID);
// glDeleteTextures(1, &m_DepthStencilAttachmentID);
}
m_Specification.width = std::clamp(size.x, 1u, (unsigned int)GL_MAX_TEXTURE_SIZE); // glCreateTextures(GL_TEXTURE_2D, 1, &m_DepthStencilAttachmentID);
m_Specification.height = std::clamp(size.y, 1u, (unsigned int)GL_MAX_TEXTURE_SIZE); // glBindTexture(GL_TEXTURE_2D, m_DepthStencilAttachmentID);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, m_Specification.width, m_Specification.height, NULL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
// // glTextureStorage2D(m_DepthStencilAttachmentID, 0, GL_DEPTH24_STENCIL8, m_Specification.width, m_Specification.height);
// glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthStencilAttachmentID, 0);
glCreateFramebuffers(1, &m_BufferID); ASSERT((glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE), "Framebuffer is incomplete");
glBindFramebuffer(GL_FRAMEBUFFER, m_BufferID);
// create color attachment glBindFramebuffer(GL_FRAMEBUFFER, 0);
glCreateTextures(GL_TEXTURE_2D, 1, &m_ColorAttachmentID); }
glBindTexture(GL_TEXTURE_2D, m_ColorAttachmentID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Specification.width, m_Specification.height, NULL, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTextureParameteri(m_ColorAttachmentID, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteri(m_ColorAttachmentID, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_ColorAttachmentID, 0);
// glTextureStorage2D(m_ColorAttachmentID, 0, GL_RGBA8, m_Specification.width, m_Specification.height); } // namespace Light
// glCreateTextures(GL_TEXTURE_2D, 1, &m_DepthStencilAttachmentID);
// glBindTexture(GL_TEXTURE_2D, m_DepthStencilAttachmentID);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, m_Specification.width, m_Specification.height, NULL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
// // glTextureStorage2D(m_DepthStencilAttachmentID, 0, GL_DEPTH24_STENCIL8, m_Specification.width, m_Specification.height);
// glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_DepthStencilAttachmentID, 0);
LT_ENGINE_ASSERT((glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE), "glFramebuffer::Validate: framebuffer is incomplete");
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
}

154
Engine/src/Platform/GraphicsAPI/OpenGL/glGraphicsContext.cpp
View file

@ -1,100 +1,100 @@
#include "glGraphicsContext.h" #include "glGraphicsContext.h"
#include "Events/WindowEvents.h" #include "Events/WindowEvents.h"
#include "Graphics/Blender.h" // required for forward declaration
#include "Graphics/Blender.h" // required for forward declaration #include "Graphics/Buffers.h" // required for forward declaration
#include "Graphics/Buffers.h" // required for forward declaration #include "Graphics/RenderCommand.h" // required for forward declaration
#include "Graphics/Renderer.h" // required for forward declaration #include "Graphics/Renderer.h" // required for forward declaration
#include "Graphics/RenderCommand.h" // required for forward declaration
#include "UserInterface/UserInterface.h" // required for forward declaration #include "UserInterface/UserInterface.h" // required for forward declaration
#include "Utility/ResourceManager.h" // required for forward declaration
#include "Utility/ResourceManager.h" // required for forward declaration
#include <glad/glad.h> #include <glad/glad.h>
#include <GLFW/glfw3.h>
#ifndef STOP_FUCKING_ORDERING_THESE_THE_WRONG_WAY_CLANG_FORMAT____
#include <GLFW/glfw3.h>
#endif
namespace Light { namespace Light {
glGraphicsContext::glGraphicsContext(GLFWwindow* windowHandle) glGraphicsContext::glGraphicsContext(GLFWwindow* windowHandle)
: m_WindowHandle(windowHandle) : m_WindowHandle(windowHandle)
{ {
// set 'GraphicsAPI' // set 'GraphicsAPI'
m_GraphicsAPI = GraphicsAPI::OpenGL; m_GraphicsAPI = GraphicsAPI::OpenGL;
// make context current // make context current
glfwMakeContextCurrent(windowHandle); glfwMakeContextCurrent(windowHandle);
// load opengl (glad)
LT_ENGINE_ASSERT(gladLoadGLLoader((GLADloadproc)glfwGetProcAddress), "glGraphicsContext::glGraphicsContext: failed to initialize opengl (glad)");
SetDebugMessageCallback(); // load opengl (glad)
} ASSERT(gladLoadGLLoader((GLADloadproc)glfwGetProcAddress), "Failed to initialize opengl (glad)");
void glGraphicsContext::LogDebugData() SetDebugMessageCallback();
{ }
// #todo: log more information
LT_ENGINE_INFO("________________________________________");
LT_ENGINE_INFO("GraphicsContext::");
LT_ENGINE_INFO(" API : OpenGL");
LT_ENGINE_INFO(" Version : {}", glGetString(GL_VERSION));
LT_ENGINE_INFO(" Renderer: {}", glGetString(GL_RENDERER));
LT_ENGINE_INFO("________________________________________");
}
void glGraphicsContext::SetDebugMessageCallback() void glGraphicsContext::LogDebugData()
{ {
// determine log level // #todo: log more information
// #todo: set filters from config.h LOG(info, "________________________________________");
LOG(info, "GraphicsContext::");
LOG(info, " API : OpenGL");
LOG(info, " Version : {}", glGetString(GL_VERSION));
LOG(info, " Renderer: {}", glGetString(GL_RENDERER));
LOG(info, "________________________________________");
}
void glGraphicsContext::SetDebugMessageCallback()
{
// determine log level
// #todo: set filters from config.h
#if defined(LIGHT_DEBUG) #if defined(LIGHT_DEBUG)
glEnable(GL_DEBUG_OUTPUT); glEnable(GL_DEBUG_OUTPUT);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr , GL_TRUE); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
GLuint ids[] = GLuint ids[] = {
{ 131185
131185 };
}; glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE, _countof(ids), ids, GL_FALSE);
glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE, _countof(ids), ids, GL_FALSE);
#elif defined(LIGHT_RELEASE) #elif defined(LIGHT_RELEASE)
glEnable(GL_DEBUG_OUTPUT); glEnable(GL_DEBUG_OUTPUT);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_FALSE); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_FALSE);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, GL_TRUE); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, GL_TRUE);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, GL_TRUE); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, GL_TRUE);
#else // LIGHT_DIST #else // LIGHT_DIST
return; return;
#endif #endif
/* setup message callback */ /* setup message callback */
glDebugMessageCallback([](unsigned int source, unsigned int type, glDebugMessageCallback([](unsigned int source, unsigned int type,
unsigned int id, unsigned int severity, unsigned int id, unsigned int severity,
int length, const char* message, int length, const char* message,
const void* userParam) const void* userParam) {
switch (severity)
{ {
switch (severity) case GL_DEBUG_SEVERITY_HIGH:
{ // throw glException(source, type, id, message);
case GL_DEBUG_SEVERITY_HIGH: return;
// throw glException(source, type, id, message);
return;
case GL_DEBUG_SEVERITY_MEDIUM: case GL_DEBUG_SEVERITY_LOW: case GL_DEBUG_SEVERITY_MEDIUM:
LT_ENGINE_WARN("glMessageCallback: Severity: {} :: Source: {} :: Type: {} :: ID: {}", case GL_DEBUG_SEVERITY_LOW:
Stringifier::glDebugMsgSeverity(severity), LOG(warn, "glMessageCallback: Severity: {} :: Source: {} :: Type: {} :: ID: {}",
Stringifier::glDebugMsgSource(source), Stringifier::glDebugMsgSeverity(severity),
Stringifier::glDebugMsgType(type), Stringifier::glDebugMsgSource(source),
id); Stringifier::glDebugMsgType(type),
LT_ENGINE_WARN(" {}", message); id);
return; LOG(warn, " {}", message);
return;
case GL_DEBUG_SEVERITY_NOTIFICATION:
LT_ENGINE_TRACE("glMessageCallback: Severity: {} :: Source: {} :: Type: {} :: ID: {}",
Stringifier::glDebugMsgSeverity(severity),
Stringifier::glDebugMsgSource(source),
Stringifier::glDebugMsgType(type),
id);
LT_ENGINE_TRACE(" {}", message);
return;
}
}, nullptr);
}
case GL_DEBUG_SEVERITY_NOTIFICATION:
LOG(trace, "Severity: {} :: Source: {} :: Type: {} :: ID: {}",
Stringifier::glDebugMsgSeverity(severity),
Stringifier::glDebugMsgSource(source),
Stringifier::glDebugMsgType(type),
id);
LOG(trace, " {}", message);
return;
}
},
nullptr);
} }
} // namespace Light

8
Engine/src/Platform/GraphicsAPI/OpenGL/glShader.cpp
View file

@ -61,8 +61,8 @@ shaderc::SpvCompilationResult glShader::CompileGLSL(BasicFileHandle file, Shader
// log error // log error
if (result.GetCompilationStatus() != shaderc_compilation_status_success) if (result.GetCompilationStatus() != shaderc_compilation_status_success)
{ {
LT_ENGINE_ERROR("Failed to compile {} shader at {}...", stage == Shader::Stage::VERTEX ? "vertex" : "pixel", file.GetPath()); LOG(err, "Failed to compile {} shader at {}...", stage == Shader::Stage::VERTEX ? "vertex" : "pixel", file.GetPath());
LT_ENGINE_ERROR(" {}", result.GetErrorMessage()); LOG(err, " {}", result.GetErrorMessage());
} }
return result; return result;
@ -92,7 +92,7 @@ unsigned int glShader::CompileShader(std::string source, Shader::Stage stage)
char* errorLog = (char*)alloca(logLength); char* errorLog = (char*)alloca(logLength);
glGetShaderInfoLog(shader, logLength, &logLength, &errorLog[0]); glGetShaderInfoLog(shader, logLength, &logLength, &errorLog[0]);
LT_ENGINE_ERROR("glShader::glShader: failed to compile {} shader:\n {}", stage == Shader::Stage::VERTEX ? "Vertex" : "Pixel", errorLog); LOG(err, "glShader::glShader: failed to compile {} shader:\n {}", stage == Shader::Stage::VERTEX ? "Vertex" : "Pixel", errorLog);
return NULL; return NULL;
} }
@ -107,7 +107,7 @@ unsigned int glShader::CompileShader(std::string source, Shader::Stage stage)
char* infoLog = (char*)alloca(logLength); char* infoLog = (char*)alloca(logLength);
glGetShaderInfoLog(shader, logLength, &logLength, &infoLog[0]); glGetShaderInfoLog(shader, logLength, &logLength, &infoLog[0]);
LT_ENGINE_WARN(infoLog); LOG(warn, infoLog);
} }
} }
#endif #endif

2
Engine/src/Platform/GraphicsAPI/OpenGL/glTexture.cpp
View file

@ -30,7 +30,7 @@ glTexture::glTexture(unsigned int width, unsigned int height, unsigned int compo
NULL; NULL;
// check // check
LT_ENGINE_ASSERT(format, "glTexture::glTexture: invalid number of components: {}", components); ASSERT(format, "Invalid number of components: {}", components);
// #todo: isn't there something like glTextureImage2D ??? // #todo: isn't there something like glTextureImage2D ???

85
Engine/src/Platform/GraphicsAPI/OpenGL/glUserInterface.cpp
View file

@ -3,60 +3,59 @@
#include "Input/KeyCodes.h" #include "Input/KeyCodes.h"
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#include <imgui.h>
#include <backends/imgui_impl_glfw.h> #include <backends/imgui_impl_glfw.h>
#include <backends/imgui_impl_opengl3.h> #include <backends/imgui_impl_opengl3.h>
#include <imgui.h>
namespace Light { namespace Light {
void glUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext) void glUserInterface::PlatformImplementation(GLFWwindow* windowHandle, Ref<SharedContext> sharedContext)
{ {
m_WindowHandle = windowHandle; m_WindowHandle = windowHandle;
ImGui_ImplGlfw_InitForOpenGL(windowHandle, false); ImGui_ImplGlfw_InitForOpenGL(windowHandle, false);
ImGui_ImplOpenGL3_Init(); ImGui_ImplOpenGL3_Init();
} }
glUserInterface::~glUserInterface() glUserInterface::~glUserInterface()
{ {
// #todo: handle this in a better way // #todo: handle this in a better way
ImGuiIO& io = ImGui::GetIO(); ImGuiIO& io = ImGui::GetIO();
if (io.IniFilename == "default_gui_layout.ini") if (io.IniFilename == "default_gui_layout.ini")
io.IniFilename = "user_gui_layout.ini"; io.IniFilename = "user_gui_layout.ini";
ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown(); ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext(); ImGui::DestroyContext();
} }
void glUserInterface::Begin() void glUserInterface::Begin()
{ {
ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame(); ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
} }
void glUserInterface::End() void glUserInterface::End()
{ {
ImGui::Render(); ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
ImGui::UpdatePlatformWindows(); ImGui::UpdatePlatformWindows();
ImGui::RenderPlatformWindowsDefault(); ImGui::RenderPlatformWindowsDefault();
glfwMakeContextCurrent(m_WindowHandle); glfwMakeContextCurrent(m_WindowHandle);
} }
void glUserInterface::LogDebugData() void glUserInterface::LogDebugData()
{ {
// #todo: improve // #todo: improve
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
LT_ENGINE_INFO("UserInterface::"); LOG(info, "UserInterface::");
LT_ENGINE_INFO(" API : ImGui"); LOG(info, " API : ImGui");
LT_ENGINE_INFO(" Version: {}", ImGui::GetVersion()); LOG(info, " Version: {}", ImGui::GetVersion());
LT_ENGINE_INFO(" GraphicsAPI : OpenGL"); LOG(info, " GraphicsAPI : OpenGL");
LT_ENGINE_INFO("________________________________________"); LOG(info, "________________________________________");
} }
} } // namespace Light

160
Engine/src/Platform/GraphicsAPI/OpenGL/glVertexLayout.cpp
View file

@ -6,92 +6,92 @@
namespace Light { namespace Light {
glVertexLayout::glVertexLayout(Ref<VertexBuffer> buffer, const std::vector<std::pair<std::string, VertexElementType>>& elements) glVertexLayout::glVertexLayout(Ref<VertexBuffer> buffer, const std::vector<std::pair<std::string, VertexElementType>>& elements)
: m_ArrayID(NULL) : m_ArrayID(NULL)
{
// check
ASSERT(std::dynamic_pointer_cast<glVertexBuffer>(buffer), "Failed to cast 'VertexBuffer' to 'glVertexBuffer'");
ASSERT(!elements.empty(), "'elements' is empty");
// local
std::vector<glVertexElementDesc> elementsDesc;
elementsDesc.reserve(elements.size());
unsigned int stride = 0u;
// extract elements desc
for (const auto& element : elements)
{ {
// check elementsDesc.push_back(GetElementDesc(element.second, stride));
LT_ENGINE_ASSERT(std::dynamic_pointer_cast<glVertexBuffer>(buffer), "glVertexLayout::glVertexLayout: failed to cast 'VertexBuffer' to 'glVertexBuffer'"); stride += elementsDesc.back().typeSize * elementsDesc.back().count;
LT_ENGINE_ASSERT(!elements.empty(), "glVertexLayout::glVertexLayout: 'elements' is empty");
// local
std::vector<glVertexElementDesc> elementsDesc;
elementsDesc.reserve(elements.size());
unsigned int stride = 0u;
// extract elements desc
for(const auto& element : elements)
{
elementsDesc.push_back(GetElementDesc(element.second, stride));
stride += elementsDesc.back().typeSize * elementsDesc.back().count;
}
// create vertex array
glCreateVertexArrays(1, &m_ArrayID);
// bind buffer and array
buffer->Bind();
Bind();
// enable vertex attributes
unsigned int index = 0u;
for (const auto& elementDesc : elementsDesc)
{
glVertexAttribPointer(index, elementDesc.count, elementDesc.type, GL_FALSE, stride, (const void*)elementDesc.offset);
glEnableVertexAttribArray(index++);
}
} }
glVertexLayout::~glVertexLayout() // create vertex array
glCreateVertexArrays(1, &m_ArrayID);
// bind buffer and array
buffer->Bind();
Bind();
// enable vertex attributes
unsigned int index = 0u;
for (const auto& elementDesc : elementsDesc)
{ {
glDeleteVertexArrays(1, &m_ArrayID); glVertexAttribPointer(index, elementDesc.count, elementDesc.type, GL_FALSE, stride, (const void*)elementDesc.offset);
glEnableVertexAttribArray(index++);
} }
}
void glVertexLayout::Bind() glVertexLayout::~glVertexLayout()
{
glDeleteVertexArrays(1, &m_ArrayID);
}
void glVertexLayout::Bind()
{
glBindVertexArray(m_ArrayID);
}
void glVertexLayout::UnBind()
{
glBindVertexArray(NULL);
}
glVertexElementDesc glVertexLayout::GetElementDesc(VertexElementType type, unsigned int offset)
{
switch (type)
{ {
glBindVertexArray(m_ArrayID); /* byte */
case Light::VertexElementType::Byte1: return { GL_BYTE, 1u, sizeof(GLbyte), offset };
case Light::VertexElementType::Byte2: return { GL_BYTE, 1u, sizeof(GLbyte), offset };
case Light::VertexElementType::Byte4: return { GL_BYTE, 1u, sizeof(GLbyte), offset };
/* ubyte */
case Light::VertexElementType::UByte1: return { GL_UNSIGNED_BYTE, 1u, sizeof(GLubyte), offset };
case Light::VertexElementType::UByte2: return { GL_UNSIGNED_BYTE, 2u, sizeof(GLubyte), offset };
case Light::VertexElementType::UByte4: return { GL_UNSIGNED_BYTE, 4u, sizeof(GLubyte), offset };
/* int */
case VertexElementType::Int1: return { GL_INT, 1u, sizeof(GLint), offset };
case VertexElementType::Int2: return { GL_INT, 2u, sizeof(GLint), offset };
case VertexElementType::Int3: return { GL_INT, 3u, sizeof(GLint), offset };
case VertexElementType::Int4: return { GL_INT, 4u, sizeof(GLint), offset };
/* uint */
case VertexElementType::UInt1: return { GL_UNSIGNED_INT, 1u, sizeof(GLuint), offset };
case VertexElementType::UInt2: return { GL_UNSIGNED_INT, 2u, sizeof(GLuint), offset };
case VertexElementType::UInt3: return { GL_UNSIGNED_INT, 3u, sizeof(GLuint), offset };
case VertexElementType::UInt4: return { GL_UNSIGNED_INT, 4u, sizeof(GLuint), offset };
/* float */
case VertexElementType::Float1: return { GL_FLOAT, 1u, sizeof(GLfloat), offset };
case VertexElementType::Float2: return { GL_FLOAT, 2u, sizeof(GLfloat), offset };
case VertexElementType::Float3: return { GL_FLOAT, 3u, sizeof(GLfloat), offset };
case VertexElementType::Float4: return { GL_FLOAT, 4u, sizeof(GLfloat), offset };
default:
ASSERT(false, "Invalid 'VertexElementType'");
return {};
} }
}
void glVertexLayout::UnBind() } // namespace Light
{
glBindVertexArray(NULL);
}
glVertexElementDesc glVertexLayout::GetElementDesc(VertexElementType type, unsigned int offset)
{
switch (type)
{
/* byte */
case Light::VertexElementType::Byte1: return { GL_BYTE, 1u, sizeof(GLbyte), offset };
case Light::VertexElementType::Byte2: return { GL_BYTE, 1u, sizeof(GLbyte), offset };
case Light::VertexElementType::Byte4: return { GL_BYTE, 1u, sizeof(GLbyte), offset };
/* ubyte */
case Light::VertexElementType::UByte1: return { GL_UNSIGNED_BYTE, 1u, sizeof(GLubyte), offset };
case Light::VertexElementType::UByte2: return { GL_UNSIGNED_BYTE, 2u, sizeof(GLubyte), offset };
case Light::VertexElementType::UByte4: return { GL_UNSIGNED_BYTE, 4u, sizeof(GLubyte), offset };
/* int */
case VertexElementType::Int1: return { GL_INT, 1u, sizeof(GLint), offset };
case VertexElementType::Int2: return { GL_INT, 2u, sizeof(GLint), offset };
case VertexElementType::Int3: return { GL_INT, 3u, sizeof(GLint), offset };
case VertexElementType::Int4: return { GL_INT, 4u, sizeof(GLint), offset };
/* uint */
case VertexElementType::UInt1: return { GL_UNSIGNED_INT, 1u, sizeof(GLuint), offset };
case VertexElementType::UInt2: return { GL_UNSIGNED_INT, 2u, sizeof(GLuint), offset };
case VertexElementType::UInt3: return { GL_UNSIGNED_INT, 3u, sizeof(GLuint), offset };
case VertexElementType::UInt4: return { GL_UNSIGNED_INT, 4u, sizeof(GLuint), offset };
/* float */
case VertexElementType::Float1: return { GL_FLOAT, 1u, sizeof(GLfloat), offset };
case VertexElementType::Float2: return { GL_FLOAT, 2u, sizeof(GLfloat), offset };
case VertexElementType::Float3: return { GL_FLOAT, 3u, sizeof(GLfloat), offset };
case VertexElementType::Float4: return { GL_FLOAT, 4u, sizeof(GLfloat), offset };
default:
LT_ENGINE_ASSERT(false, "glVertexLayout::GetElementDesc: invalid 'VertexElementType'");
return {};
}
}
}

425
Engine/src/Platform/OS/Linux/lWindow.cpp
View file

@ -1,237 +1,228 @@
#include "lWindow.h" #include "lWindow.h"
#include "Events/Event.h"
#include "Events/CharEvent.h" #include "Events/CharEvent.h"
#include "Events/MouseEvents.h" #include "Events/Event.h"
#include "Events/KeyboardEvents.h" #include "Events/KeyboardEvents.h"
#include "Events/MouseEvents.h"
#include "Events/WindowEvents.h" #include "Events/WindowEvents.h"
#include "Graphics/GraphicsContext.h" #include "Graphics/GraphicsContext.h"
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
namespace Light { namespace Light {
Scope<Window> Window::Create(std::function<void(Event&)> callback)
{
return CreateScope<lWindow>(callback);
}
lWindow::lWindow(std::function<void(Event&)> callback)
: m_Handle(nullptr),
m_EventCallback(callback)
{
// init glfw
LT_ENGINE_ASSERT(glfwInit(), "lWindow::lWindow: failed to initialize 'glfw'");
// create window
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
m_Handle = glfwCreateWindow(1u, 1u, "", nullptr, nullptr);
LT_ENGINE_ASSERT(m_Handle, "lWindow::lWindow: failed to create 'GLFWwindow'");
// bind event stuff
glfwSetWindowUserPointer(m_Handle, &m_EventCallback);
BindGlfwEvents();
// create graphics context
m_GraphicsContext = GraphicsContext::Create(GraphicsAPI::OpenGL, m_Handle);
LT_ENGINE_ASSERT(m_GraphicsContext, "lWindow::lWindow: failed to create 'GraphicsContext'");
}
lWindow::~lWindow()
{
glfwDestroyWindow(m_Handle);
}
void lWindow::PollEvents()
{
glfwPollEvents();
}
void lWindow::OnEvent(const Event& event) Scope<Window> Window::Create(std::function<void(Event&)> callback)
{
return CreateScope<lWindow>(callback);
}
lWindow::lWindow(std::function<void(Event&)> callback)
: m_Handle(nullptr), m_EventCallback(callback)
{
// init glfw
ASSERT(glfwInit(), "lWindow::lWindow: failed to initialize 'glfw'");
// create window
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
m_Handle = glfwCreateWindow(1u, 1u, "", nullptr, nullptr);
ASSERT(m_Handle, "lWindow::lWindow: failed to create 'GLFWwindow'");
// bind event stuff
glfwSetWindowUserPointer(m_Handle, &m_EventCallback);
BindGlfwEvents();
// create graphics context
m_GraphicsContext = GraphicsContext::Create(GraphicsAPI::OpenGL, m_Handle);
ASSERT(m_GraphicsContext, "lWindow::lWindow: failed to create 'GraphicsContext'");
}
lWindow::~lWindow()
{
glfwDestroyWindow(m_Handle);
}
void lWindow::PollEvents()
{
glfwPollEvents();
}
void lWindow::OnEvent(const Event& event)
{
switch (event.GetEventType())
{ {
switch (event.GetEventType()) /* closed */
case EventType::WindowClosed:
b_Closed = true;
break;
/* resized */
case EventType::WindowResized:
OnWindowResize((const WindowResizedEvent&)event);
break;
}
}
void lWindow::OnWindowResize(const WindowResizedEvent& event)
{
m_Properties.size = event.GetSize();
}
void lWindow::SetProperties(const WindowProperties& properties, bool overrideVisibility /* = false */)
{
// save the visibility status and re-assign if 'overrideVisibility' is false
bool visible = overrideVisibility ? properties.visible : m_Properties.visible;
m_Properties = properties;
m_Properties.visible = visible;
// set properties
SetTitle(properties.title);
SetSize(properties.size);
SetVSync(properties.vsync);
SetVisibility(visible);
}
void lWindow::SetTitle(const std::string& title)
{
m_Properties.title = title;
glfwSetWindowTitle(m_Handle, title.c_str());
}
void lWindow::SetSize(const glm::uvec2& size, bool additive /* = false */)
{
m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x :
size.x;
m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y :
size.y;
glfwSetWindowSize(m_Handle, size.x, size.y);
}
void lWindow::SetVSync(bool vsync, bool toggle /* = false */)
{
m_Properties.vsync = toggle ? !m_Properties.vsync : vsync;
glfwSwapInterval(m_Properties.vsync);
}
void lWindow::SetVisibility(bool visible, bool toggle)
{
m_Properties.visible = toggle ? !m_Properties.visible : visible;
if (m_Properties.visible)
glfwShowWindow(m_Handle);
else
glfwHideWindow(m_Handle);
}
void lWindow::BindGlfwEvents()
{
//============================== MOUSE_EVENTS ==============================//
/* cursor position */
glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
MouseMovedEvent event(xpos, ypos);
callback(event);
});
/* mouse button */
glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
{ {
/* closed */ ButtonPressedEvent event(button);
case EventType::WindowClosed: callback(event);
b_Closed = true;
break;
/* resized */
case EventType::WindowResized:
OnWindowResize((const WindowResizedEvent&)event);
break;
} }
} else if (action == GLFW_RELEASE)
{
void lWindow::OnWindowResize(const WindowResizedEvent& event) ButtonReleasedEvent event(button);
{ callback(event);
m_Properties.size = event.GetSize(); }
} });
void lWindow::SetProperties(const WindowProperties& properties, bool overrideVisibility /* = false */) /* scroll */
{ glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset) {
// save the visibility status and re-assign if 'overrideVisibility' is false std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
bool visible = overrideVisibility ? properties.visible : m_Properties.visible;
m_Properties = properties;
m_Properties.visible = visible;
// set properties WheelScrolledEvent event(yoffset);
SetTitle(properties.title); callback(event);
SetSize(properties.size); });
SetVSync(properties.vsync); //============================== MOUSE_EVENTS ==============================//
SetVisibility(visible);
} //============================== KEYBOARD_EVENTS ==============================//
/* key */
void lWindow::SetTitle(const std::string& title) glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
{ std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
m_Properties.title = title;
if (action == GLFW_PRESS)
glfwSetWindowTitle(m_Handle, title.c_str()); {
} KeyPressedEvent event(key);
callback(event);
void lWindow::SetSize(const glm::uvec2& size, bool additive /* = false */) }
{ else if (action == GLFW_RELEASE)
m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x : size.x; {
m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y : size.y; KeyReleasedEvent event(key);
callback(event);
}
glfwSetWindowSize(m_Handle, size.x, size.y); });
} /* char */
glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character) {
void lWindow::SetVSync(bool vsync, bool toggle /* = false */) std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
{
m_Properties.vsync = toggle ? !m_Properties.vsync : vsync; SetCharEvent event(character);
callback(event);
glfwSwapInterval(m_Properties.vsync); });
}
//============================== KEYBOARD_EVENTS ==============================//
void lWindow::SetVisibility(bool visible, bool toggle)
{ //============================== WINDOW_EVENTS ==============================//
m_Properties.visible = toggle ? !m_Properties.visible : visible; /* window position */
glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos) {
if(m_Properties.visible) std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
glfwShowWindow(m_Handle); WindowMovedEvent event(xpos, ypos);
callback(event);
});
/* window size */
glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowResizedEvent event(width, height);
callback(event);
});
/* window close */
glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowClosedEvent event;
callback(event);
});
/* window focus */
glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (focus == GLFW_TRUE)
{
WindowGainFocusEvent event;
callback(event);
}
else else
glfwHideWindow(m_Handle);
}
void lWindow::BindGlfwEvents()
{
//============================== MOUSE_EVENTS ==============================//
/* cursor position */
glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos)
{ {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window); WindowLostFocusEvent event;
MouseMovedEvent event(xpos, ypos);
callback(event); callback(event);
}); }
});
/* mouse button */ //============================== WINDOW_EVENTS ==============================//
glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods) }
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if(action == GLFW_PRESS)
{
ButtonPressedEvent event(button);
callback(event);
}
else if(action == GLFW_RELEASE)
{
ButtonReleasedEvent event(button);
callback(event);
}
});
/* scroll */
glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WheelScrolledEvent event(yoffset); } // namespace Light
callback(event);
});
//============================== MOUSE_EVENTS ==============================//
//============================== KEYBOARD_EVENTS ==============================//
/* key */
glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if(action == GLFW_PRESS)
{
KeyPressedEvent event(key);
callback(event);
}
else if(action == GLFW_RELEASE)
{
KeyReleasedEvent event(key);
callback(event);
}
});
/* char */
glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
SetCharEvent event(character);
callback(event);
});
//============================== KEYBOARD_EVENTS ==============================//
//============================== WINDOW_EVENTS ==============================//
/* window position */
glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowMovedEvent event(xpos, ypos);
callback(event);
});
/* window size */
glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowResizedEvent event(width, height);
callback(event);
});
/* window close */
glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowClosedEvent event;
callback(event);
});
/* window focus */
glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if(focus == GLFW_TRUE)
{
WindowGainFocusEvent event;
callback(event);
}
else
{
WindowLostFocusEvent event;
callback(event);
}
});
//============================== WINDOW_EVENTS ==============================//
}
}

396
Engine/src/Platform/OS/Windows/wWindow.cpp
View file

@ -1,12 +1,10 @@
#include "wWindow.h" #include "wWindow.h"
#include "Events/Event.h"
#include "Events/CharEvent.h" #include "Events/CharEvent.h"
#include "Events/MouseEvents.h" #include "Events/Event.h"
#include "Events/KeyboardEvents.h" #include "Events/KeyboardEvents.h"
#include "Events/MouseEvents.h"
#include "Events/WindowEvents.h" #include "Events/WindowEvents.h"
#include "Graphics/GraphicsContext.h" #include "Graphics/GraphicsContext.h"
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
@ -14,231 +12,223 @@
extern "C" extern "C"
{ {
// Force Machine to use Dedicated Graphics // Force Machine to use Dedicated Graphics
__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001; // NVidia __declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001; // NVidia
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1; // AMD __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1; // AMD
} }
namespace Light { namespace Light {
Scope<Window> Window::Create(std::function<void(Event&)> callback) Scope<Window> Window::Create(std::function<void(Event&)> callback)
{
return CreateScope<wWindow>(callback);
}
wWindow::wWindow(std::function<void(Event&)> callback)
: m_Handle(nullptr), m_EventCallback(callback)
{
// init glfw
ASSERT(glfwInit(), "wWindow::wWindow: failed to initialize 'glfw'");
// create window
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
m_Handle = glfwCreateWindow(1u, 1u, "", nullptr, nullptr);
ASSERT(m_Handle, "wWindow::wWindow: glfwCreateWindow: failed to create 'GLFWwindow'");
// bind event stuff
glfwSetWindowUserPointer(m_Handle, &m_EventCallback);
BindGlfwEvents();
// create graphics context
m_GraphicsContext = GraphicsContext::Create(GraphicsAPI::DirectX, m_Handle);
ASSERT(m_GraphicsContext, "wWindow::wWindow: failed to create 'GraphicsContext'");
}
wWindow::~wWindow()
{
glfwDestroyWindow(m_Handle);
}
void wWindow::PollEvents()
{
glfwPollEvents();
}
void wWindow::OnEvent(const Event& event)
{
switch (event.GetEventType())
{ {
return CreateScope<wWindow>(callback); /* closed */
case EventType::WindowClosed:
b_Closed = true;
break;
/* resized */
case EventType::WindowResized:
OnWindowResize((const WindowResizedEvent&)event);
break;
} }
}
wWindow::wWindow(std::function<void(Event&)> callback) void wWindow::OnWindowResize(const WindowResizedEvent& event)
: m_Handle(nullptr), {
m_EventCallback(callback) m_Properties.size = event.GetSize();
{ }
// init glfw
LT_ENGINE_ASSERT(glfwInit(), "wWindow::wWindow: failed to initialize 'glfw'");
// create window void wWindow::SetProperties(const WindowProperties& properties, bool overrideVisiblity /* = false */)
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); {
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5); // save the visibility status and re-assign if 'overrideVisibility' is false
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); bool visible = overrideVisiblity ? properties.visible : m_Properties.visible;
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); m_Properties = properties;
m_Properties.visible = visible;
m_Handle = glfwCreateWindow(1u, 1u, "", nullptr, nullptr); // set properties
LT_ENGINE_ASSERT(m_Handle, "wWindow::wWindow: glfwCreateWindow: failed to create 'GLFWwindow'"); SetTitle(properties.title);
SetSize(properties.size);
SetVSync(properties.vsync);
SetVisibility(visible);
}
// bind event stuff void wWindow::SetTitle(const std::string& title)
glfwSetWindowUserPointer(m_Handle, &m_EventCallback); {
BindGlfwEvents(); m_Properties.title = title;
// create graphics context glfwSetWindowTitle(m_Handle, m_Properties.title.c_str());
m_GraphicsContext = GraphicsContext::Create(GraphicsAPI::DirectX, m_Handle); }
LT_ENGINE_ASSERT(m_GraphicsContext, "wWindow::wWindow: failed to create 'GraphicsContext'");
}
wWindow::~wWindow() void wWindow::SetSize(const glm::uvec2& size, bool additive /* = false */)
{ {
glfwDestroyWindow(m_Handle); m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x :
} size.x;
m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y :
size.y;
void wWindow::PollEvents()
{
glfwPollEvents();
}
void wWindow::OnEvent(const Event& event) glfwSetWindowSize(m_Handle, size.x, size.y);
{ }
switch (event.GetEventType())
void wWindow::SetVSync(bool vsync, bool toggle /* = false */)
{
m_Properties.vsync = toggle ? !m_Properties.vsync : vsync;
glfwSwapInterval(m_Properties.vsync);
}
void wWindow::SetVisibility(bool visible, bool toggle)
{
m_Properties.visible = toggle ? !m_Properties.visible : visible;
if (m_Properties.visible)
glfwShowWindow(m_Handle);
else
glfwHideWindow(m_Handle);
}
void wWindow::BindGlfwEvents()
{
//============================== MOUSE_EVENTS ==============================//
/* cursor position */
glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
MouseMovedEvent event(xpos, ypos);
callback(event);
});
/* mouse button */
glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
{ {
/* closed */ ButtonPressedEvent event(button);
case EventType::WindowClosed: callback(event);
b_Closed = true;
break;
/* resized */
case EventType::WindowResized:
OnWindowResize((const WindowResizedEvent&)event);
break;
} }
} else if (action == GLFW_RELEASE)
{
ButtonReleasedEvent event(button);
callback(event);
}
});
void wWindow::OnWindowResize(const WindowResizedEvent& event) /* scroll */
{ glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset) {
m_Properties.size = event.GetSize(); std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
}
void wWindow::SetProperties(const WindowProperties& properties, bool overrideVisiblity /* = false */) WheelScrolledEvent event(yoffset);
{ callback(event);
// save the visibility status and re-assign if 'overrideVisibility' is false });
bool visible = overrideVisiblity ? properties.visible : m_Properties.visible; //============================== MOUSE_EVENTS ==============================//
m_Properties = properties;
m_Properties.visible = visible;
// set properties //============================== KEYBOARD_EVENTS ==============================//
SetTitle(properties.title); /* key */
SetSize(properties.size); glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
SetVSync(properties.vsync); std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
SetVisibility(visible);
}
void wWindow::SetTitle(const std::string& title) if (action == GLFW_PRESS)
{ {
m_Properties.title = title; KeyPressedEvent event(key);
callback(event);
}
else if (action == GLFW_RELEASE)
{
KeyReleasedEvent event(key);
callback(event);
}
});
/* char */
glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
glfwSetWindowTitle(m_Handle, m_Properties.title.c_str()); SetCharEvent event(character);
} callback(event);
});
void wWindow::SetSize(const glm::uvec2& size, bool additive /* = false */) //============================== KEYBOARD_EVENTS ==============================//
{
m_Properties.size.x = size.x == 0u ? m_Properties.size.x : additive ? m_Properties.size.x + size.x : size.x;
m_Properties.size.y = size.y == 0u ? m_Properties.size.y : additive ? m_Properties.size.y + size.y : size.y;
//============================== WINDOW_EVENTS ==============================//
/* window position */
glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowMovedEvent event(xpos, ypos);
glfwSetWindowSize(m_Handle, size.x, size.y); callback(event);
} });
void wWindow::SetVSync(bool vsync, bool toggle /* = false */) /* window size */
{ glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height) {
m_Properties.vsync = toggle ? !m_Properties.vsync : vsync; std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowResizedEvent event(width, height);
glfwSwapInterval(m_Properties.vsync); callback(event);
} });
void wWindow::SetVisibility(bool visible, bool toggle) /* window close */
{ glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window) {
m_Properties.visible = toggle ? !m_Properties.visible : visible; std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowClosedEvent event;
if (m_Properties.visible) callback(event);
glfwShowWindow(m_Handle); });
/* window focus */
glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus) {
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (focus == GLFW_TRUE)
{
WindowGainFocusEvent event;
callback(event);
}
else else
glfwHideWindow(m_Handle); {
} WindowLostFocusEvent event;
callback(event);
void wWindow::BindGlfwEvents() }
{ });
//============================== MOUSE_EVENTS ==============================// //============================== WINDOW_EVENTS ==============================// }
/* cursor position */ }
glfwSetCursorPosCallback(m_Handle, [](GLFWwindow* window, double xpos, double ypos) } // namespace Light
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
MouseMovedEvent event(xpos, ypos);
callback(event);
});
/* mouse button */
glfwSetMouseButtonCallback(m_Handle, [](GLFWwindow* window, int button, int action, int mods)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
{
ButtonPressedEvent event(button);
callback(event);
}
else if (action == GLFW_RELEASE)
{
ButtonReleasedEvent event(button);
callback(event);
}
});
/* scroll */
glfwSetScrollCallback(m_Handle, [](GLFWwindow* window, double xoffset, double yoffset)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WheelScrolledEvent event(yoffset);
callback(event);
});
//============================== MOUSE_EVENTS ==============================//
//============================== KEYBOARD_EVENTS ==============================//
/* key */
glfwSetKeyCallback(m_Handle, [](GLFWwindow* window, int key, int scancode, int action, int mods)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
{
KeyPressedEvent event(key);
callback(event);
}
else if (action == GLFW_RELEASE)
{
KeyReleasedEvent event(key);
callback(event);
}
});
/* char */
glfwSetCharCallback(m_Handle, [](GLFWwindow* window, unsigned int character)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
SetCharEvent event(character);
callback(event);
});
//============================== KEYBOARD_EVENTS ==============================//
//============================== WINDOW_EVENTS ==============================//
/* window position */
glfwSetWindowPosCallback(m_Handle, [](GLFWwindow* window, int xpos, int ypos)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowMovedEvent event(xpos, ypos);
callback(event);
});
/* window size */
glfwSetWindowSizeCallback(m_Handle, [](GLFWwindow* window, int width, int height)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowResizedEvent event(width, height);
callback(event);
});
/* window close */
glfwSetWindowCloseCallback(m_Handle, [](GLFWwindow* window)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
WindowClosedEvent event;
callback(event);
});
/* window focus */
glfwSetWindowFocusCallback(m_Handle, [](GLFWwindow* window, int focus)
{
std::function<void(Event&)> callback = *(std::function<void(Event&)>*)glfwGetWindowUserPointer(window);
if (focus == GLFW_TRUE)
{
WindowGainFocusEvent event;
callback(event);
}
else
{
WindowLostFocusEvent event;
callback(event);
}
});
//============================== WINDOW_EVENTS ==============================// }
}
}

2
Mirror/src/EditorLayer.cpp
View file

@ -27,7 +27,7 @@ EditorLayer::EditorLayer(const std::string& name, const std::vector<std::string>
else else
{ {
SceneSerializer serializer(m_Scene); SceneSerializer serializer(m_Scene);
LT_ENGINE_ASSERT(serializer.Deserialize(m_SceneDir), "EditorLayer::EditorLayer: failed to de-serialize: ", m_SceneDir); ASSERT(serializer.Deserialize(m_SceneDir), "Failed to de-serialize: {}", m_SceneDir);
m_CameraEntity = m_Scene->GetEntityByTag("Game Camera"); m_CameraEntity = m_Scene->GetEntityByTag("Game Camera");
} }

3
Mirror/src/EditorLayer.cpp~
View file

@ -1,5 +1,4 @@
#include "EditorLayer.h" #include "EditorLayer.h"
#include "Utility/Serializer.h" #include "Utility/Serializer.h"
namespace Light { namespace Light {
@ -27,7 +26,7 @@ EditorLayer::EditorLayer(const std::string& name, const std::vector<std::string>
else else
{ {
SceneSerializer serializer(m_Scene); SceneSerializer serializer(m_Scene);
LT_ENGINE_ASSERT(serializer.Deserialize(m_SceneDir), "EditorLayer::EditorLayer: failed to de-serialize: ", m_SceneDir); ASSERT(serializer.Deserialize(m_SceneDir), "EditorLayer::EditorLayer: failed to de-serialize: ", m_SceneDir);
m_CameraEntity = m_Scene->GetEntityByTag("Game Camera"); m_CameraEntity = m_Scene->GetEntityByTag("Game Camera");
} }

2
Mirror/src/Panels/ContentBrowser.cpp
View file

@ -38,7 +38,6 @@ void AssetBrowserPanel::OnUserInterfaceUpdate()
m_DirectoryTexture->Bind(0u); m_DirectoryTexture->Bind(0u);
for (auto& dirEntry : std::filesystem::directory_iterator(m_CurrentDirectory)) for (auto& dirEntry : std::filesystem::directory_iterator(m_CurrentDirectory))
{ {
LT_ENGINE_TRACE("File: ", dirEntry.path().string());
AssetType assetType; AssetType assetType;
std::string extension = dirEntry.path().extension().string(); std::string extension = dirEntry.path().extension().string();
@ -71,7 +70,6 @@ void AssetBrowserPanel::OnUserInterfaceUpdate()
if (ImGui::ImageButton(m_DirectoryTexture->GetTexture(), ImVec2(m_FileSize, m_FileSize), ImVec2 { 0.0f, 0.0f }, ImVec2 { 1.0f, 1.0f }, 0, ImVec4 { 0.0f, 0.0f, 0.0f, 0.0f }, ImVec4 { 1.0f, 1.0f, 1.0f, 1.0f })) if (ImGui::ImageButton(m_DirectoryTexture->GetTexture(), ImVec2(m_FileSize, m_FileSize), ImVec2 { 0.0f, 0.0f }, ImVec2 { 1.0f, 1.0f }, 0, ImVec4 { 0.0f, 0.0f, 0.0f, 0.0f }, ImVec4 { 1.0f, 1.0f, 1.0f, 1.0f }))
{ {
m_CurrentDirectory /= path.filename(); m_CurrentDirectory /= path.filename();
LT_ENGINE_INFO(path.filename().string());
} }
break; break;