GiGeometry.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 __ODGIGEOMETRY_H__
#define __ODGIGEOMETRY_H__
 
#include "TD_PackPush.h"
#include "RxObject.h"
 
#include "Ge/GePoint3d.h"
#include "Ge/GeMatrix3d.h"
 
#include "Gi/GiRasterImage.h"
#include "Gi/GiMaterial.h"
 
class OdDbStub;
class OdCmEntityColor;
class OdGeMatrix3d;
class OdGeVector3d;
class OdGePoint2d;
class OdGeCurve2d;
class OdGiPathNode;
class OdGiMapper;
class OdCmTransparency;
class OdGiImageBGRA32;
class OdGiPointCloud;

typedef OdArray<OdGeCurve2d*, OdMemoryAllocator<OdGeCurve2d*> > OdGiEdge2dArray;

class OdGiEdgeData
{
  const OdUInt16*         m_pColors;
  const OdCmEntityColor*  m_pTrueColors;
        OdDbStub**        m_pLayerIds;
        OdDbStub**        m_pLinetypeIds;
  const OdGsMarker*       m_pSelectionMarkers;
  const OdUInt8*          m_pVisibilities;
public:
  OdGiEdgeData()
    : m_pColors(NULL)
    , m_pTrueColors(NULL)
    , m_pLayerIds(NULL)
    , m_pLinetypeIds(NULL)
    , m_pSelectionMarkers(NULL)
    , m_pVisibilities(NULL)
  {}

  void setColors(
    const OdUInt16 *colors)                    { m_pColors = colors; }

  void setTrueColors(
    const OdCmEntityColor *colors)         { m_pTrueColors = colors; }

  void setLayers(
    OdDbStub* *layerIds)                       { m_pLayerIds = layerIds; }

  void setLinetypes(
    OdDbStub* *linetypeIds)                 { m_pLinetypeIds = linetypeIds; }

  void setSelectionMarkers(
    const OdGsMarker* selectionMarkers) { m_pSelectionMarkers = selectionMarkers; }

  void setVisibility(
    const OdUInt8* visibilities)           { m_pVisibilities = visibilities; }
  
  const OdUInt16* colors() const           { return m_pColors; }

  const OdCmEntityColor* trueColors() const       { return m_pTrueColors; }

  OdDbStub** layerIds() const         { return m_pLayerIds; }

  OdDbStub** linetypeIds() const      { return m_pLinetypeIds; }

  const OdGsMarker* selectionMarkers() const { return m_pSelectionMarkers; }

  const OdUInt8* visibility() const       { return m_pVisibilities; }
};
 

class OdGiFaceData
{
  const OdUInt16*         m_pColors;
  const OdCmEntityColor*  m_pTrueColors;
        OdDbStub**        m_pLayerIds;
  const OdGsMarker*       m_pSelectionMarkers;
  const OdUInt8*          m_pVisibilities;
  const OdGeVector3d*     m_pNormals;
        OdDbStub**        m_pMaterialIds;
  const OdGiMapper*       m_pMappers;
  const OdCmTransparency* m_pTransparency;
  const OdGePoint2d*      m_pFillOrigins;
  const OdGeVector2d*     m_pFillDirections;
  const OdGeVector2d*     m_pFillOffsetDirections;
  const double*           m_pFillOffsetScales;
  const double*           m_pFillDashesScales;
public:
  OdGiFaceData()
    : m_pColors(NULL)
    , m_pTrueColors(NULL)
    , m_pLayerIds(NULL)
    , m_pSelectionMarkers(NULL)
    , m_pVisibilities(NULL)
    , m_pNormals(NULL)
    , m_pMaterialIds(NULL)
    , m_pMappers(NULL)
    , m_pTransparency(NULL)
    , m_pFillOrigins(NULL)
    , m_pFillDirections(NULL)
    , m_pFillOffsetDirections(NULL)
    , m_pFillOffsetScales(NULL)
    , m_pFillDashesScales(NULL)
  {}

  void setColors(
    const OdUInt16 *colors)                    { m_pColors = colors; }

  void setTrueColors(
    const OdCmEntityColor *colors)         { m_pTrueColors = colors; }

  void setLayers(
    OdDbStub* *layerIds)                       { m_pLayerIds = layerIds; }

  void setSelectionMarkers(
    const OdGsMarker* selectionMarkers) { m_pSelectionMarkers = selectionMarkers; }

  void setNormals(
    const OdGeVector3d* normals)              { m_pNormals = normals; }

  void setVisibility(
    const OdUInt8* visibilities)           { m_pVisibilities = visibilities; }

  void setMaterials(
    OdDbStub* *materialIds)                { m_pMaterialIds = materialIds; }

  void setMappers(
    const OdGiMapper* mappers)             { m_pMappers = mappers; }

  void setTransparency(
    const OdCmTransparency *transparencies) { m_pTransparency = transparencies; }

  void setFillOrigins(
    const OdGePoint2d* fillOrigins)              { m_pFillOrigins = fillOrigins; }

  void setFillDirections(
    const OdGeVector2d* fillDirections)              { m_pFillDirections = fillDirections; }

  void setFillOffsetDirections(
    const OdGeVector2d* fillOffsetDirections)        { m_pFillOffsetDirections = fillOffsetDirections; }

  void setFillOffsetScales(
    const double* fillOffsetScales)                  { m_pFillOffsetScales = fillOffsetScales; }

  void setFillDashesScales(
    const double* fillDashesScales)                  { m_pFillDashesScales = fillDashesScales; }

  const OdUInt16* colors() const           { return m_pColors; }

  const OdCmEntityColor* trueColors() const       { return m_pTrueColors; }

  OdDbStub** layerIds() const         { return m_pLayerIds; }

  const OdGsMarker* selectionMarkers() const { return m_pSelectionMarkers; }

  const OdGeVector3d* normals() const          { return m_pNormals; }

  const OdUInt8* visibility() const       { return m_pVisibilities; }

  OdDbStub** materials() const            { return m_pMaterialIds; }

  const OdGiMapper* mappers() const       { return m_pMappers; }

  const OdCmTransparency* transparency() const { return m_pTransparency; }
  
  const OdGePoint2d* fillOrigins() const          { return m_pFillOrigins; }

  const OdGeVector2d* fillDirections() const          { return m_pFillDirections; }

  const OdGeVector2d* fillOffsetDirections() const    { return m_pFillOffsetDirections; }

  const double* fillDashesScales() const              { return m_pFillDashesScales; }

  const double* fillOffsetScales() const              { return m_pFillOffsetScales; }
};
 
typedef enum
{
  kOdGiCounterClockwise = -1,
  kOdGiNoOrientation    = 0,
  kOdGiClockwise        = 1
} OdGiOrientationType;  // Represents faces orientation for calculating various parameters.
 

class OdGiVertexData
{
  const OdGeVector3d*    m_pNormals;
  OdGiOrientationType    m_orientationFlag;
  const OdCmEntityColor* m_pTrueColors;
  const OdGePoint3d*     m_pMappingCoords;
public:
  OdGiVertexData()
    : m_pNormals(NULL)
    , m_orientationFlag(kOdGiNoOrientation)
    , m_pTrueColors(NULL)
    , m_pMappingCoords(NULL)
  {}

  enum MapChannel { 
  kAllChannels = 0
  };

  void setNormals(
    const OdGeVector3d* normals)              { m_pNormals = normals; }

  void setOrientationFlag(
    const OdGiOrientationType orientationType) { m_orientationFlag = orientationType; }

  void setTrueColors(
    const OdCmEntityColor *colors)         { m_pTrueColors = colors; }

  void setMappingCoords(
    MapChannel channel,
    const OdGePoint3d *coords)             { ODA_VERIFY(channel == kAllChannels); m_pMappingCoords = coords; }

  const OdGeVector3d* normals() const         { return m_pNormals; }

  OdGiOrientationType orientationFlag() const { return m_orientationFlag; }

  const OdCmEntityColor* trueColors() const   { return m_pTrueColors; }

  const OdGePoint3d* mappingCoords(MapChannel channel) const { ODA_VERIFY(channel == kAllChannels); return m_pMappingCoords; }
};
 
class OdGiDrawable;
struct OdGiClipBoundary;
class OdGiAbstractClipBoundary;
 
class OdDbPolyline;
class OdPolyPolygon3d;
class OdGeNurbCurve3d;
class OdGiTextStyle;
class OdDbBody;
class OdGeEllipArc3d;
class OdGiPolyline;
class OdGiBrep;

typedef enum
{
  kOdGiArcSimple = 0,   // Unfilled.
  kOdGiArcSector = 1,   // Filled area bounded by the arc and its center.
  kOdGiArcChord  = 2    // Filled area bounded by the arc and its end points
} OdGiArcType;

class FIRSTDLL_EXPORT OdGiGeometry : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGiGeometry);

  virtual OdGeMatrix3d getModelToWorldTransform() const = 0;

  virtual OdGeMatrix3d getWorldToModelTransform() const = 0;
  
  virtual void pushModelTransform(
    const OdGeVector3d& normal) = 0;

  virtual void pushModelTransform(
    const OdGeMatrix3d& xfm) = 0;

  virtual void popModelTransform() = 0;
  
  virtual void circle(
    const OdGePoint3d& center, 
    double radius, 
    const OdGeVector3d& normal) = 0;
  
  virtual void circle(
    const OdGePoint3d& firstPoint, 
    const OdGePoint3d& secondPoint, 
    const OdGePoint3d& thirdPoint) = 0;
  
  virtual void circularArc(
    const OdGePoint3d& center,
    double radius,
    const OdGeVector3d& normal,
    const OdGeVector3d& startVector,
    double sweepAngle,
    OdGiArcType arcType = kOdGiArcSimple) = 0;
  
  virtual void circularArc(
    const OdGePoint3d& firstPoint,
    const OdGePoint3d& secondPoint,
    const OdGePoint3d& thirdPoint,
    OdGiArcType arcType = kOdGiArcSimple) = 0;

  virtual void polyline(
    OdInt32 numVertices,
    const OdGePoint3d* vertexList,
    const OdGeVector3d* pNormal = 0,
    OdGsMarker baseSubEntMarker = -1) = 0;
  
  virtual void polygon(
    OdInt32 numVertices, 
    const OdGePoint3d* vertexList) = 0;

  virtual void polygon(
    OdInt32 numVertices,
    const OdGePoint3d* vertexList,
    const OdGeVector3d* pNormal);

  virtual void pline(
    const OdGiPolyline& polyline, 
    OdUInt32 fromIndex = 0, 
    OdUInt32 numSegs = 0) = 0;

  virtual void mesh(
    OdInt32 numRows,
    OdInt32 numColumns,
    const OdGePoint3d* vertexList,
    const OdGiEdgeData* pEdgeData = 0,
    const OdGiFaceData* pFaceData = 0,
    const OdGiVertexData* pVertexData = 0) = 0;
  
  virtual void shell(
    OdInt32 numVertices,
    const OdGePoint3d* vertexList,
    OdInt32 faceListSize,
    const OdInt32* faceList,
    const OdGiEdgeData* pEdgeData = 0,
    const OdGiFaceData* pFaceData = 0,
    const OdGiVertexData* pVertexData = 0) = 0;
  
  virtual void text(
    const OdGePoint3d& position,
    const OdGeVector3d& normal, 
    const OdGeVector3d& direction,
    double height, 
    double width, 
    double oblique, 
    const OdString& msg) = 0;
  
  virtual void text(
    const OdGePoint3d& position,
    const OdGeVector3d& normal, 
    const OdGeVector3d& direction,
    const OdChar* msg, 
    OdInt32 length, 
    bool raw, 
    const OdGiTextStyle* pTextStyle) = 0;
  
  virtual void xline(
    const OdGePoint3d& firstPoint, 
    const OdGePoint3d& secondPoint) = 0;

  virtual void ray(
    const OdGePoint3d& basePoint, 
    const OdGePoint3d& throughPoint) = 0;
  
  virtual void nurbs(
    const OdGeNurbCurve3d& nurbsCurve) = 0;

  virtual void ellipArc(
    const OdGeEllipArc3d& ellipArc,
    const OdGePoint3d* endPointsOverrides = 0,
    OdGiArcType arcType = kOdGiArcSimple) = 0;

  virtual void draw(
    const OdGiDrawable* pDrawable) = 0;

  virtual void pushClipBoundary(
    OdGiClipBoundary* pBoundary) = 0;

  virtual void popClipBoundary() = 0;

  virtual void worldLine(
    const OdGePoint3d points[2]) = 0;

  virtual void image(
    const OdGiImageBGRA32& img,
    const OdGePoint3d& origin,
    const OdGeVector3d& uVec,
    const OdGeVector3d& vVec,
    OdGiRasterImage::TransparencyMode trpMode = OdGiRasterImage::kTransparency8Bit) = 0;

  virtual void edge(
    const OdGiEdge2dArray& edges) = 0;

  virtual const OdGiPathNode* currentGiPath() const;

  virtual void pushClipBoundary(
    OdGiClipBoundary* pBoundary, OdGiAbstractClipBoundary* pClipInfo);

  virtual void polypoint(
    OdInt32 numPoints,
    const OdGePoint3d* vertexList,
    const OdCmEntityColor* pColors,
    const OdCmTransparency* pTransparency,
    const OdGeVector3d* pNormals = NULL,
    const OdGsMarker* pSubEntMarkers = NULL,
    OdInt32 nPointSize = 0);
  
    ODRX_SEALED_VIRTUAL void polypoint(
    OdInt32 numPoints,
    const OdGePoint3d* vertexList,
    const OdCmEntityColor* pColors,
    const OdGeVector3d* pNormals = NULL,
    const OdGsMarker* pSubEntMarkers = NULL) ODRX_FINAL;
  
    ODRX_SEALED_VIRTUAL void polypoint(
    OdInt32 numPoints,
    const OdGePoint3d* vertexList,
    const OdGeVector3d* pNormals = NULL,
    const OdGsMarker* pSubEntMarkers = NULL) ODRX_FINAL;

    virtual void polyPolygon(OdUInt32 numIndices, const OdUInt32 *pNumPositions, const OdGePoint3d *pPositions,
                             const OdUInt32 *pNumPoints, const OdGePoint3d *pPoints,
                             const OdCmEntityColor *pOutlineColors = NULL, const OdUInt32 *pOutlinePsLinetypes = NULL,
                             const OdCmEntityColor *pFillColors = NULL, const OdCmTransparency *pFillTransparencies = NULL);

  virtual void rowOfDots(
    OdInt32 numPoints, const OdGePoint3d& startPoint, const OdGeVector3d& dirToNextPoint);

  virtual void pointCloud(
    const OdGiPointCloud &pCloud);

  virtual bool brep( const OdGiBrep& giBrep );
};
 
inline const OdGiPathNode* OdGiGeometry::currentGiPath() const
{
  return 0;
}
 
inline void OdGiGeometry::pushClipBoundary(OdGiClipBoundary* pBoundary, OdGiAbstractClipBoundary* /*pClipInfo*/)
{
  // Some implementations could not support additional clipping styles, so redirect to old style clipping method by default.
  pushClipBoundary(pBoundary);
}
 
inline void OdGiGeometry::polygon(OdInt32 numVertices, const OdGePoint3d* vertexList, const OdGeVector3d* /*pNormal*/)
{
  polygon(numVertices, vertexList);
}
 
inline void OdGiGeometry::polypoint(OdInt32 numPoints, const OdGePoint3d* vertexList, const OdCmEntityColor* pColors,
                                    const OdGeVector3d* pNormals, const OdGsMarker* pSubEntMarkers)
{
  polypoint(numPoints, vertexList, pColors, NULL, pNormals, pSubEntMarkers);
}
 
inline void OdGiGeometry::polypoint(OdInt32 numPoints, const OdGePoint3d* vertexList,
                                    const OdGeVector3d* pNormals, const OdGsMarker* pSubEntMarkers)
{
  polypoint(numPoints, vertexList, NULL, pNormals, pSubEntMarkers);
}

class OdGiClipBoundarySaver
{
  bool m_bSave;
  OdGiGeometry& m_geom;
public:
  OdGiClipBoundarySaver(OdGiGeometry& geom, bool bSave) : m_bSave(bSave), m_geom(geom){}
  
  void setSave(bool bSave){m_bSave = bSave;}
  
  ~OdGiClipBoundarySaver()
  {
    if (m_bSave)
      m_geom.popClipBoundary();
  }
};

class OdGiModelTransformSaver
{
  OdGiGeometry& m_geom;
public:
  OdGiModelTransformSaver(OdGiGeometry& geom, const OdGeMatrix3d& xMat) : m_geom(geom)
  {
    m_geom.pushModelTransform(xMat);
  }
  
  ~OdGiModelTransformSaver()
  {
    m_geom.popModelTransform();
  }
};
 
/* #11298 info: Matrix identity check was removed from OdGiModelTransformSaver and place into separate OdGiModelTransformSaverOpt class.
                Identity check is also time consuming operation and it is only makes things worse if matrices become identity seldom in
                some case. Following statistics on 10 typical drawing was collected on 18.10.2012:
 
                     Source File                                     : Line     Identity=true      Identity=false     % of identity=true
..\..\..\..\..\TD\Source\Gs\GsBlockReferenceNode.cpp                 : 1263     3202               60838              5%
..\..\..\..\..\TD\Source\Gs\GsBlockReferenceNodeImpl.cpp             : 707      2                  64364              0.003%
..\..\..\..\..\TD\Source\Gs\GsBlockReferenceNodeImpl.cpp             : 868      3                  62                 4.6%
..\..\..\..\..\TD\Source\database\Entities\DbBlockReference.cpp      : 1101     25                 64905              0.038%
..\..\..\..\..\TD\Source\database\Entities\DbDimension.cpp           : 1307     12546              16                 99.87%
..\..\..\..\..\TD\Source\database\Entities\DbHatchRender.cpp         : 714      38566              0                  100%
..\..\..\..\..\TD\Source\database\Entities\DbMInsertBlock.cpp        : 322      1603               30457              5%
..\..\..\..\..\TD\Source\database\Entities\DbModelerGeometryImpl.cpp : 1410     8                  0                  100%
..\..\..\..\..\TD\Source\database\Entities\DbModelerGeometryImpl.cpp : 1545     6                  0                  100%
..\..\..\..\..\TD\Source\database\Entities\DbPoint.cpp               : 264      0                  208                0%
..\..\..\..\TD\Source\database\GiDefaultContext.cpp                  : 454      4405               0                  100%
..\..\..\..\TD\Source\database\GiDefaultContext.cpp                  : 557      124                23626              0.522%
 
All places where percents of identity=true < 10% will use OdGiModelTransformSaver. Places where Identity=true very frequent will use
OdGiModelTransformSaverOpt. Unchecked places isn't principle since them are called very seldom.                                          */

class OdGiModelTransformSaverOpt
{
  OdGiGeometry& m_geom;
  bool          m_bIdentity;
public:
  OdGiModelTransformSaverOpt(OdGiGeometry& geom, const OdGeMatrix3d& xMat) : m_geom(geom)
  {
    // @@@TODO: check, probably simple memcmp will be more effective here. memcmp is very assembler-optimized in modern crt's. Identity
    //          matrix could be inexact only after some multiplications and etc. But statistics must be collected first for isEqual check
    //          and for memcmp, if it will be faster and precisely enough isEqualTo check with tolerance can be exchanged by memcmp.
    m_bIdentity = xMat.isEqualTo(OdGeMatrix3d::kIdentity);
    if (!m_bIdentity)
      m_geom.pushModelTransform(xMat);
  }
  
  ~OdGiModelTransformSaverOpt()
  {
    if (!m_bIdentity)
      m_geom.popModelTransform();
  }
};
 
#include "TD_PackPop.h"
 
#endif