Reflection.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <limits>
#include <ostream>
 
namespace CeresEngine::ShaderCompiler {
 
    namespace Reflection {
        enum class Filter {
            MinMagMipPoint = 0,
            MinMagPointMipLinear = 0x1,
            MinPointMagLinearMipPoint = 0x4,
            MinPointMagMipLinear = 0x5,
            MinLinearMagMipPoint = 0x10,
            MinLinearMagPointMipLinear = 0x11,
            MinMagLinearMipPoint = 0x14,
            MinMagMipLinear = 0x15,
            Anisotropic = 0x55,
            ComparisonMinMagMipPoint = 0x80,
            ComparisonMinMagPointMipLinear = 0x81,
            ComparisonMinPointMagLinearMipPoint = 0x84,
            ComparisonMinPointMagMipLinear = 0x85,
            ComparisonMinLinearMagMipPoint = 0x90,
            ComparisonMinLinearMagPointMipLinear = 0x91,
            ComparisonMinMagLinearMipPoint = 0x94,
            ComparisonMinMagMipLinear = 0x95,
            ComparisonAnisotropic = 0xd5,
            MinimumMinMagMipPoint = 0x100,
            MinimumMinMagPointMipLinear = 0x101,
            MinimumMinPointMagLinearMipPoint = 0x104,
            MinimumMinPointMagMipLinear = 0x105,
            MinimumMinLinearMagMipPoint = 0x110,
            MinimumMinLinearMagPointMipLinear = 0x111,
            MinimumMinMagLinearMipPoint = 0x114,
            MinimumMinMagMipLinear = 0x115,
            MinimumAnisotropic = 0x155,
            MaximumMinMagMipPoint = 0x180,
            MaximumMinMagPointMipLinear = 0x181,
            MaximumMinPointMagLinearMipPoint = 0x184,
            MaximumMinPointMagMipLinear = 0x185,
            MaximumMinLinearMagMipPoint = 0x190,
            MaximumMinLinearMagPointMipLinear = 0x191,
            MaximumMinMagLinearMipPoint = 0x194,
            MaximumMinMagMipLinear = 0x195,
            MaximumAnisotropic = 0x1d5,
        };
 
        enum class TextureAddressMode {
            Wrap = 1,
            Mirror = 2,
            Clamp = 3,
            Border = 4,
            MirrorOnce = 5,
        };
 
        enum class ComparisonFunc {
            Never = 1,
            Less = 2,
            Equal = 3,
            LessEqual = 4,
            Greater = 5,
            NotEqual = 6,
            GreaterEqual = 7,
            Always = 8,
        };
 
        enum class FieldType {
            Undefined,
 
            Bool,
 
            Int,
 
            UInt,
 
            Half,
 
            Float,
 
            Double,
 
            Record,
        };
 
        enum class ResourceType {
            Undefined,
 
            Texture1D,
 
            Texture2D,
 
            Texture3D,
 
            TextureCube,
 
            Texture1DArray,
 
            Texture2DArray,
 
            TextureCubeArray,
 
            Texture2DMS,
 
            Texture2DMSArray,
 
            RWTexture1D,
 
            RWTexture2D,
 
            RWTexture3D,
 
            RWTextureCube,
 
            RWTexture1DArray,
 
            RWTexture2DArray,
 
            RWTextureCubeArray,
 
            RWTexture2DMS,
 
            RWTexture2DMSArray,
 
            Sampler1D,
 
            Sampler2D,
 
            Sampler3D,
 
            SamplerCube,
 
            Sampler1DArray,
 
            Sampler2DArray,
 
            SamplerCubeArray,
 
            Sampler2DMS,
 
            Sampler2DMSArray,
 
            Sampler2DRect,
 
            Buffer,
 
            ByteAddressBuffer,
 
            StructuredBuffer,
 
            AppendStructuredBuffer,
 
            ConsumeStructuredBuffer,
 
            RWBuffer,
 
            RWByteAddressBuffer,
 
            RWStructuredBuffer,
 
            ConstantBuffer,
 
            TextureBuffer,
 
            SamplerState,
 
            SamplerComparisonState,
        };
 
        struct SamplerStateDesc {
            Filter filter = Filter::MinMagMipLinear;
            TextureAddressMode addressU = TextureAddressMode::Clamp;
            TextureAddressMode addressV = TextureAddressMode::Clamp;
            TextureAddressMode addressW = TextureAddressMode::Clamp;
            float mipLODBias = 0.0f;
            UInt32 maxAnisotropy = 1u;
            ComparisonFunc comparisonFunc = ComparisonFunc::Never;
            float borderColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
            float minLOD = -std::numeric_limits<float>::max();
            float maxLOD = std::numeric_limits<float>::max();
        };
 
        struct Attribute {
            bool referenced = false;
 
            String name;
 
            Int32 slot = -1;
 
            Attribute() = default;
 
            inline Attribute(const String& name, const Int32 slot) : name{name}, slot{slot} {}
        };
 
        struct Resource {
            bool referenced = false;
 
            ResourceType type = ResourceType::Undefined;
 
            String name;
 
            Int32 slot = -1;
        };
 
        struct Field {
            bool referenced = false;
 
            String name;
 
            FieldType type = FieldType::Undefined;
 
            UInt32 dimensions[2] = {1, 1};
 
            Int32 typeRecordIndex = -1;
 
            UInt32 size = 0;
 
            UInt32 offset = 0;
 
            Vector<UInt32> arrayElements;
        };
 
        struct Record {
            bool referenced = false;
 
            String name;
 
            Int32 baseRecordIndex = -1;
 
            Vector<Field> fields;
 
            UInt32 size = 0;
 
            UInt32 padding = 0;
        };
 
        struct ConstantBuffer {
            bool referenced = false;
 
            ResourceType type = ResourceType::Undefined;
 
            String name;
 
            Int32 slot = -1;
 
            Vector<Field> fields;
 
            UInt32 size = 0;
 
            UInt32 padding = 0;
        };
 
        struct SamplerState {
            ResourceType type = ResourceType::Undefined;
 
            String name;
 
            Int32 slot = -1;
 
            bool referenced = false;
        };
 
        struct StaticSamplerState {
            ResourceType type = ResourceType::Undefined;
 
            String name;
 
            SamplerStateDesc desc;
        };
 
        struct NumThreads {
            Int32 x = 0;
 
            Int32 y = 0;
 
            Int32 z = 0;
        };
 
        struct ReflectionData {
            Vector<String> macros;
 
            Vector<Record> records;
 
            Vector<Attribute> inputAttributes;
 
            Vector<Attribute> outputAttributes;
 
            Vector<Attribute> uniforms;
 
            Vector<Resource> resources;
 
            Vector<ConstantBuffer> constantBuffers;
 
            Vector<SamplerState> samplerStates;
 
            Vector<StaticSamplerState> staticSamplerStates;
 
            NumThreads numThreads;
        };
 
    } // namespace Reflection
 
    String toString(const Reflection::Filter t);
 
    String toString(const Reflection::TextureAddressMode t);
 
    String toString(const Reflection::ComparisonFunc t);
 
    String toString(const Reflection::ResourceType t);
 
    void printReflection(std::ostream& stream, const Reflection::ReflectionData& reflectionData, bool referencedOnly = false);
 
} // namespace CeresEngine::ShaderCompiler