GiVisualStyle.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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-2022 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 __ODGIVISUALSTYLE_H__
#define __ODGIVISUALSTYLE_H__
 
#include "TD_PackPush.h"
 
#include "Gi/Gi.h"
#include "Gi/GiVariant.h"
 
class OdCmColorBase;
 
class FIRSTDLL_EXPORT OdGiFaceStyle : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiFaceStyle);
 
  enum LightingModel
  {
    kInvisible = 0, // Faces are invisible.
    kConstant  = 1, // Faces are drawn in a constant color. 
    kPhong     = 2, // Faces are drawn with Phong model to approximate realistic direct lighting.
    kGooch     = 3  // Faces are drawn with non-photorealistic lighting model for automatic technical illustration.
  };
 
  enum LightingQuality
  {
    kNoLighting        = 0, // No lighting calculations are applied to the faces.
    kPerFaceLighting   = 1, // Color is calculated for each face based on its orientation to the light sources of the scene.
    kPerVertexLighting = 2, // Color is calculated for each vertex of a face based on its orientation to the light sources of the scene.
    kPerPixelLighting  = 3  // Color is calculated for each pixel of a face based on its orientation to the light sources of the scene.
  };
 
  enum FaceColorMode
  {
    kNoColorMode     = 0, // Apply no modifications to the faces. 
    kObjectColor     = 1, // Apply the color of the drawable object to the faces of the object.
    kBackgroundColor = 2, // Apply the display background color to the faces.
    kMono            = 3, // All faces are treated as having a specific color, resulting in a "monochromatic" effect. 
    kTint            = 4, // All faces have the hue and saturation values of their color mapped to the hue and saturation values of a specific color, resulting in a "tinted" effect. The luminance value remains unchanged. 
    kDesaturate      = 5  // Apply a desaturation percentage to the diffuse color of a material.
  };
 
  enum FaceModifier
  {
    kNoFaceModifiers = 0,  // Apply no face modifiers to the faces. 
    kOpacity         = 1,  // Apply an opacity value to the faces. If unset, faces are displayed with full opacity. If set, faces are displayed with a specified degree of opacity from completely opaque to completely transparent. 
    kSpecular        = 2   // Apply a specular highlight (indicating reflection and shininess values) to a material that is applied to the faces.
  };
 
  void set(const OdGiFaceStyle& style);
 
  OdGiFaceStyle& operator=(const OdGiFaceStyle& style);
  
  bool operator==(const OdGiFaceStyle& style) const;
 
  virtual void setLightingModel(LightingModel lightingModel) = 0;
  
  virtual LightingModel lightingModel() const = 0;
 
  virtual void setLightingQuality(LightingQuality lightingQuality) = 0;
 
  virtual LightingQuality lightingQuality() const = 0;
 
  virtual void setFaceColorMode(FaceColorMode mode) = 0;
 
  virtual FaceColorMode faceColorMode() const = 0;
 
  virtual void setFaceModifiers(unsigned long nModifiers) = 0;
  
  virtual void setFaceModifierFlag(FaceModifier flag, bool bEnable) = 0;
 
  virtual unsigned long faceModifiers() const = 0;
 
  virtual bool isFaceModifierFlagSet(FaceModifier flag) const = 0;
 
  virtual void setOpacityLevel(double nLevel, bool bEnableModifier) = 0;
 
  virtual double opacityLevel() const = 0;
 
  virtual void setSpecularAmount(double nAmount, bool bEnableModifier) = 0;
 
  virtual double specularAmount() const = 0;
 
  virtual void setMonoColor(const OdCmColorBase& color, bool bEnableMode) = 0;
  
  virtual const OdCmColorBase& monoColor() const = 0;
 
  virtual OdCmColorBase& monoColor() = 0;
};
 
typedef OdSmartPtr<OdGiFaceStyle> OdGiFaceStylePtr;
 
class FIRSTDLL_EXPORT OdGiEdgeStyle : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiEdgeStyle);
 
  enum EdgeModel
  {
    kNoEdges    = 0,  // No edges are displayed.
    kIsolines   = 1,  // Display isolines.
    kFacetEdges = 2   // Display facet edges (the edges between neighbouring faces).
  };
 
  enum EdgeStyle
  {
    kNoEdgeStyle  = 0,  // No edge styles are applied to the edges.
    kVisible      = 1,  // Visible edges are displayed.
    kSilhouette   = 2,  // Silhouette edges are displayed.
    kObscured     = 4,  // Obscured edges are displayed.
    kIntersection = 8   // Intersection edges are displayed.
  };
 
  enum EdgeModifier
  {
    kNoEdgeModifiers = 0x000, // No modifiers are applied.
    kOverhang        = 0x001, // Allow an edge to overhang its start and end points by a specified amount. 
    kJitter          = 0x002, // Apply a jitter effect to the edges. The jitter effect is produced by drawing extra lines adjacent to the original line, with a specific amount of perturbation away from the original line.
    kWidth           = 0x004, // Apply a width to the edges. 
    kColor           = 0x008, // Apply a color that differs from the drawable object color to the edges. 
    kHaloGap         = 0x010, // Apply a halo gap percentage to the edges of an object that is hidden by another object, such that the specified gap is displayed between the edges of the hidden object and the edges of the object which hides it.
    kLinetype        = 0x020, // Apply a linetype to the edges.
    kAlwaysOnTop     = 0x040, // Force edges to be on top. Edges will not participate in the Z-ordering of the displayed drawables.
    kOpacity         = 0x080, // Apply an opacity value to the edges. If unset, edges are displayed with full opacity. If set, edges are displayed with a specified degree of opacity from completely opaque to completely transparent.
    kWiggle          = 0x100, // Apply a wiggle value to the edges.
    kTexture         = 0x200  // Apply a material texture to the edges.
  };
 
  enum JitterAmount
  {
    kJitterLow    = 1,  // A small amount of perturbation. 
    kJitterMedium = 2,  // A medium amount of perturbation. 
    kJitterHigh   = 3   // A large amount of perturbation. 
  };
 
  enum WiggleAmount
  {
    kWiggleLow    = 1,  // A small amount of perturbation.
    kWiggleMedium = 2,  // A medium amount of perturbation.
    kWiggleHigh   = 3   // A large amount of perturbation.
  };
 
  enum LineType
  {
    kSolid            = 1,  // A solid line pattern is used to display edges.
    kDashed           = 2,  // A dashed line pattern is used to display edges.
    kDotted           = 3,  // A dotted line pattern is used to display edges.
    kShortDash        = 4,  // A short dashed line pattern is used to display edges.
    kMediumDash       = 5,  // A medium dashed line pattern is used to display edges.
    kLongDash         = 6,  // A long dashed line pattern is used to display edges.
    kDoubleShortDash  = 7,  // A double short dashed line pattern is used to display edges.
    kDoubleMediumDash = 8,  // A double medium dashed line pattern is used to display edges.
    kDoubleLongDash   = 9,  // A double long dashed line pattern is used to display edges.
    kMediumLongDash   = 10, // A medium long dashed line pattern is used to display edges.
    kSparseDot        = 11  // A sparse dotted line pattern is used to display edges.
  };
 
  enum EdgeStyleApply
  {
    kDefault, // Apply the edge style to the geometry as designed.
    kAll      // Apply the edge style to all geometry.
  };
 
  void set(const OdGiEdgeStyle& style);
  
  OdGiEdgeStyle& operator=(const OdGiEdgeStyle& style);
  
  bool operator==(const OdGiEdgeStyle& style) const;
 
  virtual void setEdgeModel(EdgeModel model) = 0;
 
  virtual EdgeModel edgeModel() const = 0;
 
  virtual void setEdgeStyles(unsigned long nStyles) = 0;
 
  virtual void setEdgeStyleFlag(EdgeStyle flag, bool bEnable) = 0;
 
  virtual unsigned long edgeStyles() const = 0;
 
  virtual bool isEdgeStyleFlagSet(EdgeStyle flag) const = 0;
 
  virtual void setIntersectionColor(const OdCmColorBase& color) = 0;
 
  virtual const OdCmColorBase& intersectionColor() const = 0;
 
  virtual OdCmColorBase& intersectionColor() = 0;
 
  virtual void setObscuredColor(const OdCmColorBase& color) = 0;
 
  virtual const OdCmColorBase& obscuredColor() const = 0;
  
  virtual OdCmColorBase& obscuredColor() = 0;
 
  virtual void setObscuredLinetype(LineType ltype) = 0;
 
  virtual LineType obscuredLinetype() const = 0;
 
  virtual void setIntersectionLinetype(LineType ltype) = 0;
 
  virtual LineType intersectionLinetype() const = 0;
 
  virtual void setCreaseAngle(double nAngle) = 0;
 
  virtual double creaseAngle() const = 0;
 
  virtual void setEdgeModifiers(unsigned long nModifiers) = 0;
 
  virtual void setEdgeModifierFlag(EdgeModifier flag, bool bEnable) = 0;
 
  virtual unsigned long edgeModifiers() const = 0;
 
  virtual bool isEdgeModifierFlagSet(EdgeModifier flag) const = 0;
 
  virtual void setEdgeColor(const OdCmColorBase& color, bool bEnableModifier) = 0;
 
  virtual const OdCmColorBase& edgeColor() const = 0;
 
  virtual OdCmColorBase& edgeColor() = 0;
 
  virtual void setOpacityLevel(double nLevel, bool bEnableModifier) = 0;
 
  virtual double opacityLevel() const = 0;
 
  virtual void setEdgeWidth(int nWidth, bool bEnableModifier) = 0;
  
  virtual int edgeWidth() const = 0;
 
  virtual void setOverhangAmount(int nAmount, bool bEnableModifier) = 0;
 
  virtual int overhangAmount() const = 0;
 
  virtual void setJitterAmount(JitterAmount amount, bool bEnableModifier) = 0;
 
  virtual JitterAmount jitterAmount() const = 0;
 
  virtual void setWiggleAmount(WiggleAmount amount, bool bEnableModifier) = 0;
 
  virtual WiggleAmount wiggleAmount() const = 0;
 
  virtual void setSilhouetteColor(const OdCmColorBase& color) = 0;
 
  virtual const OdCmColorBase& silhouetteColor() const = 0;
 
  virtual OdCmColorBase& silhouetteColor() = 0;
 
  virtual void setSilhouetteWidth(short nWidth) = 0;
 
  virtual short silhouetteWidth() const = 0;
 
  virtual void setHaloGap(int nHaloGap, bool bEnableModifier) = 0;
 
  virtual int haloGap() const = 0;
 
  virtual void setIsolines(unsigned short nIsolines) = 0;
 
  virtual unsigned short isolines() const = 0;
 
  virtual void setHidePrecision(bool bHidePrecision) = 0;
 
  virtual bool hidePrecision() const = 0;
 
  virtual void setEdgeStyleApply(EdgeStyleApply apply) = 0;
 
  virtual EdgeStyleApply edgeStyleApply() const = 0;
};
 
typedef OdSmartPtr<OdGiEdgeStyle> OdGiEdgeStylePtr;
 
class FIRSTDLL_EXPORT OdGiDisplayStyle : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiDisplayStyle);
  
  enum DisplaySettings
  {
    kNone        = 0x00,  // No display settings are used.
    kBackgrounds = 0x01,  // Backgrounds are enabled.
    kLights      = 0x02,  // Lights are enabled.
    kMaterials   = 0x04,  // Materials are enabled.
    kTextures    = 0x08   // Textures are enabled.
  };
 
  enum ShadowType
  {
    kShadowsNone          = 0,  // No shadow is displayed.
    kShadowsGroundPlane   = 1,  // Ground plane shadows are displayed.
    kShadowsFull          = 2,  // Full shadows are displayed.       
    kShadowsFullAndGround = 3   // Full shadows are displayed along with shadows on the ground plane. 
  };
 
  void set(const OdGiDisplayStyle& style);
  
  OdGiDisplayStyle& operator=(const OdGiDisplayStyle& style);
  
  bool operator==(const OdGiDisplayStyle& style) const;
 
  virtual void setDisplaySettings(unsigned long nSettings) = 0;
 
  virtual void setDisplaySettingsFlag(DisplaySettings flag, bool bEnable) = 0;
 
  virtual unsigned long displaySettings() const = 0;
 
  virtual bool isDisplaySettingsFlagSet(DisplaySettings flag) const = 0;
 
  virtual void setBrightness(double value) = 0;
 
  virtual double brightness() const = 0;
 
  virtual void setShadowType(ShadowType type) = 0;
 
  virtual ShadowType shadowType() const = 0;
};
 
typedef OdSmartPtr<OdGiDisplayStyle> OdGiDisplayStylePtr;
 
 
namespace OdGiVisualStyleProperties
{
  enum Property
  {
    kInvalidProperty              = -1, // Invalid property. 
 
    // Face properties
 
    kFaceLightingModel            =  0, // The lighting model applied to the faces of drawables. See the FaceLightingModel enumeration.
    kFaceLightingQuality          =  1, // The calculation method of lighting effects applied to faces. See the FaceLightingQuality enumeration.
    kFaceColorMode                =  2, // The color mode applied to faces. See the FaceColorMode enumeration.
    kFaceModifiers                =  3, // Modifications applied to faces. See the FaceModifiers enumeration.
    kFaceOpacity                  =  4, // The face opacity property. Double value representing the face opacity level in the range from 0.0 (faces are fully transparent) to 1.0 (no transparency).
    kFaceSpecular                 =  5, // The face specular property. Double value representing the specular highlight amount (indicating reflection and shininess values) of the material that is applied to faces.
    kFaceMonoColor                =  6, // The face monocolor effect property. OdCmColor representing the color applied to produce a "monochromatic" effect on faces.
 
    // Edge properties
 
    kEdgeModel                    =  7, // The edge model property. See the EdgeModel enumeration.
    kEdgeStyles                   =  8, // The edge style property. See the EdgeStyles enumeration.
    kEdgeIntersectionColor        =  9, // The intersected edges color. OdCmColor representing the color applied to intersection edges.
    kEdgeObscuredColor            = 10, // The obscured edges color. OdCmColor representing the color applied to obscured edges.
    kEdgeObscuredLinePattern      = 11, // The line pattern applied to obscured edges. See the EdgeLinePattern enumeration.
    kEdgeIntersectionLinePattern  = 12, // The line pattern applied to intersection edges. See the EdgeLinePattern enumeration.
    kEdgeCreaseAngle              = 13, // The edge crease angle. Double value indicating angle threshold, above which a facet edge representing adjoining facets will be displayed.
    kEdgeModifiers                = 14, // Modifications applied to edges. See the EdgeModifiers enumeration.
    kEdgeColor                    = 15, // The edge color property. OdCmColor representing the color applied to edges. 
    kEdgeOpacity                  = 16, // The edge opacity property. Double value representing the edge opacity level in the range from 0.0 (faces are fully transparent) to 1.0 (no transparency).
    kEdgeWidth                    = 17, // The edge width property. Integer value representing edge width in pixels.
    kEdgeOverhang                 = 18, // The edge overhang property. Integer value representing the amount, in pixels, that edges should overhang their start and end points.
    kEdgeJitterAmount             = 19, // The edge jitter amount. See the EdgeJitterAmount enum.
    kEdgeSilhouetteColor          = 20, // The edge silhouette color property. OdCmColor enumeration the color applied to silhouette edges. 
    kEdgeSilhouetteWidth          = 21, // The edge silhouette width property. Short value representing silhouette edge width in pixels. 
    kEdgeHaloGap                  = 22, // The edge halo gap amount. Integer value from 0 to 100 representing the halo gap. 
    kEdgeIsolines                 = 23, // The isolines number property. Unsigned short value, between 0 and 2047, indicating the number of isolines to display for curved surfaces.
    kEdgeHidePrecision            = 24, // The hide precision property. Boolean value indicating hide precision enabled. True if enabled; otherwise, false.
 
    // Display properties
 
    kDisplayStyles                = 25, // Display settings. See the DisplayStyles enumeration.
    kDisplayBrightness            = 26, // The display brightness property. Double value indicating brightness. 
    kDisplayShadowType            = 27, // The display shadow type property. See the DisplayShadowType enumeration.
 
    // New in AC2011, 2013
    kUseDrawOrder                 = 28, // Boolean value indicating whether draw order is enabled. True if enabled; otherwise, false.
    kViewportTransparency         = 29, // Boolean value indicating whether viewport transparency is enabled. True if enabled; otherwise, false.
    kLightingEnabled              = 30, // Boolean value indicating whether lightning is enabled. True if enabled; otherwise, false.
    kPosterizeEffect              = 31, // Boolean value indicating whether posterize effect is enabled. True if enabled; otherwise, false.
    kMonoEffect                   = 32, // Boolean value indicating whether mono effect is enabled. True if enabled; otherwise, false.
 
    // New in 2013
    kBlurEffect                   = 33, // Boolean value indicating whether blur effect is enabled. True if enabled; otherwise, false.
    kPencilEffect                 = 34, // Boolean value indicating whether pencil effect is enabled. True if enabled; otherwise, false.
    kBloomEffect                  = 35, // Boolean value indicating whether bloom effect is enabled. True if enabled; otherwise, false.
    kPastelEffect                 = 36, // Boolean value indicating whether pastel effect is enabled. True if enabled; otherwise, false.
    kBlurAmount                   = 37, // The blur amount property. Integer value representing amount of blur effect.
    kPencilAngle                  = 38, // The pencil angle amount property. Double value representing the angle amount.
    kPencilScale                  = 39, // The pencil scale amount property. Double value representing the scale amount.
    kPencilPattern                = 40, // The pencil pattern amount property. Integer value representing the pencil pattern.
    kPencilColor                  = 41, // The pencil color property. OdCmColor representing the pencil color.
    kBloomThreshold               = 42, // The bloom effect threshold property. Integer value representing the threshold value.
    kBloomRadius                  = 43, // The bloom effect radius. Integer value representing the bloom radius.
    kTintColor                    = 44, // The tint color property. OdCmColor representing the color used for tint effect.
    kFaceAdjustment               = 45, // Boolean value indicating face adjustment enabled. True if enabled; otherwise, false.
    kPostContrast                 = 46, // The post-processing contrast property. Integer value representing the contrast value.
    kPostBrightness               = 47, // The post-processing brightness property. Integer value representing the brightness value.
    kPostPower                    = 48, // Integer value.
    kTintEffect                   = 49, // Boolean value indicating tint effect enabled. True if enabled; otherwise, false.
    kBloomIntensity               = 50, // The bloom intensity property. Integer value representing the intensity of the bloom effect.
    kColor                        = 51, // OdCmColor value.
    kTransparency                 = 52, // Double value.
    kEdgeWiggleAmount             = 53, // The edge wiggle amount property. See the WiggleAmount enumeration.
    kEdgeTexturePath              = 54, // The edge texture path property. String value representing the path to texture. 
    kDepthOfField                 = 55, // Boolean value indicating depth of field effect enabled. True if enabled; otherwise, false.
    kFocusDistance                = 56, // The focus distance property. Double value indicating the focus distance value.
    kFocusWidth                   = 57, // The focus width property. Double value indicating the focus width value.
 
    kPropertyCount                      // The number of visual style properties. 
  };
 
  //
  // Face properties
  //
  enum FaceLightingModel
  {
    kInvisible            = 0,  // Faces are invisible.
    kConstant             = 1,  // Faces are drawn in a constant color.
    kPhong                = 2,  // Faces are drawn with Phong model to approximate realistic direct lighting.
    kGooch                = 3,  // Faces are drawn with non-photorealistic lighting model for automatic technical illustration.
    // New in 2011
    kZebra                = 4
  };
  
  enum FaceLightingQuality
  {
    kNoLighting           = 0,  // No lighting calculations are applied to the faces.
    kPerFaceLighting      = 1,  // Color is calculated for each face based on its orientation to the light sources of the scene.
    kPerVertexLighting    = 2,  // Color is calculated for each vertex of a face based on its orientation to the light sources of the scene.
    kPerPixelLighting     = 3   // Color is calculated for each pixel of a face based on its orientation to the light sources of the scene.
  };
  
  enum FaceColorMode    
  {
    kNoColorMode          = 0,  // Apply no modifications to the faces.
    kObjectColor          = 1,  // Apply the color of the drawable object to the faces of the object.
    kBackgroundColor      = 2,  // Apply the display background color to the faces.
    kMono                 = 3,  // All faces are treated as having a specific color, resulting in a "monochromatic" effect.
    kTint                 = 4,  // All faces have the hue and saturation values of their colors mapped to the hue and saturation values of a specific color, resulting in a "tinted" effect. The luminance value remains unchanged.
    kDesaturate           = 5,  // Apply a desaturation percentage to the diffuse color of a material.
    // Visualize extensions
    kBackgroundTexture    = 6   // Apply actual background texture to the faces.
  };
 
  enum FaceModifiers    
  {
    kNoFaceModifiers      = 0,  // Apply no face modifiers to the faces. 
    kFaceOpacityFlag      = 1,  // Apply an opacity value to the faces. If unset, faces are displayed with full opacity. If set, faces are displayed with a specified degree of opacity from completely opaque to completely transparent. 
    kSpecularFlag         = 2   // Apply a specular highlight (indicating reflection and shininess values) to a material that is applied to the faces.
  };
 
  //
  // Edge properties
  //
 
  enum EdgeModel       
  {
    kNoEdges              = 0,  // No edges are displayed.
    kIsolines             = 1,  // Display isolines.
    kFacetEdges           = 2   // Display facet edges (the edges between neighbouring faces).
  };
 
  enum EdgeStyles       
  {
    kNoEdgeStyle          = 0,  // No edge styles are applied to the edges.
    kVisibleFlag          = 1,  // Visible edges are displayed.
    kSilhouetteFlag       = 2,  // Silhouette edges are displayed. A silhouette edge is an edge connecting a back facing polygon with a front facing polygon.
    kObscuredFlag         = 4,  // Obscured edges are displayed.
    kIntersectionFlag     = 8   // Intersection edges are displayed.
  };
 
  enum EdgeModifiers    
  {
    kNoEdgeModifiers      =   0,  // No modifiers are applied.
    kEdgeOverhangFlag     =   1,  // Allow an edge to overhang its start and end points by a specified amount. 
    kEdgeJitterFlag       =   2,  // Apply a jitter effect to the edges. The jitter effect is produced by drawing extra lines adjacent to the original line, with a specific amount of perturbation away from the original line.
    kEdgeWidthFlag        =   4,  // Apply a width to the edges.
    kEdgeColorFlag        =   8,  // Apply a color that differs from the drawable object color to the edges. 
    kEdgeHaloGapFlag      =  16,  // Apply a halo gap percentage to the edges of an object that is hidden by another object, such that the specified gap is displayed between the edges of the hidden object and the edges of the object which hides it.
    kAlwaysOnTopFlag      =  64,  // Force edges to be on top. Edges will not participate in the Z-ordering of the displayed drawables.
    kEdgeOpacityFlag      = 128,  // Apply an opacity value to the edges. If unset, edges are displayed with full opacity. If set, edges are displayed with a specified degree of opacity from completely opaque to completely transparent.
    // New in 2013
    kEdgeWiggleFlag       = 256,  // Apply a wiggle value to the edges.
    kEdgeTextureFlag      = 512   // Apply a material textures to the edges.
  };
 
  enum EdgeJitterAmount
  {
    kJitterLow            = 1,  // A small amount of perturbation.
    kJitterMedium         = 2,  // A medium amount of perturbation.
    kJitterHigh           = 3   // A large amount of perturbation.
  };
 
  enum EdgeWiggleAmount
  {
    kWiggleLow            = 1,  // A small amount of perturbation.
    kWiggleMedium         = 2,  // A medium amount of perturbation.
    kWiggleHigh           = 3   // A large amount of perturbation.
  };
 
  enum EdgeLinePattern
  {
    kSolid                =  1, // A solid line pattern is used to display edges.
    kDashedLine           =  2, // A dashed line pattern is used to display edges.
    kDotted               =  3, // A dotted line pattern is used to display edges.
    kShortDash            =  4, // A short dashed line pattern is used to display edges.
    kMediumDash           =  5, // A medium dashed line pattern is used to display edges.
    kLongDash             =  6, // A long dashed line pattern is used to display edges.
    kDoubleShortDash      =  7, // A double short dashed line pattern is used to display edges.
    kDoubleMediumDash     =  8, // A double medium dashed line pattern is used to display edges.
    kDoubleLongDash       =  9, // A double long dashed line pattern is used to display edges.
    kMediumLongDash       = 10, // A medium long dashed line pattern is used to display edges.
    kSparseDot            = 11  // A sparse dotted line pattern is used to display edges.
  };
 
  //
  // Display properties
  //
  enum DisplayStyles
  {
    kNoDisplayStyle       = 0,  // No display settings are used.
    kBackgroundsFlag      = 1,  // Backgrounds are enabled.
    kLightingFlag         = 2,  // Lights are enabled.
    kMaterialsFlag        = 4,  // Materials are enabled.
    kTexturesFlag         = 8   // Textures are enabled.
  };
 
  enum DisplayShadowType
  {
    kShadowsNone          = 0,  // No shadow is displayed.
    kShadowsGroundPlane   = 1,  // Ground plane shadows are displayed.
    kShadowsFull          = 2,  // Full shadows are displayed. 
    kShadowsFullAndGround = 3   // Full shadows are displayed along with shadows on the ground plane.
  };
};
 
namespace OdGiVisualStyleOperations
{
  enum Operation
  {
    kInvalidOperation = -1, // Invalid operation.
    kInherit          =  0, // Use the last property value specified.
    kSet              =  1, // Replace the last property value with the one specified. 
    kDisable          =  2, // Disable the specified bits in the property bitmask. 
    kEnable           =  3  // Enable the specified bits in the property bitmask.
  };
};
 
class FIRSTDLL_EXPORT OdGiVisualStyle : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiVisualStyle);
 
  enum Type
  {
    kFlat,              // Flat shaded visual style.
    kFlatWithEdges,     // Flat shaded visual style with edges displayed.
    kGouraud,           // Gouraud shaded visual style. 
    kGouraudWithEdges,  // Gouraud shaded visual style with edges displayed.
    k2DWireframe,       // 2D wireframe visual style (using 2D graphics system). 
    k3DWireframe,       // 3D wireframe visual style (using 3D graphics system).
    kHidden,            // Hidden visual style.
    kBasic,             // Basic visual style (default).
    kRealistic,         // Phong shaded visual style.
    kConceptual,        // Custom, user defined visual visual style. 
    kCustom,            // Custom, user defined visual visual style. 
    kDim,               // Visual style used for a dimming effect.
    kBrighten,          // Visual style used for a brightening effect.
    kThicken,           // Visual style used for a thickening effect.
    kLinePattern,       // Visual style used to apply a line pattern.
    kFacePattern,       // Visual style used to apply a face pattern.
    kColorChange,       // Visual style used to apply a change of color.
 
    kFaceOnly,          // Visual style with only face properties. All non-face properties are set to inherit.
    kEdgeOnly,          // Visual stle with edge properties only. All non-edge properties are set to inherit.
    kDisplayOnly,       // Visual style with display properties only. All non-display properties are set to inherit.
 
    kJitterOff,         // Edge style override visual style with jitter edges off. All other properties are set to inherit.
    kOverhangOff,       // Edge style override visual style with overhang edges off. All other properties are set to inherit.
    kEdgeColorOff,      // Edge style override visual style with edge color off. All other properties are set to inherit.
    kShadesOfGray,      // Shades of gray visual style.
    kSketchy,           // Sketchy visual style. 
    kXRay,              // Xray visual style. 
    kShadedWithEdges,   // Shade visual style with edges displayed.
    kShaded,            // Shaded visual style.
    kByViewport,        // Visual style by viewport.
    kByLayer,           // Visual style by layer.
    kByBlock,           // Visual style by block.
    kEmptyStyle         // Visual style with all properties set to inherit. This effectively creates an empty style upon which a custom visual style can be built.
  };
 
  OdGiVisualStyle& operator=(const OdGiVisualStyle& visualStyle);
  
  bool operator==(const OdGiVisualStyle& visualStyle) const;
 
  virtual OdGiFaceStyle& faceStyle (void) = 0;
  virtual OdGiEdgeStyle& edgeStyle (void) = 0;
  virtual OdGiDisplayStyle& displayStyle (void) = 0;
 
  virtual const OdGiFaceStyle& faceStyle (void) const = 0;
  virtual const OdGiEdgeStyle& edgeStyle (void) const = 0;
  virtual const OdGiDisplayStyle& displayStyle (void) const = 0;
 
  virtual void setFaceStyle (const OdGiFaceStyle& style) = 0;
  virtual void setEdgeStyle (const OdGiEdgeStyle& style) = 0;
  virtual void setDisplayStyle (const OdGiDisplayStyle& style) = 0;
 
  void configureForType (Type type);
 
  // New interface
 
  virtual bool setType(Type type) = 0;
 
  virtual Type type() const = 0;
 
  typedef OdGiVisualStyleProperties::Property Property;
  typedef OdGiVisualStyleOperations::Operation Operation;
 
  virtual bool setTrait(Property prop, Operation op) = 0;
 
  virtual bool setTrait(Property prop, const OdGiVariant *pVal,
                        Operation op = OdGiVisualStyleOperations::kSet) = 0;
 
  virtual bool setTrait(Property prop, OdInt32 nVal,
                        Operation op = OdGiVisualStyleOperations::kSet);
 
  virtual bool setTrait(Property prop, bool bVal,
                        Operation op = OdGiVisualStyleOperations::kSet);
 
  virtual bool setTrait(Property prop, double dVal,
                        Operation op = OdGiVisualStyleOperations::kSet);
 
  virtual bool setTrait(Property prop, double red, double green, double blue,
                        Operation op = OdGiVisualStyleOperations::kSet);
  virtual bool setTrait(Property prop, const OdCmColorBase &pColor,
                        Operation op = OdGiVisualStyleOperations::kSet);
 
  virtual bool setTrait(Property prop, const OdCmEntityColor &pColor,
                        Operation op = OdGiVisualStyleOperations::kSet);
  
  virtual bool setTrait(Property prop, const OdString &pStr,
                        Operation op = OdGiVisualStyleOperations::kSet);
 
  virtual OdGiVariantPtr trait(Property prop, Operation *pOp = NULL) const = 0;
 
  virtual Operation operation(Property prop) const = 0;
 
 
  virtual bool setTraitFlag(Property flagProp, OdUInt32 flagVal, bool bEnable = true);
 
  virtual bool traitFlag(Property flagProp, OdUInt32 flagVal) const;
 
  static OdGiVariant::VariantType propertyType(Property prop);
private:
  void configureForFlat();
  void configureForFlatWithEdges();
  void configureForGouraud();
  void configureForGouraudWithEdges();
  void configureForBasic();
  void configureFor2DWireframe();
  void configureFor3DWireframe();
  void configureForHidden();
  void configureForRealistic();
  void configureForConceptual();
  void configureForDim();
  void configureForBrighten();
  void configureForThicken();
  void configureForLinePattern();
  void configureForFacePattern();
  void configureForColorChange();
 
  // Extended configurations
  void configureForFaceOnly();
  void configureForEdgeOnly();
  void configureForDisplayOnly();
 
  void configureForJitterOff();
  void configureForOverhangOff();
  void configureForEdgeColorOff();
  void configureForShadesOfGray();
  void configureForSketchy();
  void configureForXRay();
  void configureForShadedWithEdges();
  void configureForShaded();
  void configureForByViewport();
  void configureForByLayer();
  void configureForByBlock();
  void configureForEmptyStyle();
 
  // Extended flags configuration
  void configureForAc27(bool b2d = false);
 
  // Clear all changes which is made before
  void configureForInit();
};
 
typedef OdSmartPtr<OdGiVisualStyle> OdGiVisualStylePtr;
 
class FIRSTDLL_EXPORT OdGiVisualStyleTraits : public OdGiDrawableTraits
{
public:
  ODRX_DECLARE_MEMBERS(OdGiVisualStyleTraits);
 
  virtual void setOdGiVisualStyle(const OdGiVisualStyle& visualStyle) = 0;
  
  virtual const OdGiVisualStyle& odgiVisualStyle() const = 0;
};
 
typedef OdSmartPtr<OdGiVisualStyleTraits> OdGiVisualStyleTraitsPtr;
 
#include "TD_PackPop.h"
 
#endif //__ODGIVISUALSTYLE_H__