Material.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#ifndef GZ_RENDERING_MATERIAL_HH_
#define GZ_RENDERING_MATERIAL_HH_
 
#include <memory>
#include <string>
#include <gz/math/Color.hh>
#include <gz/common/Material.hh>
#include "gz/rendering/config.hh"
#include "gz/rendering/RenderTypes.hh"
#include "gz/rendering/Object.hh"
#include "gz/rendering/ShaderType.hh"
#include "gz/rendering/Export.hh"
 
namespace gz
{
  namespace rendering
  {
    inline namespace GZ_RENDERING_VERSION_NAMESPACE {
    //
    enum GZ_RENDERING_VISIBLE MaterialType
    {
      MT_CLASSIC = 0,
 
      MT_PBS = 1
    };
 
    class GZ_RENDERING_VISIBLE Material :
      public virtual Object
    {
      public: virtual ~Material();
 
      public: virtual bool LightingEnabled() const = 0;
 
      public: virtual void SetLightingEnabled(const bool _enabled) = 0;
 
      public: virtual void SetDepthCheckEnabled(bool _enabled) = 0;
 
      public: virtual bool DepthCheckEnabled() const = 0;
 
      public: virtual void SetDepthWriteEnabled(bool _enabled) = 0;
 
      public: virtual bool DepthWriteEnabled() const = 0;
 
      public: virtual math::Color Ambient() const = 0;
 
      public: virtual void SetAmbient(const double _r, const double _g,
                  const double _b, const double _a = 1.0) = 0;
 
      public: virtual void SetAmbient(const math::Color &_color) = 0;
 
      public: virtual math::Color Diffuse() const = 0;
 
      public: virtual void SetDiffuse(const double _r, const double _g,
                  const double _b, const double _a = 1.0) = 0;
 
      public: virtual void SetDiffuse(const math::Color &_color) = 0;
 
      public: virtual math::Color Specular() const = 0;
 
      public: virtual void SetSpecular(const double _r, const double _g,
                  const double _b, const double _a = 1.0) = 0;
 
      public: virtual void SetSpecular(const math::Color &_color) = 0;
 
      public: virtual math::Color Emissive() const = 0;
 
      public: virtual void SetEmissive(const double _r, const double _g,
                  const double _b, const double _a = 1.0) = 0;
 
      public: virtual void SetEmissive(const math::Color &_color) = 0;
 
      public: virtual double Shininess() const = 0;
 
      public: virtual void SetShininess(const double _shininess) = 0;
 
      public: virtual double Transparency() const = 0;
 
      public: virtual void SetDepthMaterial(const double far,
            const double near) = 0;
 
      public: virtual void SetTransparency(const double _transparency) = 0;
 
      public: virtual void SetAlphaFromTexture(bool _enabled,
                  double _alpha = 0.5, bool _twoSided = true) = 0;
 
      public: virtual bool TextureAlphaEnabled() const = 0;
 
      public: virtual double AlphaThreshold() const = 0;
 
      public: virtual bool TwoSidedEnabled() const = 0;
 
      public: virtual double Reflectivity() const = 0;
 
      public: virtual void SetReflectivity(const double _reflectivity) = 0;
 
      public: virtual bool CastShadows() const = 0;
 
      public: virtual void SetCastShadows(const bool _castShadows) = 0;
 
      public: virtual bool ReceiveShadows() const = 0;
 
      public: virtual void SetReceiveShadows(const bool _receiveShadows) = 0;
 
      public: virtual bool ReflectionEnabled() const = 0;
 
      public: virtual void SetReflectionEnabled(const bool _enabled) = 0;
 
      public: virtual bool HasTexture() const = 0;
 
      public: virtual std::string Texture() const = 0;
 
      public: virtual void SetTexture(const std::string &_texture)
      {
        this->SetTexture(_texture, nullptr);
      }
 
      public: virtual void SetTexture(const std::string &_texture,
        const std::shared_ptr<const common::Image> &_img)
      {
        (void)_texture;
        (void)_img;
      }
 
      public: virtual std::shared_ptr<const common::Image> TextureData()
        const = 0;
 
      public: virtual void ClearTexture() = 0;
 
      public: virtual bool HasNormalMap() const = 0;
 
      public: virtual std::string NormalMap() const = 0;
 
      public: virtual std::shared_ptr<const common::Image> NormalMapData()
        const = 0;
 
      public: virtual void SetNormalMap(const std::string &_normalMap)
      {
        this->SetNormalMap(_normalMap, nullptr);
      }
 
      public: virtual void SetNormalMap(const std::string &_normalMap,
        const std::shared_ptr<const common::Image> &_img)
      {
        (void)_normalMap;
        (void)_img;
      }
 
      public: virtual void ClearNormalMap() = 0;
 
      public: virtual bool HasRoughnessMap() const = 0;
 
      public: virtual std::string RoughnessMap() const = 0;
 
      public: virtual std::shared_ptr<const common::Image> RoughnessMapData()
                  const = 0;
 
      public: virtual void SetRoughnessMap(const std::string &_roughnessMap)
      {
        this->SetRoughnessMap(_roughnessMap, nullptr);
      }
 
      public: virtual void SetRoughnessMap(
        const std::string &_roughnessMap,
        const std::shared_ptr<const common::Image> &_img)
      {
        (void)_roughnessMap;
        (void)_img;
      }
 
      public: virtual void ClearRoughnessMap() = 0;
 
      public: virtual bool HasMetalnessMap() const = 0;
 
      public: virtual std::string MetalnessMap() const = 0;
 
      public: virtual std::shared_ptr<const common::Image> MetalnessMapData()
                  const = 0;
 
      public: virtual void SetMetalnessMap(const std::string &_metalnessMap)
      {
        this->SetMetalnessMap(_metalnessMap, nullptr);
      }
 
      public: virtual void SetMetalnessMap(
        const std::string &_metalnessMap,
        const std::shared_ptr<const common::Image> &_img)
      {
        (void)_metalnessMap;
        (void)_img;
      }
 
      public: virtual void ClearMetalnessMap() = 0;
 
      public: virtual bool HasEnvironmentMap() const = 0;
 
      public: virtual std::string EnvironmentMap() const = 0;
 
      public: virtual std::shared_ptr<const common::Image> EnvironmentMapData()
                  const = 0;
 
      public: virtual void SetEnvironmentMap(const std::string &_environmentMap)
      {
        this->SetEnvironmentMap(_environmentMap, nullptr);
      }
 
      public: virtual void SetEnvironmentMap(
        const std::string &_environmentMap,
        const std::shared_ptr<const common::Image> &_img)
      {
        (void)_environmentMap;
        (void)_img;
      }
 
      public: virtual void ClearEnvironmentMap() = 0;
 
      public: virtual bool HasEmissiveMap() const = 0;
 
      public: virtual std::string EmissiveMap() const = 0;
 
      public: virtual std::shared_ptr<const common::Image> EmissiveMapData()
                  const = 0;
 
      public: virtual void SetEmissiveMap(const std::string &_emissiveMap)
      {
        this->SetEmissiveMap(_emissiveMap, nullptr);
      }
 
      public: virtual void SetEmissiveMap(
        const std::string &_emissiveMap,
        const std::shared_ptr<const common::Image> &_img)
      {
        (void)_emissiveMap;
        (void)_img;
      }
 
      public: virtual void ClearEmissiveMap() = 0;
 
      public: virtual bool HasLightMap() const = 0;
 
      public: virtual std::string LightMap() const = 0;
 
      public: virtual unsigned int LightMapTexCoordSet() const = 0;
 
      public: virtual void SetLightMap(const std::string &_lightMap,
          unsigned int _uvSet = 0u)
      {
        this->SetLightMap(_lightMap, nullptr, _uvSet);
      }
 
      public: virtual void SetLightMap(const std::string &_lightMap,
          const std::shared_ptr<const common::Image> &_img,
          unsigned int _uvSet = 0)
      {
        (void)_lightMap;
        (void)_img;
        (void)_uvSet;
      }
 
      public: virtual std::shared_ptr<const common::Image> LightMapData()
                  const = 0;
 
      public: virtual void ClearLightMap() = 0;
 
      public: virtual void SetRenderOrder(const float _renderOrder) = 0;
 
      public: virtual float RenderOrder() const = 0;
 
      public: virtual void SetRoughness(const float _roughness) = 0;
 
      public: virtual float Roughness() const = 0;
 
      public: virtual void SetMetalness(const float _metalness) = 0;
 
      public: virtual float Metalness() const = 0;
 
      public: virtual enum MaterialType Type() const = 0;
 
      public: virtual enum ShaderType ShaderType() const = 0;
 
      public: virtual void SetShaderType(enum ShaderType _type) = 0;
 
      public: virtual MaterialPtr Clone(const std::string &_name = "")
                const = 0;
 
      public: virtual void CopyFrom(ConstMaterialPtr _material) = 0;
 
      public: virtual void CopyFrom(const common::Material &_material) = 0;
 
      public: virtual std::string VertexShader() const = 0;
 
      public: virtual ShaderParamsPtr VertexShaderParams() = 0;
 
      public: virtual void SetVertexShader(const std::string &_path) = 0;
 
      public: virtual std::string FragmentShader() const = 0;
 
      public: virtual ShaderParamsPtr FragmentShaderParams() = 0;
 
      public: virtual void SetFragmentShader(const std::string &_path) = 0;
    };
    }
  }
}
#endif