pass.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------    
//------------------------------------------------------------------------------
#include "ids/id.h"
#include "ids/idpool.h"
#include "ids/idallocator.h"
#include "frame/framebatchtype.h"
#include "coregraphics/textureview.h"
 
namespace Shared
{
struct RenderTargetParameters;
}
 
namespace CoreGraphics
{
 
struct ResourceTableId;
struct TextureView;
ID_24_8_TYPE(PassId);
ID_24_8_TYPE(RenderPassId);
 
enum class AttachmentFlagBits : uint16_t
{
    NoFlags = 0,
    Clear               = N_BIT(0),
    ClearStencil        = N_BIT(1),
    Load                = N_BIT(2),
    LoadStencil         = N_BIT(3),
    Store               = N_BIT(4),
    StoreStencil        = N_BIT(6),
    Discard             = N_BIT(7),
    DiscardStencil      = N_BIT(8),
};
__ImplementEnumBitOperators(AttachmentFlagBits);
__ImplementEnumComparisonOperators(AttachmentFlagBits);
 
static AttachmentFlagBits 
AttachmentFlagsFromString(const Util::String& string)
{
    Util::Array<Util::String> bits = string.Tokenize("|");
 
    AttachmentFlagBits ret = AttachmentFlagBits::NoFlags;
    for (IndexT i = 0; i < bits.Size(); i++)
    {
        if (bits[i] == "Load")                  ret |= AttachmentFlagBits::Load;
        else if (bits[i] == "LoadStencil")      ret |= AttachmentFlagBits::LoadStencil;
        else if (bits[i] == "Store")            ret |= AttachmentFlagBits::Store;
        else if (bits[i] == "StoreStencil")     ret |= AttachmentFlagBits::StoreStencil;
        else if (bits[i] == "Discard")          ret |= AttachmentFlagBits::Discard;
        else if (bits[i] == "DiscardStencil")   ret |= AttachmentFlagBits::DiscardStencil;
    }
    return ret;
};
 
struct Subpass
{
    Util::Array<IndexT> attachments;
    Util::Array<IndexT> resolves;
    Util::Array<IndexT> dependencies;
    Util::Array<IndexT> inputs;
    IndexT depthResolve;
    IndexT depth;
    SizeT numViewports;
    SizeT numScissors;
 
    Subpass() : depthResolve(InvalidIndex), depth(InvalidIndex), numViewports(0), numScissors(0) {};
};
 
struct PassCreateInfo
{
    Util::StringAtom name;
 
    Util::Array<CoreGraphics::TextureViewId> attachments;
    Util::Array<AttachmentFlagBits> attachmentFlags; 
    Util::Array<Math::vec4> attachmentClears;
    Util::Array<bool> attachmentDepthStencil;
    
    Util::Array<Subpass> subpasses;
 
    PassCreateInfo() {};
};
 
enum class PassRecordMode : uint8_t
{
    Record,
    ExecuteRecorded,
    ExecuteInline
};

const PassId CreatePass(const PassCreateInfo& info);
void DestroyPass(const PassId id);

void PassWindowResizeCallback(const PassId id);
void PassSetRenderTargetParameters(const PassId id, const Util::FixedArray<Shared::RenderTargetParameters>& viewports);

const Util::Array<CoreGraphics::TextureViewId>& PassGetAttachments(const CoreGraphics::PassId id);

const uint32_t PassGetNumSubpassAttachments(const CoreGraphics::PassId id, const IndexT subpass);
const CoreGraphics::ResourceTableId PassGetResourceTable(const CoreGraphics::PassId id);

const Util::StringAtom PassGetName(const CoreGraphics::PassId id);
 
struct RenderPassCreateInfo
{
    Util::StringAtom name;
    Math::rectangle<int> area;
    SizeT layerCount = 1;
    Util::FixedArray<CoreGraphics::TextureViewId> colorTargets;
    Util::FixedArray<CoreGraphics::ImageLayout> colorTargetLayouts;
    Util::FixedArray<CoreGraphics::AttachmentFlagBits> colorTargetFlags;
    Util::FixedArray<CoreGraphics::TextureViewId> resolveTargets;
    Util::FixedArray<CoreGraphics::ImageLayout> resolveLayouts;
    Util::FixedArray<Math::vec4> colorClearValues;
 
    CoreGraphics::TextureViewId depthTarget = CoreGraphics::InvalidTextureViewId;
    CoreGraphics::ImageLayout depthTargetLayout = CoreGraphics::ImageLayout::Undefined;
    CoreGraphics::TextureViewId depthResolveTarget = CoreGraphics::InvalidTextureViewId;
    CoreGraphics::ImageLayout depthResolveTargetLayout = CoreGraphics::ImageLayout::Undefined;
    CoreGraphics::AttachmentFlagBits depthFlags = CoreGraphics::AttachmentFlagBits::NoFlags;
    Math::vec4 depthClearValue;
};

const RenderPassId CreateRenderPass(const RenderPassCreateInfo& info);
void DestroyRenderPass(RenderPassId pass);
void RenderPassSetRenderTargetParameters(const CoreGraphics::CmdBufferId cmdBuf, const RenderPassId id, const Util::FixedArray<Shared::RenderTargetParameters>& viewports);
const SizeT RenderPassGetNumSamples(const RenderPassId id);
 
} // namespace CoreGraphics