material.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "ids/id.h"
#include "ids/idallocator.h"
#include "resources/resourceid.h"
#include "coregraphics/texture.h"
#include "coregraphics/buffer.h"
#include "materialvariant.h"
 
 
namespace MaterialTemplates
{
struct Entry;
enum class BatchGroup;
};
 
namespace Materials
{
 
struct ShaderConfigBatchTexture;
RESOURCE_ID_TYPE(MaterialId);
ID_32_24_8_NAMED_TYPE(MaterialInstanceId, instance, materialId, materialGeneration, material); // 32 bits instance, 24 bits material, 8 bits type
 
typedef IndexT BatchIndex;
 
 
MaterialId CreateMaterial(const MaterialTemplates::Entry* entry);
void DestroyMaterial(const MaterialId id);
 
void MaterialSetTexture(const MaterialId mat, const ShaderConfigBatchTexture* bind, const Resources::ResourceId tex);
void MaterialSetTexture(const MaterialId mat, uint name, const Resources::ResourceId tex);
void MaterialSetTextureBindless(const MaterialId mat, uint name, const uint handle, const uint offset, const Resources::ResourceId tex);
void MaterialSetConstants(const MaterialId mat, const void* data, const uint size);
void MaterialSetConstant(const MaterialId mat, const void* data, const uint size, const uint offset);
 
void MaterialSetBufferBinding(const MaterialId id, IndexT index);
IndexT MaterialGetBufferBinding(const MaterialId id);
 
void MaterialAddLODTexture(const MaterialId mat, const Resources::ResourceId tex);
void MaterialSetLowestLod(const MaterialId mat, float lod);
 
void MaterialApply(const MaterialId id, const CoreGraphics::CmdBufferId buf, IndexT index);
 
const MaterialTemplates::Entry* MaterialGetTemplate(const MaterialId mat);
const Materials::BatchIndex MaterialGetBatchIndex(const MaterialId mat, const MaterialTemplates::BatchGroup batch);
uint64_t MaterialGetSortCode(const MaterialId mat);
 
#ifdef WITH_NEBULA_EDITOR
ubyte* MaterialGetConstants(const MaterialId mat);
const Resources::ResourceId MaterialGetTexture(const MaterialId mat, const IndexT i);
void MaterialInvalidate(const MaterialId mat);
#endif
 
struct MaterialConstant
{
    MaterialVariant defaultValue;
    IndexT bufferIndex;
    bool instanceConstant : 1;
    IndexT binding;
    CoreGraphics::BufferId buffer;
 
    MaterialConstant()
        : buffer(CoreGraphics::InvalidBufferId)
        //, mem(nullptr)
    {}
};
 
struct MaterialTexture
{
    CoreGraphics::TextureId defaultValue;
    IndexT slot;
};
 
enum
{
    Material_MinLOD,
    Material_LODTextures,
    Material_Table,
    Material_Buffer,
    Material_InstanceTables,
    Material_InstanceBuffers,
    Material_Textures,
    Material_Constants,
    Material_BufferOffset,
    Material_Template
#ifdef WITH_NEBULA_EDITOR
    , Material_TextureValues
#endif
};
 
 
typedef Ids::IdAllocator<
    float,
    Util::Array<Resources::ResourceId>,
    Util::FixedArray<CoreGraphics::ResourceTableId>,                                // surface level resource table, mapped batch -> table
    CoreGraphics::BufferId,                                                         // Material buffer
    Util::FixedArray<Util::FixedArray<CoreGraphics::ResourceTableId>>,              // instance level resource table, mapped batch -> table
    Util::FixedArray<Util::Tuple<IndexT, SizeT>>,                                   // instance level instance buffer, mapped batch -> memory + size
    Util::FixedArray<Util::Array<MaterialTexture>>,                                 // textures
    Util::FixedArray<Util::Array<MaterialConstant>>,                                // constants
    IndexT,                                                                         // global material buffer binding (based on ShaderConfig::PrototypeHash)
    const MaterialTemplates::Entry*                                                 // template
#ifdef WITH_NEBULA_EDITOR
    , Util::Array<Resources::ResourceId>
#endif
> MaterialAllocator;
extern MaterialAllocator materialAllocator;
 
MaterialInstanceId CreateMaterialInstance(const MaterialId material);
void DestroyMaterialInstance(const MaterialInstanceId materialInstance);
 
CoreGraphics::ConstantBufferOffset MaterialInstanceAllocate(const MaterialInstanceId mat, const BatchIndex batch);
void MaterialInstanceApply(const MaterialInstanceId id, const CoreGraphics::CmdBufferId buf, IndexT index, IndexT bufferIndex);
 
 
SizeT MaterialInstanceBufferSize(const MaterialInstanceId sur, const BatchIndex batch);
 
enum MaterialInstanceMembers
{
    MaterialInstance_Offsets
};
typedef Ids::IdAllocator<
    uint
> MaterialInstanceAllocator;
extern MaterialInstanceAllocator materialInstanceAllocator;
 
} // namespace Materials