GPUSampler.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 "Common.hpp"
#include "Forward.hpp"
 
#include "GPUGraphicsPipeline.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include <cstdint>
#include <iosfwd>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() GPUSamplerAddressMode {
        Repeat,
 
        Mirror,
 
        Clamp,
 
        Border,
 
        MirrorOnce,
    };
 
    enum class CE_SCRIPT_EXPORT() GPUSamplerFilter {
        Nearest,
 
        Linear,
 
        Cubic
    };
 
    struct CE_SCRIPT_EXPORT() GPUSamplerDescriptor final {
        CE_SCRIPT_EXPORT()
        GPUSamplerAddressMode addressModeU = GPUSamplerAddressMode::Repeat;
 
        CE_SCRIPT_EXPORT()
        GPUSamplerAddressMode addressModeV = GPUSamplerAddressMode::Repeat;
 
        CE_SCRIPT_EXPORT()
        GPUSamplerAddressMode addressModeW = GPUSamplerAddressMode::Repeat;
 
        CE_SCRIPT_EXPORT()
        GPUSamplerFilter minFilter = GPUSamplerFilter::Nearest;
 
        CE_SCRIPT_EXPORT()
        GPUSamplerFilter magFilter = GPUSamplerFilter::Nearest;
 
        CE_SCRIPT_EXPORT()
        GPUSamplerFilter mipMapFilter = GPUSamplerFilter::Nearest;
 
        CE_SCRIPT_EXPORT()
        bool mipMapping = false;
 
        CE_SCRIPT_EXPORT()
        float mipMapLODBias = 0.0f;
 
        CE_SCRIPT_EXPORT()
        float minLOD = 0.0f;
 
        CE_SCRIPT_EXPORT()
        float maxLOD = 1000.0f;
 
        CE_SCRIPT_EXPORT()
        UInt32 maxAnisotropy = 1;
 
        CE_SCRIPT_EXPORT()
        bool compareEnabled = false;
 
        CE_SCRIPT_EXPORT()
        GPUCompareOp compareOp = GPUCompareOp::Less;
 
        CE_SCRIPT_EXPORT()
        Vector4f borderColor = {0.0f, 0.0f, 0.0f, 0.0f};
 
        CE_SCRIPT_EXPORT()
        String name;
 
    public:
        friend bool operator==(const GPUSamplerDescriptor& lhs, const GPUSamplerDescriptor& rhs);
 
        friend bool operator!=(const GPUSamplerDescriptor& lhs, const GPUSamplerDescriptor& rhs);
 
        friend String toString(const GPUSamplerDescriptor& descriptor);
 
        friend std::ostream& operator<<(std::ostream& os, const GPUSamplerDescriptor& descriptor);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(addressModeU);
            CE_REFL_DATA(addressModeV);
            CE_REFL_DATA(addressModeW);
            CE_REFL_DATA(minFilter);
            CE_REFL_DATA(magFilter);
            CE_REFL_DATA(mipMapFilter);
            CE_REFL_DATA(mipMapping);
            CE_REFL_DATA(mipMapLODBias);
            CE_REFL_DATA(minLOD);
            CE_REFL_DATA(maxLOD);
            CE_REFL_DATA(maxAnisotropy);
            CE_REFL_DATA(compareEnabled);
            CE_REFL_DATA(compareOp);
            CE_REFL_DATA(borderColor);
            CE_REFL_DATA(name);
        }
    };
 
    class CE_SCRIPT_EXPORT() GPUSampler : public TDeviceObject<GPUSamplerDescriptor> {
    public:
        using TDeviceObject::TDeviceObject;
 
        GPUSampler(const GPUSampler&) = delete;
        GPUSampler& operator=(const GPUSampler&) = delete;
 
        GPUSampler(GPUSampler&&) = delete;
        GPUSampler& operator=(GPUSampler&&) = delete;
    };
 
    std::ostream& operator<<(std::ostream& os, const GPUSamplerAddressMode& mode);
 
    std::ostream& operator<<(std::ostream& os, const GPUSamplerFilter& filter);
 
} // namespace CeresEngine
 
CE_REFLECT_HASH(CeresEngine::GPUSamplerDescriptor);