sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OpenGL: Link contexts to device

This commit is contained in:
Lynix 2020-04-19 15:33:36 +02:00
parent bd6924d66d
commit 349e915e10
12 changed files with 78 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/Nazara/OpenGLRenderer/OpenGLDevice.hpp
View File

@ -12,12 +12,15 @@
#include <Nazara/OpenGLRenderer/Config.hpp>
#include <Nazara/OpenGLRenderer/Wrapper/Context.hpp>
#include <Nazara/Renderer/RenderDevice.hpp>
#include <unordered_set>
#include <vector>
namespace Nz
{
class NAZARA_OPENGLRENDERER_API OpenGLDevice : public RenderDevice
{
friend GL::Context;
public:
OpenGLDevice(GL::Loader& loader);
OpenGLDevice(const OpenGLDevice&) = delete;
@ -37,11 +40,16 @@ namespace Nz
std::unique_ptr<Texture> InstantiateTexture(const TextureInfo& params) override;
std::unique_ptr<TextureSampler> InstantiateTextureSampler(const TextureSamplerInfo& params) override;
inline void NotifyTextureDestruction(GLuint texture) const;
OpenGLDevice& operator=(const OpenGLDevice&) = delete;
OpenGLDevice& operator=(OpenGLDevice&&) = delete; ///TODO?
private:
inline void NotifyContextDestruction(const GL::Context& context) const;
std::unique_ptr<GL::Context> m_referenceContext;
mutable std::unordered_set<const GL::Context*> m_contexts;
GL::Loader& m_loader;
};
}

11
include/Nazara/OpenGLRenderer/OpenGLDevice.inl
View File

@ -11,6 +11,17 @@ namespace Nz
{
return *m_referenceContext;
}
inline void OpenGLDevice::NotifyTextureDestruction(GLuint texture) const
{
for (const GL::Context* context : m_contexts)
context->NotifyTextureDestruction(texture);
}
inline void OpenGLDevice::NotifyContextDestruction(const GL::Context& context) const
{
m_contexts.erase(&context);
}
}
#include <Nazara/OpenGLRenderer/DebugOff.hpp>

10
include/Nazara/OpenGLRenderer/Wrapper/Context.hpp
View File

@ -14,6 +14,11 @@
#include <string>
#include <unordered_set>
namespace Nz
{
class OpenGLDevice;
}
namespace Nz::GL
{
enum class ContextType
@ -55,13 +60,13 @@ namespace Nz::GL
class Context
{
public:
Context() = default;
inline Context(const OpenGLDevice* device);
virtual ~Context();
virtual bool Activate() = 0;
virtual void EnableVerticalSync(bool enabled) = 0;
inline const OpenGLDevice* GetDevice() const;
inline ExtensionStatus GetExtensionStatus(Extension extension) const;
inline const ContextParams& GetParams() const;
@ -95,6 +100,7 @@ namespace Nz::GL
std::array<ExtensionStatus, UnderlyingCast(Extension::Max) + 1> m_extensionStatus;
std::unordered_set<std::string> m_supportedExtensions;
const OpenGLDevice* m_device;
};
}

9
include/Nazara/OpenGLRenderer/Wrapper/Context.inl
View File

@ -7,6 +7,15 @@
namespace Nz::GL
{
inline Context::Context(const OpenGLDevice* device) :
m_device(device)
{
}
inline const OpenGLDevice* Context::GetDevice() const
{
return m_device;
}
inline ExtensionStatus Context::GetExtensionStatus(Extension extension) const
{

9
include/Nazara/OpenGLRenderer/Wrapper/Loader.hpp
View File

@ -13,6 +13,11 @@
#include <Nazara/OpenGLRenderer/Wrapper/Context.hpp>
#include <memory>
namespace Nz
{
class OpenGLDevice;
}
namespace Nz::GL
{
class Context;
@ -25,8 +30,8 @@ namespace Nz::GL
Loader() = default;
virtual ~Loader();
virtual std::unique_ptr<Context> CreateContext(const ContextParams& params, Context* shareContext = nullptr) const = 0;
virtual std::unique_ptr<Context> CreateContext(const ContextParams& params, WindowHandle handle, Context* shareContext = nullptr) const = 0;
virtual std::unique_ptr<Context> CreateContext(const OpenGLDevice* device, const ContextParams& params, Context* shareContext = nullptr) const = 0;
virtual std::unique_ptr<Context> CreateContext(const OpenGLDevice* device, const ContextParams& params, WindowHandle handle, Context* shareContext = nullptr) const = 0;
virtual GLFunction LoadFunction(const char* name) const = 0;
};

2
include/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.hpp
View File

@ -26,7 +26,7 @@ namespace Nz::GL
class WGLContext : public Context
{
public:
WGLContext(const WGLLoader& loader);
inline WGLContext(const OpenGLDevice* device, const WGLLoader& loader);
WGLContext(const WGLContext&) = delete;
WGLContext(WGLContext&&) = delete;
~WGLContext();

6
include/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.inl
View File

@ -7,6 +7,12 @@
namespace Nz::GL
{
inline GL::WGLContext::WGLContext(const OpenGLDevice* device, const WGLLoader& loader) :
Context(device),
m_loader(loader)
{
}
inline bool WGLContext::HasPlatformExtension(const std::string& str) const
{
return m_supportedPlatformExtensions.find(str) != m_supportedPlatformExtensions.end();

4
include/Nazara/OpenGLRenderer/Wrapper/Win32/WGLLoader.hpp
View File

@ -24,8 +24,8 @@ namespace Nz::GL
WGLLoader(DynLib& openglLib);
~WGLLoader() = default;
std::unique_ptr<Context> CreateContext(const ContextParams& params, Context* shareContext) const override;
std::unique_ptr<Context> CreateContext(const ContextParams& params, WindowHandle handle, Context* shareContext) const override;
std::unique_ptr<Context> CreateContext(const OpenGLDevice* device, const ContextParams& params, Context* shareContext) const override;
std::unique_ptr<Context> CreateContext(const OpenGLDevice* device, const ContextParams& params, WindowHandle handle, Context* shareContext) const override;
GLFunction LoadFunction(const char* name) const override;

14
src/Nazara/OpenGLRenderer/OpenGLDevice.cpp
View File

@ -14,21 +14,29 @@ namespace Nz
OpenGLDevice::OpenGLDevice(GL::Loader& loader) :
m_loader(loader)
{
m_referenceContext = loader.CreateContext({});
m_referenceContext = loader.CreateContext(this, {});
if (!m_referenceContext)
throw std::runtime_error("failed to create reference context");
m_contexts.insert(m_referenceContext.get());
}
OpenGLDevice::~OpenGLDevice() = default;
std::unique_ptr<GL::Context> OpenGLDevice::CreateContext(const GL::ContextParams& params) const
{
return m_loader.CreateContext(params, m_referenceContext.get());
auto contextPtr = m_loader.CreateContext(this, params, m_referenceContext.get());
m_contexts.insert(contextPtr.get());
return contextPtr;
}
std::unique_ptr<GL::Context> OpenGLDevice::CreateContext(const GL::ContextParams& params, WindowHandle handle) const
{
return m_loader.CreateContext(params, handle, m_referenceContext.get());
auto contextPtr = m_loader.CreateContext(this, params, handle, m_referenceContext.get());
m_contexts.insert(contextPtr.get());
return contextPtr;
}
std::unique_ptr<AbstractBuffer> OpenGLDevice::InstantiateBuffer(BufferType type)

9
src/Nazara/OpenGLRenderer/Wrapper/Context.cpp
View File

@ -4,8 +4,11 @@
#include <Nazara/OpenGLRenderer/Wrapper/Context.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/Core/StringExt.hpp>
#include <Nazara/OpenGLRenderer/OpenGLDevice.hpp>
#include <Nazara/OpenGLRenderer/Wrapper/Loader.hpp>
#include <sstream>
#include <stdexcept>
#include <Nazara/OpenGLRenderer/Debug.hpp>
@ -13,6 +16,12 @@ namespace Nz::GL
{
thread_local const Context* s_currentContext = nullptr;
Context::~Context()
{
if (m_device)
m_device->NotifyContextDestruction(*this);
}
bool Context::Initialize(const ContextParams& params)
{

5
src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLContext.cpp
View File

@ -12,11 +12,6 @@
namespace Nz::GL
{
GL::WGLContext::WGLContext(const WGLLoader& loader) :
m_loader(loader)
{
}
WGLContext::~WGLContext()
{
Destroy();

12
src/Nazara/OpenGLRenderer/Wrapper/Win32/WGLLoader.cpp
View File

@ -11,7 +11,7 @@ namespace Nz::GL
{
WGLLoader::WGLLoader(DynLib& openglLib) :
m_opengl32Lib(openglLib),
m_baseContext(*this)
m_baseContext(nullptr, *this)
{
if (!m_gdi32Lib.Load("gdi32.dll"))
throw std::runtime_error("failed to load gdi32.dll: " + m_gdi32Lib.GetLastError());
@ -42,7 +42,7 @@ namespace Nz::GL
#undef NAZARA_OPENGLRENDERER_EXT_FUNC
// In order to load OpenGL functions, we have to create a context first
WGLContext loadContext(*this);
WGLContext loadContext(nullptr, *this);
if (!loadContext.Create(nullptr, {}))
throw std::runtime_error("failed to create load context");
@ -56,9 +56,9 @@ namespace Nz::GL
throw std::runtime_error("failed to load OpenGL functions");
}
std::unique_ptr<Context> WGLLoader::CreateContext(const ContextParams& params, Context* shareContext) const
std::unique_ptr<Context> WGLLoader::CreateContext(const OpenGLDevice* device, const ContextParams& params, Context* shareContext) const
{
auto context = std::make_unique<WGLContext>(*this);
auto context = std::make_unique<WGLContext>(device, *this);
if (!context->Create(&m_baseContext, params, static_cast<WGLContext*>(shareContext)))
{
NazaraError("failed to create context");
@ -74,9 +74,9 @@ namespace Nz::GL
return context;
}
std::unique_ptr<Context> WGLLoader::CreateContext(const ContextParams& params, WindowHandle handle, Context* shareContext) const
std::unique_ptr<Context> WGLLoader::CreateContext(const OpenGLDevice* device, const ContextParams& params, WindowHandle handle, Context* shareContext) const
{
auto context = std::make_unique<WGLContext>(*this);
auto context = std::make_unique<WGLContext>(device, *this);
if (!context->Create(&m_baseContext, params, handle, static_cast<WGLContext*>(shareContext)))
{
NazaraError("failed to create context");