shader.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "ids/id.h"
#include "ids/idpool.h"
#include "resources/resourceid.h"
#include "coregraphics/shaderfeature.h"
#include "coregraphics/buffer.h"
#include "util/variant.h"
#include "util/dictionary.h"
#include "api/loader.h"
 
namespace CoreGraphics
{
 
struct TextureId;
struct ShaderRWBufferId;
struct ResourceTableId;
struct ResourceTableLayoutId;
struct ResourcePipelineId;
struct ResourceTableSet;
 
RESOURCE_ID_TYPE(ShaderId);             
ID_24_8_24_8_NAMED_TYPE(ShaderProgramId, programId, programGeneration, shaderId, shaderGeneration, program, shader);     // 32 bits shader, 24 bits program, 8 bits type
 
ID_32_TYPE(DerivativeStateId);          // 32 bits derivative state (already created from an ordinary state)
 
struct GPULangShaderCreateInfo
{
    Resources::ResourceName name;
    GPULang::Loader* loader;
};
 
enum ShaderConstantType
{
    UnknownVariableType,
    IntVariableType,
    FloatVariableType,
    VectorVariableType,     // vec4
    Vector2VariableType,    // vec2
    MatrixVariableType,
    BoolVariableType,
    TextureVariableType,
    SamplerVariableType,
    ConstantBufferVariableType,
    ImageReadWriteVariableType,
    BufferReadWriteVariableType,
    TextureHandleType,      // just a uint
    ImageHandleType,        // just a uint
    SamplerHandleType       // just a uint
};
 

const Util::String ConstantTypeToString(const ShaderConstantType& type);

const ShaderId CreateShader(const GPULangShaderCreateInfo& info);
void DestroyShader(const ShaderId id);
 
#if WITH_NEBULA_EDITOR
bool ReloadShader(const ShaderId id, const GPULangShaderCreateInfo& info);
#endif

const ShaderId ShaderGet(const Resources::ResourceName& name);
CoreGraphics::ShaderFeature::Mask ShaderFeatureMask(const Util::String& mask);

const ResourceTableId ShaderCreateResourceTable(const ShaderId id, const IndexT group, const uint overallocationSize = 1, const char* name = nullptr);
ResourceTableSet ShaderCreateResourceTableSet(const ShaderId id, const IndexT group, const uint overallocationSize = 1, const char* name = nullptr);
const bool ShaderHasResourceTable(const ShaderId id, const IndexT group);
const BufferId ShaderCreateConstantBuffer(const ShaderId id, const Util::StringAtom& name, BufferAccessMode mode = BufferAccessMode::HostCached);
const BufferId ShaderCreateConstantBuffer(const ShaderId id, const IndexT cbIndex, BufferAccessMode mode = BufferAccessMode::HostCached);
const BufferId ShaderCreateConstantBuffer(const ShaderId id, const IndexT group, const IndexT cbIndex, BufferAccessMode mode = BufferAccessMode::HostCached);
const uint ShaderCalculateConstantBufferIndex(const uint64_t bindingMask, const IndexT slot);

const Resources::ResourceName ShaderGetName(const ShaderId id);
const SizeT ShaderGetConstantCount(const ShaderId id);
const ShaderConstantType ShaderGetConstantType(const ShaderId id, const IndexT i);
const ShaderConstantType ShaderGetConstantType(const ShaderId id, const Util::StringAtom& name);
const Util::StringAtom ShaderGetConstantName(const ShaderId id, const IndexT i);
const Util::StringAtom ShaderGetConstantBlockName(const ShaderId id, const Util::StringAtom& name);
const Util::StringAtom ShaderGetConstantBlockName(const ShaderId id, const IndexT cIndex);
const IndexT ShaderGetConstantGroup(const ShaderId id, const Util::StringAtom& name);
const IndexT ShaderGetConstantSlot(const ShaderId id, const Util::StringAtom& name);

CoreGraphics::ResourceTableLayoutId ShaderGetResourceTableLayout(const ShaderId id, const IndexT group);
CoreGraphics::ResourcePipelineId ShaderGetResourcePipeline(const ShaderId id);

const SizeT ShaderGetConstantBufferCount(const ShaderId id);
const SizeT ShaderGetConstantBufferSize(const ShaderId id, const IndexT i);
const Util::StringAtom ShaderGetConstantBufferName(const ShaderId id, const IndexT i);
const IndexT ShaderGetConstantBufferResourceSlot(const ShaderId id, const IndexT i);
const IndexT ShaderGetConstantBufferResourceGroup(const ShaderId id, const IndexT i);
const uint64_t ShaderGetConstantBufferBindingMask(const ShaderId id, const IndexT group);
const uint64_t ShaderGetConstantBufferSize(const ShaderId id, const IndexT group, const IndexT i);

const IndexT ShaderGetResourceSlot(const ShaderId id, const Util::StringAtom& name);

const Util::Dictionary<ShaderFeature::Mask, ShaderProgramId>& ShaderGetPrograms(const ShaderId id);
const Util::String& ShaderProgramGetName(const ShaderProgramId id);

const CoreGraphics::ShaderProgramId ShaderGetProgram(const ShaderId id, const CoreGraphics::ShaderFeature::Mask mask);

union RayTracingBits
{
    struct 
    {
        bool hasGen : 1;
        bool hasCallable : 1;
        bool hasAnyHit : 1;
        bool hasClosestHit : 1;
        bool hasIntersect : 1;
        bool hasMiss : 1;
    } bitField;
    uint bits;
};
RayTracingBits ShaderProgramGetRaytracingBits(const ShaderProgramId id);
 
} // namespace CoreGraphics