Material.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2024, EPFL/Blue Brain Project
 *
 * The Blue Brain BioExplorer is a tool for scientists to extract and analyse
 * scientific data from visualization
 *
 * This file is part of Blue Brain BioExplorer <https://github.com/BlueBrain/BioExplorer>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <platform/core/common/Api.h>
#include <platform/core/common/CommonTypes.h>
#include <platform/core/common/MathTypes.h>
#include <platform/core/common/PropertyObject.h>
#include <platform/core/common/Types.h>
#include <platform/core/common/material/Texture2D.h>
 
SERIALIZATION_ACCESS(Material)
 
namespace core
{
typedef std::map<TextureType, Texture2DPtr> TextureDescriptors;
 
class Material : public PropertyObject
{
public:
    PLATFORM_API virtual void commit() = 0;
 
    PLATFORM_API Material(const PropertyMap& properties = {});
 
    PLATFORM_API const std::string& getName() const { return _name; }
 
    PLATFORM_API void setName(const std::string& value) { _updateValue(_name, value); }
 
    PLATFORM_API void setDiffuseColor(const Vector3d& value) { _updateValue(_diffuseColor, value); }
    PLATFORM_API const Vector3d& getDiffuseColor() const { return _diffuseColor; }
 
    PLATFORM_API void setSpecularColor(const Vector3d& value) { _updateValue(_specularColor, value); }
 
    PLATFORM_API const Vector3d& getSpecularColor() const { return _specularColor; }
 
    PLATFORM_API void setSpecularExponent(const double value) { _updateValue(_specularExponent, value); }
    PLATFORM_API double getSpecularExponent() const { return _specularExponent; }
 
    PLATFORM_API void setReflectionIndex(const double value) { _updateValue(_reflectionIndex, value); }
    PLATFORM_API double getReflectionIndex() const { return _reflectionIndex; }
 
    PLATFORM_API void setOpacity(const double value) { _updateValue(_opacity, value); }
    PLATFORM_API double getOpacity() const { return _opacity; }
 
    PLATFORM_API void setRefractionIndex(const double value) { _updateValue(_refractionIndex, value); }
    PLATFORM_API double getRefractionIndex() const { return _refractionIndex; }
 
    PLATFORM_API void setEmission(double value) { _updateValue(_emission, value); }
    PLATFORM_API double getEmission() const { return _emission; }
 
    PLATFORM_API void setGlossiness(const double value) { _updateValue(_glossiness, value); }
    PLATFORM_API double getGlossiness() const { return _glossiness; }
 
    PLATFORM_API void setShadingMode(const MaterialShadingMode value) { _updateValue(_shadingMode, value); }
    PLATFORM_API MaterialShadingMode getShadingMode() const { return _shadingMode; }
 
    PLATFORM_API void setUserParameter(const double value) { _updateValue(_userParameter, value); }
    PLATFORM_API double getUserParameter() const { return _userParameter; }
 
    PLATFORM_API void setCastUserData(const bool value) { _updateValue(_castUserData, value); }
    PLATFORM_API double getCastUserData() const { return _castUserData; }
 
    PLATFORM_API void setClippingMode(const MaterialClippingMode value) { _updateValue(_clippingMode, value); }
    PLATFORM_API MaterialClippingMode getClippingMode() const { return _clippingMode; }
 
    PLATFORM_API void setChameleonMode(const MaterialChameleonMode value) { _updateValue(_chameleonMode, value); }
    PLATFORM_API MaterialChameleonMode getChameleonMode() const { return _chameleonMode; }
 
    PLATFORM_API void setNodeId(const int32_t value) { _updateValue(_nodeId, value); }
    PLATFORM_API int32_t getNodeId() const { return _nodeId; }
 
    PLATFORM_API const TextureDescriptors& getTextureDescriptors() const { return _textureDescriptors; }
 
    PLATFORM_API void setTexture(const std::string& fileName, const TextureType type);
 
    PLATFORM_API void removeTexture(const TextureType type);
 
    PLATFORM_API Texture2DPtr getTexture(const TextureType type) const;
 
    PLATFORM_API bool hasTexture(const TextureType type) const { return _textureDescriptors.count(type) > 0; }
 
    PLATFORM_API void clearTextures();
 
protected:
    bool _loadTexture(const std::string& fileName, const TextureType type);
 
    std::string _name{"undefined"};         // The name of the material.
    Vector3d _diffuseColor{1., 1., 1.};     // The color of the diffuse component of the material.
    Vector3d _specularColor{1., 1., 1.};    // The color of the specular component of the material.
    double _specularExponent{10.};          // The specular exponent of the material.
    double _reflectionIndex{0.};            // The reflection index of the material.
    double _opacity{1.};                    // The opacity of the material.
    double _refractionIndex{1.};            // The refraction index of the material.
    double _emission{0.};                   // The emission of the material.
    double _glossiness{1.};                 // The glossiness of the material.
    TexturesMap _textures;                  // The textures of the material.
    TextureDescriptors _textureDescriptors; // The texture descriptors of the material.
    double _userParameter{1.};              // The user parameter of the material.
    MaterialShadingMode _shadingMode{MaterialShadingMode::undefined_shading_mode}; // The shading mode of the material
    bool _castUserData{false};                                                     // The cast user data of the material
    MaterialClippingMode _clippingMode{MaterialClippingMode::no_clipping};         // The clipping mode of the material
    int32_t _nodeId;                                                               // ID attached to the material
    MaterialChameleonMode _chameleonMode{MaterialChameleonMode::undefined_chameleon_mode}; // The chameleon mode of the
                                                                                           // material
 
    SERIALIZATION_FRIEND(Material)
};
} // namespace core