imstkTexture.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkEventObject.h"
#include "imstkColor.h"

#include <string>
#include <memory>

namespace imstk
{
class ImageData;

class Texture : public EventObject
{
public:
    enum class Type
    {
        Diffuse = 0, // Also used for albedo
        Normal,
        Roughness,
        Metalness,
        SubsurfaceScattering,
        AmbientOcclusion,
        Cavity,
        Cubemap,
        IrradianceCubeMap,
        RadianceCubeMap,
        ORM,
        BRDF_LUT,
        Emissive,
        Anistropy,
        CoatNormal,
        None
    };

    enum class FileType
    {
        Unknown,
        Bmp,
        Png,
        Jpg,
        Dds
    };

    enum class WrapType
    {
        CLAMP_TO_EDGE,   // Clamps without border color
        CLAMP_TO_BORDER, // Pixels outside [0,1] use border color
        REPEAT           // Pixels outside [0,1] repeat back to [0,1] in a modulus fashion. Such that 1.3, becomes 0.3
    };

    Texture(std::string path = "", Type type = Type::Diffuse);

    Texture(std::shared_ptr<ImageData> imageTex, Type type = Type::Diffuse);

    virtual ~Texture() = default;

    // *INDENT-OFF*
    SIGNAL(Texture, modified);
    // *INDENT-ON*

    void postModified() { this->postEvent(Event(modified())); }

    Type getType() const;

    const std::string& getPath() const { return m_path; }

    FileType getFileType();

    bool getMipmapsEnabled() const { return m_mipmapsEnabled; }

    const WrapType& getWrapType() const { return m_wrapType; }
    void setWrapType(const WrapType& repeat)
    {
        m_wrapType = repeat;
        postModified();
    }

    const Color& getBorderColor() const { return m_borderColor; }
    void setBorderColor(const Color& color)
    {
        m_borderColor = color;
        postModified();
    }

    bool isAnisotropyEnabled() const { return m_anisotropyEnabled; }

    double getAnisotropyFactor() const { return m_anisotropyFactor; }

    void setImageData(std::shared_ptr<ImageData> imgData) { imageTexture = imgData; }

    void setInterpolation(const bool interpolation)
    {
        m_interpolation = interpolation;
        postModified();
    }

    bool getInterpolation() { return m_interpolation; }

    std::shared_ptr<ImageData> getImageData() const { return imageTexture; }

protected:
    std::shared_ptr<ImageData> imageTexture = nullptr;
    Type m_type;             
    std::string m_path = ""; 

    // Helps with texture aliasing (and a little with performance)
    bool m_mipmapsEnabled = true;

    WrapType m_wrapType    = WrapType::REPEAT;
    Color    m_borderColor = Color::Black;

    // Helps sharpen mipmapped textures at more extreme angles
    bool   m_anisotropyEnabled = true;
    double m_anisotropyFactor  = 1.0;

    // Use interpolation when texturing?
    bool m_interpolation = true;
};
} // namespace imstk

namespace std
{
template<> struct less<std::shared_ptr<imstk::Texture>>
{
    bool operator()(const std::shared_ptr<imstk::Texture>& texture1,
                    const std::shared_ptr<imstk::Texture>& texture2) const
    {
        if (texture1->getType() != texture2->getType())
        {
            return (texture1->getType() < texture2->getType());
        }

        if (texture1->getPath() != texture2->getPath())
        {
            return (texture1->getPath() < texture2->getPath());
        }

        if (texture1->getMipmapsEnabled() != texture2->getMipmapsEnabled())
        {
            return (texture1->getMipmapsEnabled() < texture2->getMipmapsEnabled());
        }

        if (texture1->isAnisotropyEnabled() != texture2->isAnisotropyEnabled())
        {
            return (texture1->isAnisotropyEnabled() < texture2->isAnisotropyEnabled());
        }

        if (texture1->getAnisotropyFactor() != texture2->getAnisotropyFactor())
        {
            return (texture1->getAnisotropyFactor() < texture2->getAnisotropyFactor());
        }

        return false;
    }
};
} // namespace std