sampler.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "samplerdeclaration.h"
#include "materialcommon.h"
 
// External Includes
#include <rtti/objectptr.h>
#include <utility/dllexport.h>
#include <nap/resource.h>
#include <nap/numeric.h>
 
namespace nap
{
    // Forward Declares
    class Texture2D;
    class TextureCube;
    class SamplerInstance;
    class RenderService;
 
    namespace sampler
    {
        constexpr const char* texture   = "Texture";
        constexpr const char* textures  = "Textures";
    }
 
    enum class EFilterMode : uint32
    {
        Nearest = 0,                
        Linear                      
    };
 
 
    enum class EAddressMode : uint32
    {
        Repeat = 0,                 
        MirroredRepeat,             
        ClampToEdge,                
        ClampToBorder               
    };
 
 
    enum class EAnisotropicSamples : uint32
    {
        Default     = 0,            
        Four        = 4,            
        Eight       = 8,            
        Sixteen     = 16            
    };
 
 
    enum class EBorderColor : uint32
    {
        FloatTransparentBlack = 0,  
        IntTransparentBlack,        
        FloatOpaqueBlack,           
        IntOpaqueBlack,             
        FloatOpaqueWhite,           
        IntOpaqueWhite              
    };
 
 
    // Sampler
 
    class NAPAPI Sampler : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        Sampler() = default;
 
        std::string         mName;                                                          
        EFilterMode         mMinFilter              = EFilterMode::Linear;                  
        EFilterMode         mMaxFilter              = EFilterMode::Linear;                  
        EFilterMode         mMipMapMode             = EFilterMode::Linear;                  
        EAddressMode        mAddressModeVertical    = EAddressMode::ClampToEdge;            
        EAddressMode        mAddressModeHorizontal  = EAddressMode::ClampToEdge;            
        EAnisotropicSamples mMaxAnisotropy          = EAnisotropicSamples::Default;         
        EBorderColor        mBorderColor            = EBorderColor::IntOpaqueBlack;         
        EDepthCompareMode   mCompareMode            = EDepthCompareMode::LessOrEqual;       
        bool                mEnableCompare          = false;                                
        float               mLodBias                = 0.0f;                                 
        uint32              mMinLodLevel            = 0;                                    
        uint32              mMaxLodLevel            = 1000;                                 
    };
 
 
    // Sampler2D
 
    class NAPAPI Sampler2D : public Sampler
    {
        RTTI_ENABLE(Sampler)
    public:
        Sampler2D() = default;
        mutable rtti::ObjectPtr<Texture2D> mTexture = nullptr;      
    };
 
 
    // SamplerCube
 
    class NAPAPI SamplerCube : public Sampler
    {
        RTTI_ENABLE(Sampler)
    public:
        SamplerCube() = default;
        mutable rtti::ObjectPtr<TextureCube> mTextureCube;          
    };
 
 
    // SamplerArray
 
    class NAPAPI SamplerArray : public Sampler
    {
        RTTI_ENABLE(Sampler)
 
    public:
        virtual int getNumElements() const = 0;
    };
 
 
    // Sampler2DArray
 
    class NAPAPI Sampler2DArray : public SamplerArray
    {
        RTTI_ENABLE(SamplerArray)
    public:
 
        Sampler2DArray() = default;
        Sampler2DArray(int inSize) :
            mTextures(inSize)                                   { }
 
        virtual int getNumElements() const override             { return mTextures.size(); }
 
        std::vector<rtti::ObjectPtr<Texture2D>> mTextures;      
    };
 
 
    // SamplerCubeArray
 
    class NAPAPI SamplerCubeArray : public SamplerArray
    {
        RTTI_ENABLE(SamplerArray)
    public:
 
        SamplerCubeArray() = default;
        SamplerCubeArray(int inSize) :
            mTextures(inSize) { }
 
        virtual int getNumElements() const override { return mTextures.size(); }
 
        std::vector<rtti::ObjectPtr<TextureCube>> mTextures;    
    };
}