graphicsserver.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "core/refcounted.h"
#include "framesync/framesynctimer.h"
#include "util/stringatom.h"
#include "ids/idgenerationpool.h"
#include "graphicsentity.h"
#include "coregraphics/graphicsdevice.h"
#include "coregraphics/displaydevice.h"
#include "coregraphics/shaderserver.h"
#include "coregraphics/shaperenderer.h"
#include "coregraphics/textrenderer.h"
#include "graphics/view.h"
#include "debug/debughandler.h"
 
namespace CoreGraphics
{
class MeshLoader;
class GPULangShaderLoader;
class TextureLoader;
}
 
namespace Models
{
class ModelLoader;
}
 
namespace Materials
{
class MaterialLoader;
}
 
namespace CoreAnimation
{
class AnimationLoader;
}
 
namespace Characters
{
class SkeletonLoader;
}
 
namespace Particles
{
class ParticleLoader;
}
 
namespace Graphics
{
 
struct FrameContext
{
    Timing::Time time;
    Timing::Tick ticks;
    Timing::Time frameTime;
    IndexT frameIndex;
    IndexT bufferIndex;
};
 
using ViewIndependentCall = void(*)(const Graphics::FrameContext& ctx);
using ViewDependentCall = void(*)(const ViewId view, const Graphics::FrameContext& ctx);
 
 
class GraphicsContext;
struct GraphicsContextFunctionBundle;
struct GraphicsContextState;
struct ViewId;
class GraphicsServer : public Core::RefCounted
{
    __DeclareClass(GraphicsServer);
    __DeclareSingleton(GraphicsServer);
public:
    GraphicsServer();
    virtual ~GraphicsServer();

    void Open();
    void Close();

    GraphicsEntityId CreateGraphicsEntity();
    void DiscardGraphicsEntity(const GraphicsEntityId id);
    bool IsValidGraphicsEntity(const GraphicsEntityId id);

    Graphics::ViewId CreateView(
        const Util::StringAtom& name
        , bool(*renderFunction)(const Math::rectangle<int>&, IndexT, IndexT)
        , const Math::rectangle<int>& viewport
        , Graphics::StageMask stageMask = PRIMARY_STAGE_MASK
        , std::function<void(IndexT, IndexT)> preViewCallback = nullptr
        , std::function<void(IndexT, IndexT)> postViewCallback = nullptr
    );
    Graphics::ViewId CreateView(const Util::StringAtom& name);
    const Graphics::ViewId GetView(const Util::StringAtom& name);
    void DiscardView(const Graphics::ViewId view);
    const Graphics::ViewId GetCurrentView() const;
    void SetCurrentView(const Graphics::ViewId view);

    void AddEndFrameCall(void(*func)(IndexT frameIndex, IndexT bufferIndex));
    void SetResizeCall(void(*)(const SizeT, const SizeT));

    void AddWindow(const CoreGraphics::WindowId window);
    void RemoveWindow(const CoreGraphics::WindowId window);
    const Util::Array<CoreGraphics::WindowId>& GetWindows() const;

    void SetupPreLogicCalls(const Util::Array<ViewIndependentCall>& calls);
    void SetupPostLogicCalls(const Util::Array<ViewIndependentCall>& calls);
    void SetupPreLogicViewCalls(const Util::Array<ViewDependentCall>& calls);
    void SetupPostLogicViewCalls(const Util::Array<ViewDependentCall>& calls);

    void RunPreLogic();
    void RunPostLogic();
    void Render();

    void EndFrame();
    void NewFrame();

    const Timing::Time GetTime() const;
    const Timing::Time GetFrameTime() const;
    const IndexT GetFrameIndex() const;

    void RenderDebug(uint32_t flags);

    void RegisterGraphicsContext(GraphicsContextFunctionBundle* context, GraphicsContextState* state);
    void UnregisterGraphicsContext(GraphicsContextFunctionBundle* context);
    
    bool OnWindowResized(CoreGraphics::WindowId wndId);
 
private:
 
    Ids::IdGenerationPool entityPool;
 
    Ptr<FrameSync::FrameSyncTimer> timer;
    bool ownsTimer;
    FrameContext frameContext;
 
    Util::Array<GraphicsContextFunctionBundle*> contexts;
    Util::Array<GraphicsContextState*> states;
 
    Util::Dictionary<Util::StringAtom, Graphics::ViewId> viewsByName;
    Util::Array<Graphics::ViewId> views;
    Graphics::ViewId currentView;
 
    Util::Array<std::function<void(IndexT, IndexT)>> preViewCallbacks;
    Util::Array<std::function<void(IndexT, IndexT)>> postViewCallbacks;
    Util::Array<std::function<void(IndexT, IndexT)>> endFrameCallbacks;
 
    void (*resizeCall) (const SizeT, const SizeT);
 
    Ptr<CoreGraphics::DisplayDevice> displayDevice;
    bool graphicsDevice;
    Ptr<CoreGraphics::ShaderServer> shaderServer;
    Ptr<CoreGraphics::ShapeRenderer> shapeRenderer;
    Ptr<CoreGraphics::TextRenderer> textRenderer;
 
    Ptr<CoreGraphics::GPULangShaderLoader> shaderLoader;
    Ptr<Models::ModelLoader> modelLoader;
    Ptr<CoreGraphics::MeshLoader> meshLoader;
    Ptr<CoreGraphics::TextureLoader> textureLoader;
    Ptr<Materials::MaterialLoader> materialLoader;
    Ptr<CoreAnimation::AnimationLoader> animationLoader;
    Ptr<Characters::SkeletonLoader> skeletonLoader;
    Ptr<Particles::ParticleLoader> particleLoader;
 
    Util::Array<ViewIndependentCall> preLogicCalls, postLogicCalls;
    Util::Array<ViewDependentCall> preLogicViewCalls, postLogicViewCalls;
 
    Util::Array<CoreGraphics::WindowId> windows;
    SizeT maxWindowWidth, maxWindowHeight;
 
    bool isOpen;
};
 
//------------------------------------------------------------------------------
static GraphicsEntityId
CreateEntity()
{
    return GraphicsServer::Instance()->CreateGraphicsEntity();
}
 
//------------------------------------------------------------------------------
static void
DestroyEntity(const GraphicsEntityId id)
{
    GraphicsServer::Instance()->DiscardGraphicsEntity(id);
}
 
//------------------------------------------------------------------------------
template<typename ... CONTEXTS>
static void
RegisterEntity(const GraphicsEntityId id)
{
    (CONTEXTS::RegisterEntity(id), ...);
}
 
//------------------------------------------------------------------------------
template<typename ... CONTEXTS>
static void
DeregisterEntity(const GraphicsEntityId id)
{
    (CONTEXTS::DeregisterEntity(id), ...);
}
 
//------------------------------------------------------------------------------
template<typename ... CONTEXTS>
static void
DeregisterEntityImmediate(const GraphicsEntityId id)
{
    (CONTEXTS::DeregisterEntityImmediate(id), ...);
}
 
//------------------------------------------------------------------------------
inline void 
GraphicsServer::SetResizeCall(void(*func)(const SizeT windowWidth, const SizeT windowHeight))
{
    this->resizeCall = func;
}
 
//------------------------------------------------------------------------------
inline void
GraphicsServer::SetupPreLogicCalls(const Util::Array<ViewIndependentCall>& calls)
{
    this->preLogicCalls = calls;
}
 
//------------------------------------------------------------------------------
inline void
GraphicsServer::SetupPostLogicCalls(const Util::Array<ViewIndependentCall>& calls)
{
    this->postLogicCalls = calls;
}
 
//------------------------------------------------------------------------------
inline void
GraphicsServer::SetupPreLogicViewCalls(const Util::Array<ViewDependentCall>& calls)
{
    this->preLogicViewCalls = calls;
}
 
//------------------------------------------------------------------------------
inline void
GraphicsServer::SetupPostLogicViewCalls(const Util::Array<ViewDependentCall>& calls)
{
    this->postLogicViewCalls = calls;
}
 
//------------------------------------------------------------------------------
inline const Timing::Time 
GraphicsServer::GetTime() const
{
    return this->frameContext.time;
}
 
//------------------------------------------------------------------------------
inline const Timing::Time
GraphicsServer::GetFrameTime() const
{
    return this->frameContext.frameTime;
}
 
//------------------------------------------------------------------------------
inline const IndexT
GraphicsServer::GetFrameIndex() const
{
    return this->frameContext.frameIndex;
}
 
 
 
} // namespace Graphics