GiMaterial.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef __ODGIMATERIAL_H__
#define __ODGIMATERIAL_H__
 
#include "TD_PackPush.h"
#include "RootExport.h"
#include "GiExport.h"
 
#include "CmColorBase.h"
#include "Ge/GeMatrix3d.h"
#include "Gi/GiDrawable.h"
#include "Gi/GiVariant.h"
 
class OdGiMaterialColor;
class OdGiMaterialMap;
class OdGiRasterImage;
 
class ODRX_ABSTRACT FIRSTDLL_EXPORT OdGiMaterialTraits : public OdGiDrawableTraits
{
public:
  ODRX_DECLARE_MEMBERS(OdGiMaterialTraits);
 
  enum IlluminationModel
  {
    kBlinnShader = 0, // Blinn shader uses the light's color to determine the reflection color.
    kMetalShader      // Metal shader calculates the reflected light's color using the material's diffuse color and the light's color. 
  };
 
  enum ChannelFlags
  {
    kNone           = 0x00000, // No material channels enabled.
    kUseDiffuse     = 0x00001, // Enables diffuse material channel.
    kUseSpecular    = 0x00002, // Enables specular material channel.
    kUseReflection  = 0x00004, // Enables reflection material channel.
    kUseOpacity     = 0x00008, // Enables opacity material channel.
    kUseBump        = 0x00010, // Enables bump material channel.
    kUseRefraction  = 0x00020, // Enables refraction material channel.
    kUseNormalMap   = 0x00040, // Enables normal map material channel.
    // BIM extensions
    kUseEmission    = 0x00080, // Enables emission material channel.
    kUseTint        = 0x00100, // Enables tint material channel.
 
    kUseAll         = (kUseDiffuse | kUseSpecular | kUseReflection |
                       kUseOpacity | kUseBump | kUseRefraction | kUseNormalMap), // Enables all material channels.
    kUseAllInternal = (kUseAll | kUseEmission | kUseTint) // Enables all material channels including extension channels.
  };
  
  enum Mode
  {
    kRealistic = 0, // Realistic material model.
    kAdvanced       // Advanced material model.
  };
 
  // Returned via subSetAttributes()
  enum
  {
    kByBlock    = (OdGiDrawable::kLastFlag << 1), // "ByBlock" material.
    kByLayer    = (OdGiDrawable::kLastFlag << 2)  // "ByLayer" material.
  };
 
  // Extended material traits enumerations
 
  enum LuminanceMode
  {
    kSelfIllumination = 0, // Compute luminance from self-illumination parameters.
    kLuminance,            // Use luminance specified by the setLuminance() method.
    kEmissionColor         // Compute luminance using an emission material channel.
  };
 
  enum NormalMapMethod
  {
    kTangentSpace   // Method of tangent spaces is used to compute the normal map.
  };
 
  enum GlobalIlluminationMode
  {
    kGlobalIlluminationNone,          // No global illumination.
    kGlobalIlluminationCast,          // The global illumination is casting light. 
    kGlobalIlluminationReceive,       // The global illumination is receiving light.
    kGlobalIlluminationCastAndReceive // The global illumination is casting and receiving light.
  };
 
  enum FinalGatherMode
  {
    kFinalGatherNone,               // No final gathering.
    kFinalGatherCast,               // The final gathering is casting.
    kFinalGatherReceive,            // The final gathering is receiving.
    kFinalGatherCastAndReceive      // The final gathering is casting and receiving.
  };
 
  // BIM extensions
  enum DiffuseColorMode
  {
    kDiffuseRealisticColor = 0, // Use the color specified in the diffuse material channel.
    kDiffuseShadingColor,       // Use the color specified by the setShadingDiffuse() method.
    kDiffuseStyleDependent      // Chosen color depends on the active visual style.
  };
 
  virtual void ambient(OdGiMaterialColor& ambientColor) const = 0;
 
  virtual void diffuse(OdGiMaterialColor& diffuseColor, OdGiMaterialMap& diffuseMap) const = 0;
 
  virtual void specular(OdGiMaterialColor& specularColor, OdGiMaterialMap& specularMap, double& glossFactor) const = 0;
 
  virtual void reflection(OdGiMaterialMap& reflectionMap) const = 0;
 
  virtual void opacity(double& opacityPercentage, OdGiMaterialMap& opacityMap) const = 0;
 
  virtual void bump(OdGiMaterialMap& bumpMap) const = 0;
 
  virtual void refraction(double& refractionIndex, OdGiMaterialMap& refractionMap) const = 0;
 
  virtual double translucence() const = 0;
 
  virtual double selfIllumination() const = 0;
 
  virtual double reflectivity() const = 0;
 
  virtual IlluminationModel illuminationModel() const = 0;
 
  virtual ChannelFlags channelFlags() const = 0;
 
  virtual Mode mode() const = 0;
 
  virtual void setAmbient(const OdGiMaterialColor& ambientColor) = 0;
 
  virtual void setDiffuse(const OdGiMaterialColor& diffuseColor, const OdGiMaterialMap& diffuseMap) = 0;
 
  virtual void setSpecular(const OdGiMaterialColor& specularColor, const OdGiMaterialMap& specularMap, double glossFactor) = 0;
 
  virtual void setReflection(const OdGiMaterialMap& reflectionMap) = 0;
 
  virtual void setOpacity(double opacityPercentage, const OdGiMaterialMap& opacityMap) = 0;
 
  virtual void setBump(const OdGiMaterialMap& bumpMap) = 0;
 
  virtual void setRefraction(double refractionIndex, const OdGiMaterialMap& refractionMap) = 0;
 
  virtual void setTranslucence(double value) = 0;
 
  virtual void setSelfIllumination(double value) = 0;
 
  virtual void setReflectivity(double value) = 0;
 
  virtual void setIlluminationModel(IlluminationModel model) = 0;
 
  virtual void setChannelFlags(ChannelFlags flags) = 0;
 
  virtual void setMode(Mode value) = 0;
 
  // Extended material properties
 
  virtual void setColorBleedScale(double scale) = 0;
 
  virtual double colorBleedScale() const = 0;
 
  virtual void setIndirectBumpScale(double scale) = 0;
 
  virtual double indirectBumpScale() const = 0;
 
  virtual void setReflectanceScale(double scale) = 0;
 
  virtual double reflectanceScale() const = 0;
 
  virtual void setTransmittanceScale(double scale) = 0;
 
  virtual double transmittanceScale() const = 0;
 
  virtual void setTwoSided(bool flag) = 0;
 
  virtual bool twoSided() const = 0;
 
  virtual void setLuminanceMode(LuminanceMode mode) = 0;
 
  virtual LuminanceMode luminanceMode() const = 0;
 
  virtual void setLuminance(double value) = 0;
 
  virtual double luminance() const = 0;
 
  virtual void setNormalMap(const OdGiMaterialMap &normalMap, NormalMapMethod method, double strength) = 0;
 
  virtual void normalMap(OdGiMaterialMap &normalMap, NormalMapMethod &method, double &strength) const = 0;
 
  virtual void setGlobalIllumination(GlobalIlluminationMode mode) = 0;
 
  virtual GlobalIlluminationMode globalIllumination() const = 0;
 
  virtual void setFinalGather(FinalGatherMode mode) = 0;
 
  virtual FinalGatherMode finalGather() const = 0;
 
  // BIM extensions
 
  virtual void setEmission(const OdGiMaterialColor& emissionColor, const OdGiMaterialMap& emissionMap) = 0;
 
  virtual void emission(OdGiMaterialColor& emissionColor, OdGiMaterialMap& emissionMap) const = 0;
 
  virtual void setTint(const OdGiMaterialColor& tintColor) = 0;
 
  virtual void tint(OdGiMaterialColor& tintColor) const = 0;
 
  virtual void setShadingAmbient(const OdGiMaterialColor& ambientColor) = 0;
 
  virtual void shadingAmbient(OdGiMaterialColor& ambientColor) const = 0;
 
  virtual void setShadingDiffuse(const OdGiMaterialColor& diffuseColor) = 0;
 
  virtual void shadingDiffuse(OdGiMaterialColor& diffuseColor) const = 0;
 
  virtual void setShadingSpecular(const OdGiMaterialColor& specularColor) = 0;
 
  virtual void shadingSpecular(OdGiMaterialColor& specularColor) const = 0;
 
  virtual void setShadingOpacity(double opacityPercentage) = 0;
 
  virtual void shadingOpacity(double &opacityPercentage) const = 0;
 
  virtual void setDiffuseColorMode(DiffuseColorMode diffuseColorMode) = 0;
 
  virtual DiffuseColorMode diffuseColorMode() const = 0;
};
 
typedef OdSmartPtr<OdGiMaterialTraits> OdGiMaterialTraitsPtr;
 
 
class ODGI_EXPORT OdGiMaterialColor
{
public:
  enum Method
  {
    kInherit  = 0, // Uses the current drawing color.
    kOverride = 1  // Uses the color set with setColor().
  };
 
  ODGI_EXPORT_STATIC static const OdGiMaterialColor kNull;
 
  OdGiMaterialColor();
 
  OdGiMaterialColor(const OdCmEntityColor &overrideColor);
 
  void setMethod(Method method);
 
  void setFactor(double factor);
 
  OdCmEntityColor& color();
 
  Method method() const;
 
  double factor() const;
 
  const OdCmEntityColor& color() const;
 
  bool operator ==(const OdGiMaterialColor &other) const
  {
    return (m_method == other.m_method) &&
           (m_factor == other.m_factor) &&
           (m_color  == other.m_color);      
  }
  bool operator != (const OdGiMaterialColor &other) const
  {
    return (m_method != other.m_method) ||
           (m_factor != other.m_factor) ||
           (m_color  != other.m_color);      
  }
 
  void setColor(const OdCmEntityColor &color);
 
private:
  Method          m_method;
  double          m_factor;
  OdCmEntityColor m_color;
};
 
 
class ODRX_ABSTRACT FIRSTDLL_EXPORT OdGiMaterialTexture : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiMaterialTexture);
  virtual bool operator==(const OdGiMaterialTexture & texture)const;
protected:
  OdGiMaterialTexture() { }
  ~OdGiMaterialTexture() { }
};
 
inline bool OdGiMaterialTexture::operator==(const OdGiMaterialTexture & texture) const {
  return (texture.isA() == isA());
}
 
typedef OdSmartPtr<OdGiMaterialTexture> OdGiMaterialTexturePtr;
 
class ODRX_ABSTRACT FIRSTDLL_EXPORT OdGiImageTexture : public OdGiMaterialTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiImageTexture);
protected:
  OdGiImageTexture() { }
  ~OdGiImageTexture() { }
};
 
typedef OdSmartPtr<OdGiImageTexture> OdGiImageTexturePtr;
 
class FIRSTDLL_EXPORT OdGiImageFileTexture : public OdGiImageTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiImageFileTexture);
 
  virtual void setSourceFileName(const OdString& fileName);
  
  virtual const OdString sourceFileName() const;
 
  virtual bool operator==(const OdGiMaterialTexture & texture) const;
  OdGiImageFileTexture &operator =(const OdGiImageFileTexture &texture);
 
  // OdRxObject overrides
 
  void copyFrom(const OdRxObject* pSource);
private:
  OdString m_sourceFileName;
};
 
typedef OdSmartPtr<OdGiImageFileTexture> OdGiImageFileTexturePtr;
 
class FIRSTDLL_EXPORT OdGiRasterImageTexture : public OdGiImageTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiRasterImageTexture);
  virtual void setRasterImage(const OdGiRasterImage *pRasterImage);
 
  virtual const OdGiRasterImage *rasterImage() const;
 
  virtual bool operator==(const OdGiMaterialTexture & texture) const;
  OdGiRasterImageTexture &operator =(const OdGiRasterImageTexture &texture);
 
  void copyFrom(const OdRxObject* pSource);
private:
  OdRxObjectPtr m_pRasterImage;
};
 
typedef OdSmartPtr<OdGiRasterImageTexture> OdGiRasterImageTexturePtr;
 
class ODRX_ABSTRACT FIRSTDLL_EXPORT OdGiProceduralTexture : public OdGiMaterialTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiProceduralTexture);
 
  enum Type
  {
    kWood    = 0, // Wood texture.
    kMarble  = 1, // Marble texture.
    kGeneric = 2  // Generic texture.
  };
 
  virtual Type type() const = 0;
protected:
  OdGiProceduralTexture() { }
  ~OdGiProceduralTexture() { }
};
 
typedef OdSmartPtr<OdGiProceduralTexture> OdGiProceduralTexturePtr;
 
class FIRSTDLL_EXPORT OdGiWoodTexture : public OdGiProceduralTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiWoodTexture);
 
  OdGiWoodTexture();
  
  virtual Type type() const  {return kWood;}
 
  // wood properties
 
  virtual void setColor1(const OdGiMaterialColor &woodColor1);
  
  virtual const OdGiMaterialColor& color1(void) const;
 
  virtual void setColor2(const OdGiMaterialColor &woodColor2);
  
  virtual const OdGiMaterialColor& color2(void) const;
 
  virtual void setRadialNoise(double radialNoise);
    
  virtual double radialNoise(void) const;
 
  virtual void setAxialNoise(double axialNoise);
  
  virtual double axialNoise(void) const;
 
  virtual void setGrainThickness(double grainThickness);
  
  virtual double grainThickness(void) const;
 
  virtual bool operator==(const OdGiMaterialTexture & texture) const;
  OdGiWoodTexture &operator =(const OdGiWoodTexture &texture);
 
  // OdRxObject overrides
 
  void copyFrom(const OdRxObject* pSource);
private:
  OdGiMaterialColor m_color1;
  OdGiMaterialColor m_color2;
  double            m_radialNoise;
  double            m_axialNoise;
  double            m_grainThickness;
};
 
typedef OdSmartPtr<OdGiWoodTexture> OdGiWoodTexturePtr;
 
class FIRSTDLL_EXPORT OdGiMarbleTexture : public OdGiProceduralTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiMarbleTexture);
 
  OdGiMarbleTexture();
 
  virtual Type type() const  {return kMarble;}
 
  virtual void setStoneColor(const OdGiMaterialColor &stoneColor);
  
  virtual const OdGiMaterialColor& stoneColor(void) const;
 
  virtual void setVeinColor(const OdGiMaterialColor &veinColor);
  
  virtual const OdGiMaterialColor& veinColor(void) const;
 
  virtual void setVeinSpacing(double veinSpacing);
  
  virtual double veinSpacing(void) const;
 
  virtual void setVeinWidth(double veinWidth);
  
  virtual double veinWidth(void) const;
 
  virtual bool operator==(const OdGiMaterialTexture & texture) const;
  OdGiMarbleTexture &operator =(const OdGiMarbleTexture &texture);
 
  // OdRxObject overrides
 
  void copyFrom(const OdRxObject* pSource);
private:
  OdGiMaterialColor m_stoneColor;
  OdGiMaterialColor m_veinColor;
  double            m_veinSpacing;
  double            m_veinWidth;
};
 
typedef OdSmartPtr<OdGiMarbleTexture> OdGiMarbleTexturePtr;
 
class FIRSTDLL_EXPORT OdGiGenericTexture : public OdGiProceduralTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiGenericTexture);
 
  OdGiGenericTexture();
  
  virtual Type type() const  {return kGeneric;}
 
  virtual void setDefinition(const OdGiVariant &definition);
  
  virtual OdGiVariantPtr definition() const;
  
  virtual void definition(OdGiVariantPtr &pDefinition) const;
 
  virtual bool operator==(const OdGiMaterialTexture & texture) const;
  OdGiGenericTexture &operator =(const OdGiGenericTexture &texture);
 
  // OdRxObject overrides
 
  void copyFrom(const OdRxObject* pSource);
private:
  OdGiVariantPtr    m_definition;
};
 
typedef OdSmartPtr<OdGiGenericTexture> OdGiGenericTexturePtr;
 
 
class ODGI_EXPORT OdGiMapper
{
public:
  enum Projection
  {
    kInheritProjection   = 0, // Inherits projection from the current material's mapper.
    kPlanar              = 1, // Maps directly to XY coordinates.
    kBox                 = 2, // Maps to planes perpendicular to major axes.
    kCylinder            = 3, // Maps to cylinders aligned with the Z-axis.
    kSphere              = 4, // Maps to spheres aligned with the Z-axis.
 
    kDgnParametric       = 0x32, // Maps directly to surface coordinates. For .dgn materials.
    kDgnPlanar           = 0x33, // Maps directly to surface coordinates. For .dgn materials.
    kDgnCylinder         = 0x34, // Maps to cylinders aligned with the Z-axis. For .dgn materials.
    kDgnCylinderCapped   = 0x35, // Maps to cylinders aligned with the Z-axis. If normal to surface is the same as Z-axis,
                                 // then uses planar mapping. For .dgn materials.
    kDgnSphere           = 0x36  // Maps to spheres aligned with the Z-axis. For .dgn materials.
  };
 
  enum Tiling
  {
    kInheritTiling    = 0, // Inherits tiling from the current material's mapper.
    kTile             = 1, // Repeats map along image axes.
    kCrop             = 2, // Crops map < 0.0 or > 1.0 on image axes.
    kClamp            = 3, // Clamps (stretches) map between 0.0 and 1.0 on image axes.
    kMirror           = 4  // Mirrors the material map at every integer boundary.
  };
 
  enum AutoTransform
  {
    kInheritAutoTransform = 0x0, // Inherits automatic transform mode from the current material's mapper.
    kNone                 = 0x1, // No automatic transform.
    kObject               = 0x2, // Adjusts the mapper transform to align with and fit the current object.
    kModel                = 0x4  // Multiplies the mapper transform by the current block transform.
  };
 
  ODGI_EXPORT_STATIC static const OdGiMapper kIdentity;
 
  OdGiMapper()
    : m_projection(kPlanar)
    , m_uTiling(kTile)
    , m_vTiling(kTile)
    , m_autoTransform(kNone)
  {
  }
 
  OdGiMapper (const OdGiMapper& mapper);
  OdGiMapper& operator=(const OdGiMapper& mapper);
  bool operator==(const OdGiMapper& mapper) const;
  bool operator!=(const OdGiMapper& mapper) const;
 
  void setProjection(Projection projection);
 
  void setUTiling(Tiling tiling);
 
  void setVTiling(Tiling tiling);
 
  void setAutoTransform(AutoTransform autoTransform);
 
  OdGeMatrix3d& transform();
 
  Projection projection() const;
 
  Tiling uTiling() const;
 
  Tiling vTiling() const;
 
  AutoTransform autoTransform() const;
 
  const OdGeMatrix3d& transform() const;
 
  void setTransform(const OdGeMatrix3d &tm);
 
private:
  Projection    m_projection;
  Tiling        m_uTiling;
  Tiling        m_vTiling;
  AutoTransform m_autoTransform;
  OdGeMatrix3d  m_transform;
};
 
 
class ODGI_EXPORT OdGiMaterialMap
{
public:
  
  enum Source
  {
    kScene      = 0,  // Map is created from the current scene.
    kFile       = 1,  // Map is from a file.
    kProcedural = 2   // Map is procedural.
  };
 
  ODGI_EXPORT_STATIC static const OdGiMaterialMap kNull;
 
  OdGiMaterialMap();
 
  void setSource(Source source);
 
  void setSourceFileName(const OdString& filename);
 
  void setBlendFactor(double blendFactor);
 
  void setTexture(OdGiMaterialTexturePtr pTexture);
 
  OdGiMapper& mapper();
 
  Source source() const;
 
  OdString sourceFileName() const;
 
  double blendFactor() const;
 
  const OdGiMapper& mapper() const;
 
  void setMapper(const OdGiMapper &mapper);
 
  const OdGiMaterialTexturePtr  texture(void) const;
 
  bool operator ==(const OdGiMaterialMap &other) const
  {
    if ((m_source      == other.m_source)      &&
        (m_fileName    == other.m_fileName)    &&
        (m_blendFactor == other.m_blendFactor) &&
        (m_mapper      == other.m_mapper))
    {
      if (m_texture.isNull() && other.m_texture.isNull())
        return true;
      if (!m_texture.isNull() && !other.m_texture.isNull())
        return (*m_texture == *(other.m_texture));
    }
    return false;
  }
  bool operator !=(const OdGiMaterialMap &other) const
  {
    return !(*this == other);
  }
 
  OdGiMaterialMap &operator =(const OdGiMaterialMap& mmap)
  {
    m_source = mmap.m_source;
    m_fileName = mmap.m_fileName;
    m_blendFactor = mmap.m_blendFactor;
    m_mapper = mmap.m_mapper;
    m_texture = mmap.m_texture;
    return *this;
  }
private:
  Source     m_source;
  OdString   m_fileName;
  double     m_blendFactor;
  OdGiMapper m_mapper;
  OdGiMaterialTexturePtr m_texture;
};
 
// OdGiMaterialColor inline implementations
 
inline
OdGiMaterialColor::OdGiMaterialColor()
  : m_method(kInherit)
  , m_factor(1.0)
{
}
 
inline
OdGiMaterialColor::OdGiMaterialColor(const OdCmEntityColor &overrideColor)
  : m_method(kOverride)
  , m_factor(1.0)
  , m_color(overrideColor)
{
}
 
inline void
OdGiMaterialColor::setMethod(Method method)
{
  m_method = method;
}
 
inline void
OdGiMaterialColor::setFactor(double factor)
{
  m_factor = factor;
}
 
inline OdCmEntityColor&
OdGiMaterialColor::color()
{
  return m_color;
}
 
inline OdGiMaterialColor::Method
OdGiMaterialColor::method() const
{
  return m_method;
}
 
inline double
OdGiMaterialColor::factor() const
{
  return m_factor;
}
 
inline const OdCmEntityColor&
OdGiMaterialColor::color() const
{
  return m_color;
}
 
inline void
OdGiMaterialColor::setColor(const OdCmEntityColor &color)
{
  m_color = color;
}
 
// OdGiMaterialMap inline implementations
 
inline
OdGiMaterialMap::OdGiMaterialMap()
  : m_source(kFile)
  , m_blendFactor(1.0)
{
}
 
inline void
OdGiMaterialMap::setSource(Source source)
{
  m_source = source;
}
 
inline void
OdGiMaterialMap::setSourceFileName(const OdString& filename)
{
  m_fileName = filename;
}
 
inline void
OdGiMaterialMap::setBlendFactor(double blendFactor)
{
  m_blendFactor = blendFactor;
}
 
inline OdGiMapper&
OdGiMaterialMap::mapper()
{
  return m_mapper;
}
 
inline OdGiMaterialMap::Source
OdGiMaterialMap::source() const
{
  return m_source;
}
 
inline OdString
OdGiMaterialMap::sourceFileName() const
{
  return m_fileName;
}
 
inline double
OdGiMaterialMap::blendFactor() const
{
  return m_blendFactor;
}
 
inline const OdGiMapper&
OdGiMaterialMap::mapper() const
{
  return m_mapper;
}
 
inline void
OdGiMaterialMap::setMapper(const OdGiMapper &mapper)
{
  m_mapper = mapper;
}
 
inline void
OdGiMaterialMap::setTexture(OdGiMaterialTexturePtr pTexture)
{
  m_texture = pTexture;
}
 
inline const OdGiMaterialTexturePtr
OdGiMaterialMap::texture(void) const
{
  return m_texture;
}
 
// OdGiMapper inline implementations
 
inline
OdGiMapper::OdGiMapper(const OdGiMapper& mapper)
  : m_projection(mapper.m_projection)
  , m_uTiling(mapper.m_uTiling)
  , m_vTiling(mapper.m_vTiling)
  , m_autoTransform(mapper.m_autoTransform)
  , m_transform(mapper.m_transform)
{
}
 
inline OdGiMapper&
OdGiMapper::operator=(const OdGiMapper& mapper)
{
  if (&mapper != this)
  {
    m_projection = mapper.m_projection;
    m_uTiling = mapper.m_uTiling;
    m_vTiling = mapper.m_vTiling;
    m_autoTransform = mapper.m_autoTransform;
    m_transform = mapper.m_transform;
  }
  return *this;
}
 
inline bool
OdGiMapper::operator==(const OdGiMapper& mapper) const
{
  return m_projection == mapper.m_projection
    && m_uTiling == mapper.m_uTiling
    && m_vTiling == mapper.m_vTiling
    && m_autoTransform == mapper.m_autoTransform
    && m_transform == mapper.m_transform;
}
 
inline bool
OdGiMapper::operator!=(const OdGiMapper& mapper) const
{
  return !(*this == mapper);
}
 
inline void
OdGiMapper::setProjection(Projection projection)
{
  m_projection = projection;
}
 
inline void
OdGiMapper::setUTiling(Tiling tiling)
{
  m_uTiling = tiling;
}
 
inline void
OdGiMapper::setVTiling(Tiling tiling)
{
  m_vTiling = tiling;
}
 
inline void
OdGiMapper::setAutoTransform(AutoTransform autoTransform)
{
  m_autoTransform = autoTransform;
}
 
inline OdGiMapper::Projection
OdGiMapper::projection() const
{
  return m_projection;
}
 
inline OdGiMapper::Tiling
OdGiMapper::uTiling() const
{
  return m_uTiling;
}
 
inline OdGiMapper::Tiling
OdGiMapper::vTiling() const
{
  return m_vTiling;
}
 
inline OdGiMapper::AutoTransform
OdGiMapper::autoTransform() const
{
  return m_autoTransform;
}
 
inline const OdGeMatrix3d&
OdGiMapper::transform() const
{
  return m_transform;
}
 
inline OdGeMatrix3d&
OdGiMapper::transform()
{
  return m_transform;
}
 
inline void
OdGiMapper::setTransform(const OdGeMatrix3d &tm)
{
  transform() = tm;
}
 
// OdGiImageFileTexture inline implementations
 
inline void
OdGiImageFileTexture::setSourceFileName(const OdString& fileName)
{
  m_sourceFileName = fileName;
}
 
inline const OdString
OdGiImageFileTexture::sourceFileName() const
{
  return m_sourceFileName;
}
 
inline bool
OdGiImageFileTexture::operator==(const OdGiMaterialTexture & texture) const
{
  if (!(texture.isA() == isA()))
    return false;
  const OdGiImageFileTexture &refTexture = static_cast<const OdGiImageFileTexture&>(texture);
  return m_sourceFileName == refTexture.m_sourceFileName;
}
 
inline OdGiImageFileTexture &
OdGiImageFileTexture::operator =(const OdGiImageFileTexture &texture)
{
  m_sourceFileName = texture.m_sourceFileName;
  return *this;
}
 
inline void OdGiImageFileTexture::copyFrom(const OdRxObject* pSource)
{
  OdGiImageFileTexturePtr pSrcTex = OdGiImageFileTexture::cast(pSource);
  if (!pSrcTex.isNull())
  {
    setSourceFileName(pSrcTex->sourceFileName());
  }
  else
  {
    throw OdError(eNotApplicable);
  }
}
 
// OdGiRasterImageTexture inline implementations
 
inline void
OdGiRasterImageTexture::setRasterImage(const OdGiRasterImage *pRasterImage)
{
  m_pRasterImage = reinterpret_cast<const OdRxObject*>(pRasterImage);
}
 
inline const OdGiRasterImage *
OdGiRasterImageTexture::rasterImage() const
{
  return reinterpret_cast<const OdGiRasterImage*>(m_pRasterImage.get());
}
 
inline bool
OdGiRasterImageTexture::operator==(const OdGiMaterialTexture & texture) const
{
  if (!(texture.isA() == isA()))
    return false;
  const OdGiRasterImageTexture &refTexture = static_cast<const OdGiRasterImageTexture&>(texture);
  return m_pRasterImage.get() == refTexture.m_pRasterImage.get();
}
 
inline OdGiRasterImageTexture &
OdGiRasterImageTexture::operator =(const OdGiRasterImageTexture &texture)
{
  m_pRasterImage = texture.m_pRasterImage;
  return *this;
}
 
inline void OdGiRasterImageTexture::copyFrom(const OdRxObject* pSource)
{
  OdGiRasterImageTexturePtr pSrcTex = OdGiRasterImageTexture::cast(pSource);
  if (!pSrcTex.isNull())
  {
    setRasterImage(pSrcTex->rasterImage());
  }
  else
  {
    throw OdError(eNotApplicable);
  }
}
 
// OdGiWoodTexture inline implementations
 
inline
OdGiWoodTexture::OdGiWoodTexture()
  : m_radialNoise(0.)
  , m_axialNoise(0.)
  , m_grainThickness(0.)
{
}
 
inline void
OdGiWoodTexture::setColor1(const OdGiMaterialColor &woodColor1)
{
  m_color1 = woodColor1;
}
 
inline const OdGiMaterialColor&
OdGiWoodTexture::color1(void) const
{
  return m_color1;
}
 
inline void
OdGiWoodTexture::setColor2(const OdGiMaterialColor &woodColor2)
{
  m_color2 = woodColor2;
}
 
inline const OdGiMaterialColor&
OdGiWoodTexture::color2(void) const
{
  return m_color2;
}
 
inline void
OdGiWoodTexture::setRadialNoise(double radialNoise)
{
  m_radialNoise = radialNoise;
}
 
inline double
OdGiWoodTexture::radialNoise(void) const
{
  return m_radialNoise;
}
 
inline void
OdGiWoodTexture::setAxialNoise(double axialNoise)
{
  m_axialNoise = axialNoise;
}
 
inline double
OdGiWoodTexture::axialNoise(void) const
{
  return m_axialNoise;
}
 
inline void
OdGiWoodTexture::setGrainThickness(double grainThickness)
{
  m_grainThickness = grainThickness;
}
 
inline double
OdGiWoodTexture::grainThickness(void) const
{
  return m_grainThickness;
}
 
inline bool
OdGiWoodTexture::operator==(const OdGiMaterialTexture & texture) const
{
  if (!(texture.isA() == isA()))
    return false;
  const OdGiWoodTexture &refTexture = static_cast<const OdGiWoodTexture&>(texture);
  return (m_color1 == refTexture.m_color1) &&
         (m_color2 == refTexture.m_color2) &&
         (m_radialNoise == refTexture.m_radialNoise) &&
         (m_axialNoise == refTexture.m_axialNoise) &&
         (m_grainThickness == refTexture.m_grainThickness);
}
 
inline OdGiWoodTexture &
OdGiWoodTexture::operator =(const OdGiWoodTexture &texture)
{
  m_color1 = texture.m_color1;
  m_color2 = texture.m_color2;
  m_radialNoise = texture.m_radialNoise;
  m_axialNoise = texture.m_axialNoise;
  m_grainThickness = texture.m_grainThickness;
  return *this;
}
 
inline void OdGiWoodTexture::copyFrom(const OdRxObject* pSource)
{
  OdGiWoodTexturePtr pSrcTex = OdGiWoodTexture::cast(pSource);
  if (!pSrcTex.isNull())
  {
    setColor1(pSrcTex->color1());
    setColor2(pSrcTex->color2());
    setRadialNoise(pSrcTex->radialNoise());
    setAxialNoise(pSrcTex->axialNoise());
    setGrainThickness(pSrcTex->grainThickness());
  }
  else
  {
    throw OdError(eNotApplicable);
  }
}
 
// OdGiMarbleTexture inline implementations
 
inline
OdGiMarbleTexture::OdGiMarbleTexture()
  : m_veinSpacing(0.)
  , m_veinWidth(0.)
{
}
 
inline void
OdGiMarbleTexture::setStoneColor(const OdGiMaterialColor &stoneColor)
{
  m_stoneColor = stoneColor;
}
 
inline const OdGiMaterialColor&
OdGiMarbleTexture::stoneColor(void) const
{
  return m_stoneColor;
}
 
inline void
OdGiMarbleTexture::setVeinColor(const OdGiMaterialColor &veinColor)
{
  m_veinColor = veinColor;
}
 
inline const OdGiMaterialColor&
OdGiMarbleTexture::veinColor(void) const
{
  return m_veinColor;
}
 
inline void
OdGiMarbleTexture::setVeinSpacing(double veinSpacing)
{
  m_veinSpacing = veinSpacing;
}
 
inline double
OdGiMarbleTexture::veinSpacing(void) const
{
  return m_veinSpacing;
}
 
inline void
OdGiMarbleTexture::setVeinWidth(double veinWidth)
{
  m_veinWidth = veinWidth;
}
 
inline double
OdGiMarbleTexture::veinWidth(void) const
{
  return m_veinWidth;
}
 
inline bool
OdGiMarbleTexture::operator==(const OdGiMaterialTexture & texture) const
{
  if (!(texture.isA() == isA()))
    return false;
  const OdGiMarbleTexture &refTexture = static_cast<const OdGiMarbleTexture&>(texture);
  return (m_stoneColor == refTexture.m_stoneColor) &&
         (m_veinColor == refTexture.m_veinColor) &&
         (m_veinSpacing == refTexture.m_veinSpacing) &&
         (m_veinWidth == refTexture.m_veinWidth);
}
 
inline OdGiMarbleTexture &
OdGiMarbleTexture::operator =(const OdGiMarbleTexture &texture)
{
  m_stoneColor = texture.m_stoneColor;
  m_veinColor = texture.m_veinColor;
  m_veinSpacing = texture.m_veinSpacing;
  m_veinWidth = texture.m_veinWidth;
  return *this;
}
 
inline void OdGiMarbleTexture::copyFrom(const OdRxObject* pSource)
{
  OdGiMarbleTexturePtr pSrcTex = OdGiMarbleTexture::cast(pSource);
  if (!pSrcTex.isNull())
  {
    setStoneColor(pSrcTex->stoneColor());
    setVeinColor(pSrcTex->veinColor());
    setVeinSpacing(pSrcTex->veinSpacing());
    setVeinWidth(pSrcTex->veinWidth());
  }
  else
  {
    throw OdError(eNotApplicable);
  }
}
 
// OdGiGenericTexture inline implementations
 
inline
OdGiGenericTexture::OdGiGenericTexture()
{
}
 
inline void
OdGiGenericTexture::setDefinition(const OdGiVariant &definition)
{
  if (m_definition.isNull())
  {
    m_definition = OdGiVariant::createObject(definition);
  }
  else
  {
    *m_definition = definition;
  }
}
 
inline OdGiVariantPtr
OdGiGenericTexture::definition() const
{
  return m_definition;
}
 
inline void
OdGiGenericTexture::definition(OdGiVariantPtr &pDefinition) const
{
  if (m_definition.isNull())
  {
    pDefinition = OdGiVariant::createObject();
  }
  else
  {
    pDefinition = OdGiVariant::createObject(*m_definition);
  }
}
 
inline bool
OdGiGenericTexture::operator==(const OdGiMaterialTexture & texture) const
{
  if (!(texture.isA() == isA()))
    return false;
  const OdGiGenericTexture &refTexture = static_cast<const OdGiGenericTexture&>(texture);
  if (m_definition.isNull() && refTexture.m_definition.isNull())
    return true;
  if (!m_definition.isNull() && !refTexture.m_definition.isNull())
    return (*m_definition == *(refTexture.m_definition));
  return false;
}
 
inline OdGiGenericTexture &
OdGiGenericTexture::operator =(const OdGiGenericTexture &texture)
{
  if (!texture.m_definition.isNull())
    m_definition = OdGiVariant::createObject(*(texture.m_definition));
  else
    m_definition.release();
  return *this;
}
 
inline void OdGiGenericTexture::copyFrom(const OdRxObject* pSource)
{
  OdGiGenericTexturePtr pSrcTex = OdGiGenericTexture::cast(pSource);
  if (!pSrcTex.isNull())
  {
    setDefinition(*(pSrcTex->definition()));
  }
  else
  {
    throw OdError(eNotApplicable);
  }
}
 
#include "TD_PackPop.h"
 
#endif //#ifndef __ODGIMATERIAL_H__