gz/common/Material.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2016 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_COMMON_MATERIAL_HH_
#define GZ_COMMON_MATERIAL_HH_
 
#include <iostream>
#include <memory>
#include <string>
 
#include <gz/math/Color.hh>
#include <gz/common/graphics/Export.hh>
#include <gz/common/EnumIface.hh>
#include <gz/common/Pbr.hh>
#include <gz/common/SuppressWarning.hh>
 
namespace ignition
{
  namespace common
  {
    // Forward declare private data class
    class MaterialPrivate;
 
    class IGNITION_COMMON_GRAPHICS_VISIBLE Material
    {
      public: enum ShadeMode
      {
        SHADE_MODE_BEGIN = 0,
 
        FLAT = 0,
 
        GOURAUD = 1,
 
        PHONG = 2,
 
        BLINN = 3,
 
        SHADE_MODE_END
      };
 
      public: enum BlendMode
      {
        BLEND_MODE_BEGIN = 0,
 
        ADD = 0,
 
        MODULATE = 1,
 
        REPLACE = 2,
 
        BLEND_MODE_END
      };
 
      public: Material();
 
      public: ~Material();
 
      public: explicit Material(const math::Color &_clr);
 
      public: std::string Name() const;
 
      public: void SetTextureImage(const std::string &_tex);
 
      public: void SetTextureImage(const std::string &_tex,
                                   const std::string &_resourcePath);
 
      public: std::string TextureImage() const;
 
      public: void SetAmbient(const math::Color &_clr);
 
      public: math::Color Ambient() const;
 
      public: void SetDiffuse(const math::Color &_clr);
 
      public: math::Color Diffuse() const;
 
      public: void SetSpecular(const math::Color &_clr);
 
      public: math::Color Specular() const;
 
      public: void SetEmissive(const math::Color &_clr);
 
      public: math::Color Emissive() const;
 
      public: void SetTransparency(double _t);
 
      public: double Transparency() const;
 
      public: void SetAlphaFromTexture(bool _enabled,
                  double _alpha = 0.5, bool _twoSided = true);
 
      public: bool TextureAlphaEnabled() const;
 
      public: double AlphaThreshold() const;
 
      public: bool TwoSidedEnabled() const;
 
      public: void SetRenderOrder(float _renderOrder);
 
      public: float RenderOrder() const;
 
      public: void SetShininess(double _t);
 
      public: double Shininess() const;
 
      public: void SetBlendFactors(double _srcFactor, double _dstFactor);
 
      public: void BlendFactors(double &_srcFactor, double &_dstFactor) const;
 
      public: void SetBlend(BlendMode _b);
 
      public: BlendMode Blend() const;
 
      public: std::string BlendStr() const;
 
      public: std::string ShadeStr() const;
 
      public: void SetShade(ShadeMode _b);
 
      public: ShadeMode Shade() const;
 
      public: void SetPointSize(double _size);
 
      public: double PointSize() const;
 
      public: void SetDepthWrite(bool _value);
 
      public: bool DepthWrite() const;
 
      public: void SetLighting(bool _value);
 
      public: bool Lighting() const;
 
      public: void SetPbrMaterial(const Pbr &_pbr);
 
      public: Pbr *PbrMaterial() const;
 
      public: friend std::ostream &operator<<(std::ostream &_out,
                  const gz::common::Material &_m)
              {
                _out << "Material:\n";
                _out << "  Name: " << _m.Name() << "\n";
                _out << "  Texture: " << _m.TextureImage() << "\n";
                _out << "  Ambient: " << _m.Ambient() << "\n";
                _out << "  Diffuse: " << _m.Diffuse() << "\n";
                _out << "  Specular: " << _m.Specular() << "\n";
                _out << "  Emissive: " << _m.Emissive() << "\n";
                _out << "  Transparency: " << _m.Transparency() << "\n";
                _out << "  Shininess: " << _m.Shininess() << "\n";
                _out << "  Render order: " << _m.RenderOrder() << "\n";
                _out << "  BlendMode: " << _m.BlendStr() << "\n";
                _out << "  ShadeMode: " << _m.ShadeStr() << "\n";
                _out << "  DepthWrite: " << _m.DepthWrite() << "\n";
                return _out;
              }
 
      IGN_COMMON_WARN_IGNORE__DLL_INTERFACE_MISSING
      private: std::unique_ptr<MaterialPrivate> dataPtr;
      IGN_COMMON_WARN_RESUME__DLL_INTERFACE_MISSING
    };
  }
}
#endif