GiSelectionStyle.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 __ODGISELECTIONSTYLE_H__
#define __ODGISELECTIONSTYLE_H__
 
#include "TD_PackPush.h"
 
#include "Gi/Gi.h"

class FIRSTDLL_EXPORT OdGiSelectionStyle
{
  public:
    class ColorMask
    {
      protected:
        OdCmEntityColor m_color;
        OdUInt32 m_transparency;
      public:
        ColorMask() : m_transparency(255) {}

        void setColor(const OdCmEntityColor &color) { m_color = color; }
        const OdCmEntityColor &color() const { return m_color; }

        void setTransparency(OdUInt8 transparency) { m_transparency = transparency; }
        OdUInt8 transparency() const { return isVisible() ? OdUInt8(m_transparency) : 255; }

        void setColor(const OdCmEntityColor &color, OdUInt8 transparency) { setColor(color); setTransparency(transparency); }

        bool isVisible() const { return m_transparency < 255; }
        bool isOpaque() const { return !m_transparency; }

        void reset() { m_color = OdCmEntityColor(); m_transparency = 255; }

        bool operator ==(const ColorMask &cm2) const
        { return (transparency() == cm2.transparency()) && (!isVisible() || color() == cm2.color()); }
        
        bool operator !=(const ColorMask &cm2) const
        { return (transparency() != cm2.transparency()) ||  (isVisible() && color() != cm2.color()); }
    };

    class ElementStyle
    {
      protected:
        enum ElementFlags
        {
          kDrawElement    = (1 << 0), // Enable displaying of edges/faces
          kPatternElement = (1 << 1), // Apply classic highlighting pattern for edges/faces
          kMaskElement    = (1 << 2), // Apply color mask effect to edges/faces
          // Global element flags
          kGOnTopOfDepth  = (1 << 3), // Display element on top of depth buffer
          kGlobalFlags    = kGOnTopOfDepth, // List of global flags
          //
          kLastElementStyleFlag = kGOnTopOfDepth
        };
        OdUInt32 m_nFlags; // Flags
        ColorMask m_colorMask; // Color mask effect properties
      public:
        ElementStyle() : m_nFlags(0) { }

        void setVisible(bool bVisible) { SETBIT(m_nFlags, kDrawElement, bVisible); }
        bool isVisible() const { return GETBIT(m_nFlags, kDrawElement); }

        void enablePattern(bool bEnable) { SETBIT(m_nFlags, kPatternElement, bEnable); }
        bool isPatternEnabled() const { return GETBIT(m_nFlags, kPatternElement); }

        void enableColorMasking(bool bEnable) { SETBIT(m_nFlags, kMaskElement, bEnable); }
        bool isColorMaskingEnabled() const { return GETBIT(m_nFlags, kMaskElement); }

        const ColorMask &colorMask() const { return m_colorMask; }
        ColorMask &colorMask() { return m_colorMask; }

        bool isOnTopOfDepth() const { return GETBIT(m_nFlags, kGOnTopOfDepth); }

        bool hasEffect() const { return isPatternEnabled() || (isColorMaskingEnabled() && colorMask().isVisible()); }

        void setByDefault() { m_nFlags = kDrawElement; m_colorMask.reset(); }
        void setAsDisabled() { m_nFlags = 0; m_colorMask.reset(); }
        void setForStippling() { m_nFlags = kDrawElement | kPatternElement; m_colorMask.reset(); }
        void setForColorMasking() { m_nFlags = kDrawElement | kMaskElement; m_colorMask.setColor(OdCmEntityColor(48, 115, 250), 140); }

        bool operator ==(const ElementStyle &secStyle) const
        { return ((m_nFlags & ~kGlobalFlags) == (secStyle.m_nFlags & ~kGlobalFlags)) && (m_colorMask == secStyle.m_colorMask); }
        
        bool operator !=(const ElementStyle &secStyle) const
        { return ((m_nFlags & ~kGlobalFlags) != (secStyle.m_nFlags & ~kGlobalFlags)) || (m_colorMask != secStyle.m_colorMask); }
    };

    typedef ElementStyle FaceStyle;
    class EdgeStyle : public ElementStyle
    {
      public:
        enum Mode
        {
          kExistEdges,   // Draw existing edges if they are enabled.
          kIsolineEdges, // Draw isolines for 3d objects and existing edges for others.
          kContourEdges  // Draw contours for 3d objects and existing edges for others.
        };
      protected:
        enum EdgeFlags
        {
          kDrawIsolines = (kLastElementStyleFlag << 1), // Draw isolines for 3d objects
          kDrawContours = (kLastElementStyleFlag << 2)  // Draw contours for 3d objects
        };
        OdInt32 m_lineWeightExtension; // Number of pixels for lineweight enlargement
      public:
        EdgeStyle() : m_lineWeightExtension(0) { }

        void setMode(Mode edgeMode)
        { switch (edgeMode) {
            case kIsolineEdges: SETBIT_1(m_nFlags, kDrawIsolines); SETBIT_0(m_nFlags, kDrawContours); break;
            case kContourEdges: SETBIT_0(m_nFlags, kDrawIsolines); SETBIT_1(m_nFlags, kDrawContours); break;
            default: SETBIT_0(m_nFlags, kDrawIsolines | kDrawContours);
          }
        }

        Mode mode() const
        { if (GETBIT(m_nFlags, kDrawIsolines)) return kIsolineEdges;
          if (GETBIT(m_nFlags, kDrawContours)) return kContourEdges;
          return kExistEdges;
        }

        void setLineWeightExtension(OdInt32 nLwdExtension) { m_lineWeightExtension = nLwdExtension; }
        OdInt32 lineWeightExtension() const { return m_lineWeightExtension; }
        bool hasLineWeightExtension() const { return m_lineWeightExtension != 0; }

        bool hasEffect() const { return ElementStyle::hasEffect() || hasLineWeightExtension() || (mode() != kExistEdges); }

        void setByDefault() { ElementStyle::setByDefault(); m_lineWeightExtension = 0; }
        void setAsDisabled() { ElementStyle::setAsDisabled(); m_lineWeightExtension = 0; }
        void setForStippling() { ElementStyle::setForStippling(); m_lineWeightExtension = 0; }
        void setForColorMasking() { ElementStyle::setForColorMasking(); m_colorMask.setTransparency(128);
                                    m_nFlags |= kDrawIsolines; m_lineWeightExtension = 5; }

        bool operator ==(const EdgeStyle &secStyle) const
        { return ElementStyle::operator ==(secStyle) && (m_lineWeightExtension == secStyle.m_lineWeightExtension); }
        
        bool operator !=(const EdgeStyle &secStyle) const
        { return ElementStyle::operator !=(secStyle) || (m_lineWeightExtension != secStyle.m_lineWeightExtension); }
    };

    class StyleEntry
    {
      protected:
        EdgeStyle m_edgeStyle;
        FaceStyle m_faceStyle;
      public:
        EdgeStyle &edgeStyle() { return m_edgeStyle; }
        const EdgeStyle &edgeStyle() const { return m_edgeStyle; }

        FaceStyle &faceStyle() { return m_faceStyle; }
        const FaceStyle &faceStyle() const { return m_faceStyle; }

        bool isOnTopOfDepth() const
        { return m_edgeStyle.isOnTopOfDepth() && m_faceStyle.isOnTopOfDepth(); }

        bool isVisible() const { return m_edgeStyle.isVisible() || m_faceStyle.isVisible(); }
        bool hasEffect() const { return m_edgeStyle.hasEffect() || m_faceStyle.hasEffect(); }

        void setByDefault() { m_edgeStyle.setByDefault(); m_faceStyle.setByDefault(); }
        void setAsDisabled() { m_edgeStyle.setAsDisabled(); m_faceStyle.setAsDisabled(); }
        void setForStippling() { m_edgeStyle.setForStippling(); m_faceStyle.setForStippling(); }
        void setForColorMasking() { m_edgeStyle.setForColorMasking(); m_faceStyle.setForColorMasking(); }

        void setForColorMasking(const OdCmEntityColor &color, OdUInt8 transparency)
        { setByDefault();
          m_edgeStyle.enableColorMasking(true); m_edgeStyle.colorMask().setColor(color, transparency);
          m_faceStyle.enableColorMasking(true); m_faceStyle.colorMask().setColor(color, transparency); }

        bool operator ==(const StyleEntry &secStyle) const
        { return (m_edgeStyle == secStyle.m_edgeStyle) && (m_faceStyle == secStyle.m_faceStyle); }
        
        bool operator !=(const StyleEntry &secStyle) const
        { return (m_edgeStyle != secStyle.m_edgeStyle) || (m_faceStyle != secStyle.m_faceStyle); }
    };
  protected:
    StyleEntry m_styleEntry[4];
  protected:
    struct GIntAccessor : public ElementStyle
    {
      static OdUInt32 getIntFlags(const ElementStyle &elemStyle)
      { return static_cast<const GIntAccessor &>(elemStyle).m_nFlags; }
      static OdUInt32 extractIntFlags(ElementStyle &elemStyle)
      { GIntAccessor &gStyle = static_cast<GIntAccessor &>(elemStyle);
        const OdUInt32 flags = gStyle.m_nFlags & kGlobalFlags; gStyle.m_nFlags &= ~kGlobalFlags;
        return flags; }
      static void installIntFlags(ElementStyle &elemStyle, OdUInt32 flags)
      { GIntAccessor &gStyle = static_cast<GIntAccessor &>(elemStyle);
        gStyle.m_nFlags = (gStyle.m_nFlags & ~kGlobalFlags) | flags; }
      static bool isOnTopOfDepth(OdUInt32 flags) { return GETBIT(flags, kGOnTopOfDepth); }
      static void setOnTopOfDepth(OdUInt32 &flags, bool bSet) { SETBIT(flags, kGOnTopOfDepth, bSet); }
    };
    class WrapGIntFlags { StyleEntry *m_pStyle; OdUInt32 m_flags[2];
      public: WrapGIntFlags(StyleEntry &style, bool bWrap = true) : m_pStyle(bWrap ? &style : NULL)
              { if (m_pStyle) { m_flags[0] = GIntAccessor::extractIntFlags(style.edgeStyle());
                                m_flags[1] = GIntAccessor::extractIntFlags(style.faceStyle()); }
              else { m_flags[0] = m_flags[1] = 0; }
              }
              ~WrapGIntFlags() { if (m_pStyle) { GIntAccessor::installIntFlags(m_pStyle->edgeStyle(), m_flags[0]);
                                                 GIntAccessor::installIntFlags(m_pStyle->faceStyle(), m_flags[1]); } }
    };
    int makeEntryId(bool bDrawOnTop, bool bDrawIn3d) const { return ((bDrawOnTop) ? 1 : 0) | ((bDrawIn3d) ? 2 : 0); }
  public:
    OdGiSelectionStyle() { }

    StyleEntry &styleFor(bool bDrawOnTop = false, bool bDrawIn3d = false)
    { return m_styleEntry[makeEntryId(bDrawOnTop, bDrawIn3d)]; }

    const StyleEntry &styleFor(bool bDrawOnTop = false, bool bDrawIn3d = false) const 
    { return m_styleEntry[makeEntryId(bDrawOnTop, bDrawIn3d)]; }

    void sync3d() { WrapGIntFlags _wint(styleFor(true, true));
                    styleFor(false, true) = styleFor(false, false); styleFor(true, true) = styleFor(true, false); }

    void sync2d() { WrapGIntFlags _wint(styleFor(true, true));
                    styleFor(false, false) = styleFor(false, true); styleFor(true, false) = styleFor(true, true); }

    void exchangeTopBottom(bool bFor2d = true, bool bFor3d = true)
    { StyleEntry tmpEntry; WrapGIntFlags _wint(styleFor(true, true), bFor3d);
      if (bFor2d) { tmpEntry = styleFor(false, false); styleFor(false, false) = styleFor(true, false); styleFor(true, false) = tmpEntry; }
      if (bFor3d) { tmpEntry = styleFor(false, true);  styleFor(false, true)  = styleFor(true, true);  styleFor(true, true)  = tmpEntry; }
    }

    void setOnTopOfDepth(bool bSet) { StyleEntry &ent = styleFor(true, true);
      OdUInt32 flags = GIntAccessor::getIntFlags(ent.edgeStyle()); GIntAccessor::setOnTopOfDepth(flags, bSet); GIntAccessor::installIntFlags(ent.edgeStyle(), flags);
               flags = GIntAccessor::getIntFlags(ent.faceStyle()); GIntAccessor::setOnTopOfDepth(flags, bSet); GIntAccessor::installIntFlags(ent.faceStyle(), flags);
    }

    bool isOnTopOfDepth() const { return styleFor(true, true).isOnTopOfDepth(); }

    void setByDefault() { styleFor(false).setByDefault(); styleFor(true).setAsDisabled(); sync3d(); }
    void setAsDisabled() { styleFor(false).setAsDisabled(); styleFor(true).setAsDisabled(); sync3d(); }
    void setForStippling() { styleFor(false).setForStippling(); styleFor(true).setAsDisabled(); sync3d(); }
    void setForColorMasking() { styleFor(false).setByDefault(); styleFor(false).edgeStyle().setMode(EdgeStyle::kIsolineEdges);
                                styleFor(true).setForColorMasking(); sync3d(); }
};
 
#include "TD_PackPop.h"
 
#endif //__ODGISELECTIONSTYLE_H__