visibilitycontext.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "graphics/graphicscontext.h"
#include "visibility.h"
#include "jobs/jobs.h"
#include "visibility/systems/visibilitysystem.h"
#include "models/model.h"
#include "models/nodes/shaderstatenode.h"
#include "materials/gpulang/materialtemplatesgpulang.h"
#include "memory/arenaallocator.h"
#include "math/clipstatus.h"
#include "coregraphics/mesh.h"
 
namespace Models
{
    class ModelContext;
}
 
namespace Visibility
{
 
 
class ObserverContext : public Graphics::GraphicsContext
{
    __DeclareContext();
public:

    static void Setup(const Graphics::GraphicsEntityId id, VisibilityEntityType entityType, Graphics::StageMask stageMask = 0xFFFF, bool isOrtho = false);

    static void RunVisibilityTests(const Graphics::FrameContext& ctx);
    static void GenerateDrawLists(const Graphics::FrameContext& ctx);

    static void Create();
    static void Discard();

    static VisibilitySystem* CreateBoxSystem(const BoxSystemLoadInfo& info);
    static VisibilitySystem* CreatePortalSystem(const PortalSystemLoadInfo& info);
    static VisibilitySystem* CreateOctreeSystem(const OctreeSystemLoadInfo& info);
    static VisibilitySystem* CreateQuadtreeSystem(const QuadtreeSystemLoadInfo& info);
    static VisibilitySystem* CreateBruteforceSystem(const BruteforceSystemLoadInfo& info);

    static void WaitForVisibility(const Graphics::FrameContext& ctx);
 
#ifndef PUBLIC_BUILD
    static void OnRenderDebug(uint32_t flags);
#endif
 
    typedef Ids::Id32 ModelAllocId;
 
    struct VisibilityModelCommand
    {
        uint32_t offset;
        CoreGraphics::MeshId mesh;
        Materials::MaterialId material;
 
#if NEBULA_GRAPHICS_DEBUG
        Util::StringAtom nodeName;
#endif
    };
 
    struct VisibilityDrawCommand
    {
        CoreGraphics::PrimitiveGroup primitiveGroup;
        uint32_t offset;
        uint32_t numInstances;
        uint32_t baseInstance;
    };
 
    struct VisibilityBatchCommand
    {
        uint32_t packetOffset;
        uint32_t numDrawPackets;
        Util::Array<VisibilityModelCommand, 256> models;
        Util::Array<VisibilityDrawCommand, 1024> draws;
    };
 
    struct VisibilityDrawList
    {
        Util::HashTable<const MaterialTemplatesGPULang::Entry*, VisibilityBatchCommand> visibilityTable;
        Util::Array<Models::ShaderStateNode::DrawPacket*> drawPackets;
    };

    static const VisibilityDrawList* GetVisibilityDrawList(const Graphics::GraphicsEntityId id);
 
    static Jobs::JobSyncId jobInternalSync;
    static Jobs::JobSyncId jobInternalSync2;
    static Jobs::JobSyncId jobInternalSync3;
    static Jobs::JobSyncId jobHostSync;
    static Util::Queue<Jobs::JobId> runningJobs;
 
private:
 
    friend class ObservableContext;
    friend struct ObservableGlobalState;
    typedef Util::Array<Math::ClipStatus::Type> VisibilityResultArray;
 
    enum
    {
        Observer_IsOrtho,
        Observer_EntityId,
        Observer_EntityType,
        Observer_StageMask,
        Observer_ResultArray,
        Observer_DrawList,
        Observer_DrawListAllocator,
        Observer_IndexBuffer,
        Observer_IndexedClipStatuses
    };
 
    typedef Ids::IdAllocator<
        bool                                     // observer is an orthogonal camera
        , Graphics::GraphicsEntityId               // entity id
        , VisibilityEntityType                     // type of object so we know how to get the transform
        , Graphics::StageMask                      // mask for visibility
        , VisibilityResultArray                    // visibility lookup table
        , VisibilityDrawList                       // draw list
        , Memory::ArenaAllocator<1024>             // memory allocator for draw commands
        , Util::FixedArray<uint64_t>               // index buffer
        , Util::FixedArray<Math::ClipStatus::Type> // clip statuses
    > ObserverAllocator;
    static ObserverAllocator observerAllocator;

    static Graphics::ContextEntityId Alloc();
    static void Dealloc(Graphics::ContextEntityId id);
    
    static Util::Array<VisibilitySystem*> systems;
};
 
class ObservableContext : public Graphics::GraphicsContext
{
    __DeclareContext();
public:

    static void Setup(const Graphics::GraphicsEntityId id, VisibilityEntityType entityType);

    static void Create();
private:
 
    friend class ObserverContext;
    friend class Models::ModelContext;
 
    enum
    {
        Observable_EntityId,
        Observable_NumNodes
    };
 
    // observable corresponds to a single entity
    typedef Ids::IdAllocator<
        Graphics::GraphicsEntityId, // The entity id that this component is bound to
        uint32_t                      // Node instance range
    > ObservableAllocator;
 
    static ObservableAllocator observableAllocator;

    static Graphics::ContextEntityId Alloc();
    static void Dealloc(Graphics::ContextEntityId id);
};
 
} // namespace Visibility