GiMaterial.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 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,
    kMetalShader
  };

  enum ChannelFlags
  {
    kNone           = 0x00000,
    kUseDiffuse     = 0x00001,
    kUseSpecular    = 0x00002,
    kUseReflection  = 0x00004,
    kUseOpacity     = 0x00008,
    kUseBump        = 0x00010,
    kUseRefraction  = 0x00020,
    kUseNormalMap   = 0x00040,
    // BIM extensions
    kUseEmission    = 0x00080,
    kUseTint        = 0x00100,
    kUseRoughness   = 0x00200,
    kUseCutouts     = 0x00400,
    kUseAll         = (kUseDiffuse | kUseSpecular | kUseReflection |
                       kUseOpacity | kUseBump | kUseRefraction | kUseNormalMap),
    kUseAllInternal = (kUseAll | kUseEmission | kUseTint | kUseRoughness | kUseCutouts)
  };
  
  enum Mode
  {
    kRealistic = 0,
    kAdvanced
  };
 
  // Returned via subSetAttributes()
  enum
  {
    kByBlock    = (OdGiDrawable::kLastFlag << 1), // "ByBlock" material.
    kByLayer    = (OdGiDrawable::kLastFlag << 2)  // "ByLayer" material.
  };
 
  // Extended material traits enumerations

  enum LuminanceMode
  {
    kSelfIllumination = 0,
    kLuminance,
    kEmissionColor
  };

  enum NormalMapMethod
  {
    kTangentSpace,
    kReliefPattern
  };

  enum GlobalIlluminationMode
  {
    kGlobalIlluminationNone,
    kGlobalIlluminationCast,
    kGlobalIlluminationReceive,
    kGlobalIlluminationCastAndReceive
  };

  enum FinalGatherMode
  {
    kFinalGatherNone,
    kFinalGatherCast,
    kFinalGatherReceive,
    kFinalGatherCastAndReceive
  };
 
  // BIM extensions
  enum DiffuseColorMode
  {
    kDiffuseRealisticColor = 0,
    kDiffuseShadingColor,
    kDiffuseStyleDependent
  };

  enum ReflectionMethod
  {
    kRayTracedReflections,
    kEnvironmentReflection
  };

  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;
 
  // Visualize extensions

  virtual void setShadowsOpacityEffect(double effectPercentage, double nonShadowLightsMergeEffect = 1.0) = 0;

  virtual double shadowsOpacityEffect(double &nonShadowLightsMergeEffect) const = 0;

  virtual void setSpecularHighlightingOverride(double overrideVal) = 0;

  virtual double specularHighlightingOverride() const = 0;

  virtual void setRoughness(const OdGiMaterialMap& roughnessMap, double strength) = 0;

  virtual void roughness(OdGiMaterialMap& roughnessMap, double &strength) const = 0;

  virtual void setCutouts(const OdGiMaterialMap& cutoutsMap) = 0;

  virtual void cutouts(OdGiMaterialMap& cutoutsMap) const = 0;

  virtual void setReflectionMethod(ReflectionMethod method) = 0;

  virtual ReflectionMethod reflectionMethod() const = 0;
};

typedef OdSmartPtr<OdGiMaterialTraits> OdGiMaterialTraitsPtr;
 

class ODGI_EXPORT OdGiMaterialColor
{
public:
  enum Method
  {
    kInherit  = 0,
    kOverride = 1,
    kBlend    = 2
  };

  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);

  void setBlendFactor(double factor);

  double blendFactor() const;
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 FIRSTDLL_EXPORT OdGiRasterImageFileTexture : public OdGiImageFileTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiRasterImageFileTexture);
  virtual void setRasterImage(const OdGiRasterImage *pRasterImage);

  virtual const OdGiRasterImage *rasterImage() const;

  virtual void setRasterImageTexture(const OdGiRasterImageTexture *pRasterImage);

  virtual const OdGiRasterImageTexture *rasterImageTexture() const;

  virtual bool operator==(const OdGiMaterialTexture & texture) const;
  
  OdGiRasterImageFileTexture &operator =(const OdGiRasterImageFileTexture &texture);

  void copyFrom(const OdRxObject* pSource);
private:
  OdGiRasterImageTexturePtr m_pRasterImage;
};

typedef OdSmartPtr<OdGiRasterImageFileTexture> OdGiRasterImageFileTexturePtr;

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 ODRX_ABSTRACT FIRSTDLL_EXPORT OdGiSceneTexture : public OdGiMaterialTexture
{
public:
  ODRX_DECLARE_MEMBERS(OdGiSceneTexture);

  OdGiSceneTexture() : m_softness(0) { }
  
  ~OdGiSceneTexture() { }

  void setSoftness(OdUInt8 softness) { m_softness = softness; }
  
  OdUInt8 softness() const { return m_softness; }

  virtual bool operator==(const OdGiMaterialTexture &texture) const
  { return OdGiMaterialTexture::operator==(texture) &&
           (static_cast<const OdGiSceneTexture&>(texture).softness() == softness()); }
  
  OdGiSceneTexture &operator =(const OdGiSceneTexture &texture)
  {
    setSoftness(texture.softness());
    return *this;
  }
 
  // OdRxObject overrides

  void copyFrom(const OdRxObject* pSource)
  {
    OdSmartPtr<OdGiSceneTexture> pSrcTex = OdGiSceneTexture::cast(pSource);
    if (!pSrcTex.isNull())
      setSoftness(pSrcTex->softness());
    else
      throw OdError(eNotApplicable);
  }
protected:
  OdUInt8 m_softness;
};

typedef OdSmartPtr<OdGiSceneTexture> OdGiSceneTexturePtr;
 

class ODGI_EXPORT OdGiMapper
{
public:
  enum Projection
  {
    kInheritProjection   = 0,
    kPlanar              = 1,
    kBox                 = 2,
    kCylinder            = 3,
    kSphere              = 4,
    kDgnParametric       = 0x32,
    kDgnPlanar           = 0x33,
    kDgnCylinder         = 0x34,
    kDgnCylinderCapped   = 0x35,
    kDgnSphere           = 0x36
  };

  enum Tiling
  {
    kInheritTiling    = 0,
    kTile             = 1,
    kCrop             = 2,
    kClamp            = 3,
    kMirror           = 4
  };

  enum AutoTransform
  {
    kInheritAutoTransform = 0x0,
    kNone                 = 0x1,
    kObject               = 0x2,
    kModel                = 0x4,

    kPredefinedBim        = 0x8,
  };

  ODGI_EXPORT_STATIC static const OdGiMapper kIdentity;

  OdGiMapper()
    : m_projection(kPlanar)
    , m_uTiling(kTile)
    , m_vTiling(kTile)
    , m_autoTransform(kNone)
  {
  }
  
  OdGiMapper(const OdGiMapper& mapper) = default;

  OdGiMapper& operator=(const OdGiMapper& mapper) = default;

  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,
    kFile       = 1,
    kProcedural = 2
  };

  ODGI_EXPORT_STATIC static const OdGiMaterialMap kNull;

  OdGiMaterialMap();

  void setSource(Source source);

  void setSourceFileName(const OdString& filename);

  void setBlendFactor(double blendFactor);

  void setBrightness(double brightness);

  void setInverted(bool bInvert);

  void setInvertedBrightness(bool bInvert);

  void setTexture(OdGiMaterialTexturePtr pTexture);

  OdGiMapper& mapper();

  Source source() const;

  OdString sourceFileName() const;

  double blendFactor() const;

  double brightness() const;

  bool isInverted() const;

  bool isInvertedBrightness() 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_flags       == other.m_flags)       &&
        (m_blendFactor == other.m_blendFactor) &&
        (m_brightness  == other.m_brightness)  &&
        (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_flags = mmap.m_flags;
    m_blendFactor = mmap.m_blendFactor;
    m_brightness = mmap.m_brightness;
    m_mapper = mmap.m_mapper;
    m_texture = mmap.m_texture;
    return *this;
  }
private:
  enum Flags
  {
    kInvertImage = (1 << 0),
    kInvertBrightness = (1 << 1)
  };
private:
  Source     m_source;
  OdUInt32   m_flags;
  double     m_blendFactor;
  double     m_brightness;
  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;
}
 
inline void
OdGiMaterialColor::setBlendFactor(double factor)
{
  if (OdLessOrEqual(factor, 0.0))
    m_method = kInherit, m_factor = 0.0;
  else if (OdGreaterOrEqual(factor, 1.0f))
    m_method = kOverride, m_factor = 1.0;
  else
    m_method = kBlend, m_factor = factor;
}
 
inline double
OdGiMaterialColor::blendFactor() const
{
  switch (m_method)
  {
    case kInherit:  return 0.0;
    case kOverride: return 1.0;
    default:        return m_factor;
  }
}
 
// OdGiMaterialMap inline implementations
 
inline
OdGiMaterialMap::OdGiMaterialMap()
  : m_source(kFile)
  , m_flags(0)
  , m_blendFactor(1.0)
  , m_brightness(1.0)
{
}
 
inline void
OdGiMaterialMap::setBlendFactor(double blendFactor)
{
  m_blendFactor = blendFactor;
}
 
inline void
OdGiMaterialMap::setBrightness(double brightness)
{
  m_brightness = brightness;
}
 
inline void
OdGiMaterialMap::setInverted(bool bInvert)
{
  SETBIT(m_flags, kInvertImage, bInvert);
}
 
inline void
OdGiMaterialMap::setInvertedBrightness(bool bInvert)
{
  SETBIT(m_flags, kInvertBrightness, bInvert);
}
 
inline OdGiMapper&
OdGiMaterialMap::mapper()
{
  return m_mapper;
}
 
inline OdGiMaterialMap::Source
OdGiMaterialMap::source() const
{
  return m_source;
}
 
inline double
OdGiMaterialMap::blendFactor() const
{
  return m_blendFactor;
}
 
inline double
OdGiMaterialMap::brightness() const
{
  return m_brightness;
}
 
inline bool
OdGiMaterialMap::isInverted() const
{
  return GETBIT(m_flags, kInvertImage);
}
 
inline bool
OdGiMaterialMap::isInvertedBrightness() const
{
  return GETBIT(m_flags, kInvertBrightness);
}
 
inline const OdGiMapper&
OdGiMaterialMap::mapper() const
{
  return m_mapper;
}
 
inline void
OdGiMaterialMap::setMapper(const OdGiMapper &mapper)
{
  m_mapper = mapper;
}
 
inline const OdGiMaterialTexturePtr
OdGiMaterialMap::texture(void) const
{
  return m_texture;
}
 
// OdGiMapper inline implementations
 
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);
  }
}
 
// OdGiRasterImageFileTexture inline implementations
 
inline void
OdGiRasterImageFileTexture::setRasterImage(const OdGiRasterImage *pRasterImage)
{
  if (pRasterImage)
  {
    if (m_pRasterImage.isNull())
      m_pRasterImage = OdGiRasterImageTexture::createObject();
    m_pRasterImage->setRasterImage(pRasterImage);
  } else
    m_pRasterImage.release();
}
 
inline const OdGiRasterImage *
OdGiRasterImageFileTexture::rasterImage() const
{
  if (m_pRasterImage.isNull())
    return NULL;
  return m_pRasterImage->rasterImage();
}
 
inline void 
OdGiRasterImageFileTexture::setRasterImageTexture(const OdGiRasterImageTexture *pRasterImage)
{
  m_pRasterImage = pRasterImage;
}
 
inline const OdGiRasterImageTexture *
OdGiRasterImageFileTexture::rasterImageTexture() const
{
  return m_pRasterImage;
}
 
inline bool
OdGiRasterImageFileTexture::operator==(const OdGiMaterialTexture &texture) const
{
  if (!(texture.isA() == isA()))
    return false;
  const OdGiRasterImageFileTexture &refTexture = static_cast<const OdGiRasterImageFileTexture &>(texture);
  return (rasterImage() == refTexture.rasterImage()) && (sourceFileName() == refTexture.sourceFileName());
}
 
inline OdGiRasterImageFileTexture &
OdGiRasterImageFileTexture::operator =(const OdGiRasterImageFileTexture &texture)
{
  setRasterImage(texture.rasterImage());
  setSourceFileName(texture.sourceFileName());
  return *this;
}
 
inline void OdGiRasterImageFileTexture::copyFrom(const OdRxObject* pSource)
{
  OdGiRasterImageFileTexturePtr pSrcTex = OdGiRasterImageFileTexture::cast(pSource);
  if (!pSrcTex.isNull())
  {
    setRasterImage(pSrcTex->rasterImage());
    setSourceFileName(pSrcTex->sourceFileName());
  }
  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__