ecvMaterial.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// Local
#include "ecvColorTypes.h"
#include "ecvSerializableObject.h"
 
// Qt
#include <QtGui/qopengl.h>
 
#include <QSharedPointer>
 
// STL
#include <map>
#include <utility>
#include <vector>
 
class QImage;
class QOpenGLContext;
 
class CV_DB_LIB_API ccMaterial : public ccSerializableObject {
public:
    typedef QSharedPointer<const ccMaterial> CShared;
    typedef QSharedPointer<ccMaterial> Shared;
 
    explicit ccMaterial(const QString& name = QString("default"));
 
    ccMaterial(const ccMaterial& mtl);
 
    inline const QString& getName() const { return m_name; }
    inline const QString& getTextureFilename() const {
        return m_textureFilename;
    }
    inline void setName(QString name) { m_name = name; }
 
    void setDiffuse(const ecvColor::Rgbaf& color);
    inline void setDiffuseFront(const ecvColor::Rgbaf& color) {
        m_diffuseFront = color;
    }
    inline void setDiffuseBack(const ecvColor::Rgbaf& color) {
        m_diffuseBack = color;
    }
    inline const ecvColor::Rgbaf& getDiffuseFront() const {
        return m_diffuseFront;
    }
    inline const ecvColor::Rgbaf& getDiffuseBack() const {
        return m_diffuseBack;
    }
 
    inline void setAmbient(const ecvColor::Rgbaf& color) { m_ambient = color; }
    inline const ecvColor::Rgbaf& getAmbient() const { return m_ambient; }
 
    inline void setIllum(int illum) { m_illum = illum; }
    inline int getIllum() const { return m_illum; }
 
    inline void setSpecular(const ecvColor::Rgbaf& color) {
        m_specular = color;
    }
    inline const ecvColor::Rgbaf& getSpecular() const { return m_specular; }
 
    inline void setEmission(const ecvColor::Rgbaf& color) {
        m_emission = color;
    }
    inline const ecvColor::Rgbaf& getEmission() const { return m_emission; }
 
    void setShininess(float val);
    inline void setShininessFront(float val) { m_shininessFront = val; }
    inline void setShininessBack(float val) { m_shininessBack = val; }
    inline float getShininessFront() const { return m_shininessFront; }
    inline float getShininessBack() const { return m_shininessBack; }
 
    void setTransparency(float val);
 
    inline void setMetallic(float val) { m_metallic = val; }
    inline float getMetallic() const { return m_metallic; }
 
    inline void setRoughness(float val) { m_roughness = val; }
    inline float getRoughness() const { return m_roughness; }
 
    inline void setSheen(float val) { m_sheen = val; }
    inline float getSheen() const { return m_sheen; }
 
    inline void setClearcoat(float val) { m_clearcoat = val; }
    inline float getClearcoat() const { return m_clearcoat; }
 
    inline void setClearcoatRoughness(float val) { m_clearcoatRoughness = val; }
    inline float getClearcoatRoughness() const { return m_clearcoatRoughness; }
 
    inline void setAnisotropy(float val) { m_anisotropy = val; }
    inline float getAnisotropy() const { return m_anisotropy; }
 
    inline void setAmbientOcclusion(float val) { m_ambientOcclusion = val; }
    inline float getAmbientOcclusion() const { return m_ambientOcclusion; }
 
    void applyGL(const QOpenGLContext* context,
                 bool lightEnabled,
                 bool skipDiffuse) const;
 
    bool hasTexture() const;
 
 
    void setTexture(const QImage& image,
                    const QString& absoluteFilename = QString(),
                    bool mirrorImage = false);
 
 
    bool loadAndSetTexture(const QString& absoluteFilename);
 
    const QImage& getTexture() const;
 
    GLuint getTextureID() const;
 
    static QImage GetTexture(const QString& absoluteFilename);
 
    // ========== Multi-Texture PBR Support ==========
 
    enum class TextureMapType {
        DIFFUSE,       // map_Kd - Diffuse/Albedo
        AMBIENT,       // map_Ka - Ambient Occlusion
        SPECULAR,      // map_Ks - Specular
        NORMAL,        // map_Bump, map_bump, norm, bump - Normal map
        METALLIC,      // map_Pm - Metallic
        ROUGHNESS,     // map_Pr - Roughness
        SHININESS,     // map_Ns - Shininess/Glossiness (inverse of roughness)
        EMISSIVE,      // map_Ke - Emissive
        OPACITY,       // map_d - Opacity/Alpha
        DISPLACEMENT,  // map_disp, disp - Displacement
        REFLECTION,    // refl - Reflection
        SHEEN,         // map_Ps - Sheen (fabric-like materials)
        CLEARCOAT,     // map_Pc - Clearcoat layer
        CLEARCOAT_ROUGHNESS,  // map_Pcr - Clearcoat roughness
        ANISOTROPY            // map_aniso - Anisotropic reflection
    };
 
    bool loadAndSetTextureMap(TextureMapType type,
                              const QString& absoluteFilename);
 
    QString getTextureFilename(TextureMapType type) const;
 
 
    std::vector<QString> getTextureFilenames(TextureMapType type) const;
 
    bool hasTextureMap(TextureMapType type) const;
 
 
    std::vector<std::pair<TextureMapType, QString>> getAllTextureFilenames()
            const;
 
    static void AddTexture(const QImage& image,
                           const QString& absoluteFilename);
 
 
    static void ReleaseTextures();
 
 
    void releaseTexture();
 
 
    bool compare(const ccMaterial& mtl) const;
 
    // inherited from ccSerializableObject
    bool isSerializable() const override { return true; }
    bool toFile(QFile& out, short dataVersion) const override;
    short minimumFileVersion() const override;
    bool fromFile(QFile& in,
                  short dataVersion,
                  int flags,
                  LoadedIDMap& oldToNewIDMap) override;
 
    inline QString getUniqueIdentifier() const { return m_uniqueID; }
 
protected:
    QString m_name;
    QString m_textureFilename;  // Legacy: main diffuse texture
    QString m_uniqueID;
    int m_illum;
 
    ecvColor::Rgbaf m_diffuseFront;
    ecvColor::Rgbaf m_diffuseBack;
    ecvColor::Rgbaf m_ambient;
    ecvColor::Rgbaf m_specular;
    ecvColor::Rgbaf m_emission;
    float m_shininessFront;
    float m_shininessBack;
 
    // PBR scalar parameters
    float m_metallic;            // Pm - Metallic factor [0,1]
    float m_roughness;           // Pr - Roughness factor [0,1]
    float m_sheen;               // Ps - Sheen factor [0,1]
    float m_clearcoat;           // Pc - Clearcoat factor [0,1]
    float m_clearcoatRoughness;  // Pcr - Clearcoat roughness [0,1]
    float m_anisotropy;          // aniso - Anisotropy factor [0,1]
    float m_ambientOcclusion;    // Pa - Ambient Occlusion factor [0,1]
 
    // Multi-texture PBR support
    // Support multiple textures of the same type (e.g., multiple map_Kd)
    std::map<TextureMapType, std::vector<QString>> m_textureFilenames;
};