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 IGNITION_COMMON_MATERIAL_HH_
#define IGNITION_COMMON_MATERIAL_HH_

#include <iostream>
#include <memory>
#include <string>

#include <ignition/math/Color.hh>
#include <ignition/common/graphics/Export.hh>
#include <ignition/common/EnumIface.hh>
#include <ignition/common/Pbr.hh>
#include <ignition/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 ignition::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