///////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2002-2025, 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-2025 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 __OD_GS_VISUALIZE_CLIP__
#define __OD_GS_VISUALIZE_CLIP__

#include "TD_PackPush.h"

#include "Gs/GsBaseInclude.h"
#include "GsVisualizeGeometry.h"
#include "GsVisualizeVectorizer.h"
#include "TvFactory.h"
#include "Gi/GiOrthoClipperEx.h"

//Redirects ExGsVisualize-specific methods to the geometry
class ExGsVisualizeGeometryRedirector : public ExGsVisualizeGeometryBase
{
protected:
  ExGsVisualizeGeometry* m_pGeom;
public:
  ExGsVisualizeGeometryRedirector( ExGsVisualizeVectorizer* pVect )
  {
    m_pGeom = new ExGsVisualizeGeometry( pVect );
  }
  virtual ~ExGsVisualizeGeometryRedirector()
  {
    delete m_pGeom;
  }

  virtual bool getDisableEntityCaching() const { return m_pGeom->getDisableEntityCaching(); }
  virtual void setDisableEntityCaching( bool b ) { m_pGeom->setDisableEntityCaching( b ); }
  virtual void setDrawContext( OdGiConveyorContext* pDrawCtx ) { m_pGeom->setDrawContext( pDrawCtx ); }
  virtual void setTimer( ExGsVisualizeTimer* timer ) { m_pGeom->setTimer( timer ); }
  virtual void resetApplyTransform() { m_pGeom->resetApplyTransform(); }
  virtual bool isSilentMode() const { return m_pGeom->isSilentMode(); }
  virtual void setSilentMode( bool b ) { m_pGeom->setSilentMode( b ); }
  virtual void setTvDatabaseId( OdTvDatabaseId id ) { m_pGeom->setTvDatabaseId( id ); }
  virtual void applyEffectiveTraits( const OdGiSubEntityTraitsData& effectiveTraits ) { m_pGeom->applyEffectiveTraits( effectiveTraits ); }
  virtual void setTvEntity( OdTvEntityId entityId, bool forInsert = false ) { m_pGeom->setTvEntity( entityId, forInsert ); }
  virtual void setTvInsert( OdTvEntityId entityId ) { m_pGeom->setTvInsert( entityId ); }
  virtual OdTvEntityId getTvEntityId() const { return m_pGeom->getTvEntityId(); }
  virtual void applyEffectiveTraitsToInsert( const OdGiSubEntityTraitsData& effectiveTraits, OdGeMatrix3d* pCustomTransform = NULL )
  {
    m_pGeom->applyEffectiveTraitsToInsert( effectiveTraits, pCustomTransform );
  }
  virtual void applyClipBoundaryToInsert( OdGiClipBoundary* pBoundary, OdGiAbstractClipBoundary* pAbsBoundary )
  {
    m_pGeom->applyClipBoundaryToInsert( pBoundary, pAbsBoundary );
  }
  virtual void pushState() { m_pGeom->pushState(); }
  virtual void popState() { m_pGeom->popState(); }
  virtual void setDrawableId( const OdTvRegAppId& appId, OdDbStub* pStub, const OdTvRegAppId& appIdDbId) { m_pGeom->setDrawableId( appId, pStub, appIdDbId); }
  virtual OdVisualizeEntityStack& subEntityStack() { return m_pGeom->subEntityStack(); }
  virtual void pushModelTransform( const OdGeMatrix3d& xMat ) { m_pGeom->pushModelTransform( xMat ); }
  virtual void popModelTransform() { m_pGeom->popModelTransform(); }
  virtual const OdGeMatrix3d& modelTransform() const { return m_pGeom->modelTransform(); }
  virtual void setTargetDisplayMode( OdTvGeometryData::TargetDisplayMode mode ) { m_pGeom->setTargetDisplayMode( mode ); }
  virtual bool brep( const OdGiBrep& brep ) { return m_pGeom->brep( brep ); }
  virtual OdUInt64 forceSubEntityFrom( OdUInt64 nEntHandle, const OdString& name, const OdTvRegAppId& appId = OdTvRegAppId(), const OdTvRegAppId& appIdDbId = OdTvRegAppId(), OdDbStub* id = nullptr ) { return m_pGeom->forceSubEntityFrom( nEntHandle, name, appId, appIdDbId, id ); }
  virtual OdGiConveyorGeometry& asGeometry()
  {
    return *m_pGeom;
  }
  void setGeometryNotifier( ExGsVisualizeGeomertyNotifier* pNotifier )
  {
    m_pGeom->setGeometryNotifier( pNotifier );
  }
};

//Redirects both ExGsVisualize-specific methods and OdGiConveyorGeometry to the geometry
class ExGsVisualizeGeometryWrapper : public ExGsVisualizeGeometryRedirector
{
protected:
  OdGiConveyorGeometry* m_pOut;
public:
  ExGsVisualizeGeometryWrapper( ExGsVisualizeVectorizer* pVect ) : ExGsVisualizeGeometryRedirector( pVect ) { m_pOut = nullptr; }
  virtual ~ExGsVisualizeGeometryWrapper() {}

  virtual void setOutput( OdGiConveyorGeometry* pOut ) { m_pOut = pOut; }

  virtual void plineProc( const OdGiPolyline& polyline,
    const OdGeMatrix3d* pXfm = 0,
    OdUInt32 fromIndex = 0,
    OdUInt32 numSegs = 0 ) 
  { 
    m_pOut->plineProc( polyline, pXfm, fromIndex, numSegs ); 
  }
  virtual void polylineProc(
    OdInt32 numPoints, const OdGePoint3d* vertexList,
    const OdGeVector3d* pNormal = 0,
    const OdGeVector3d* pExtrusion = 0,
    OdGsMarker baseSubEntMarker = -1 )
  {
    m_pOut->polylineProc( numPoints, vertexList, pNormal, pExtrusion, baseSubEntMarker );
  }
  virtual void polygonProc(
    OdInt32 numPoints, const OdGePoint3d* vertexList,
    const OdGeVector3d* pNormal = 0,
    const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->polygonProc( numPoints, vertexList, pNormal, pExtrusion );
  }
  virtual void xlineProc(
    const OdGePoint3d& firstPoint, const OdGePoint3d& secondPoint )
  {
    m_pOut->xlineProc( firstPoint, secondPoint );
  }
  virtual void rayProc(
    const OdGePoint3d& basePoint, const OdGePoint3d& throughPoint )
  {
    m_pOut->rayProc( basePoint, throughPoint );
  }
  virtual void meshProc(
    OdInt32 numRows,
    OdInt32 numColumns,
    const OdGePoint3d* vertexList,
    const OdGiEdgeData* pEdgeData = 0,
    const OdGiFaceData* pFaceData = 0,
    const OdGiVertexData* pVertexData = 0 )
  {
    m_pOut->meshProc( numRows, numColumns, vertexList, pEdgeData, pFaceData, pVertexData );
  }
  virtual void shellProc(
    OdInt32 numVertices, const OdGePoint3d* vertexList,
    OdInt32 faceListSize, const OdInt32* faceList,
    const OdGiEdgeData* pEdgeData = 0,
    const OdGiFaceData* pFaceData = 0,
    const OdGiVertexData* pVertexData = 0 )
  {
    m_pOut->shellProc( numVertices, vertexList, faceListSize, faceList, pEdgeData, pFaceData, pVertexData );
  }
  virtual void circleProc(
    const OdGePoint3d& center,
    double radius,
    const OdGeVector3d& normal,
    const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->circleProc( center, radius, normal, pExtrusion );
  }
  virtual void circleProc(
    const OdGePoint3d& firstPoint,
    const OdGePoint3d& secondPoint,
    const OdGePoint3d& thirdPoint,
    const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->circleProc( firstPoint, secondPoint, thirdPoint, pExtrusion );
  }
  virtual void circularArcProc(
    const OdGePoint3d& center,
    double radius,
    const OdGeVector3d& normal,
    const OdGeVector3d& startVector,
    double sweepAngle,
    OdGiArcType arcType = kOdGiArcSimple, const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->circularArcProc( center, radius, normal, startVector, sweepAngle, arcType, pExtrusion );
  }
  virtual void circularArcProc(
    const OdGePoint3d& firstPoint,
    const OdGePoint3d& secondPoint,
    const OdGePoint3d& thirdPoint,
    OdGiArcType arcType = kOdGiArcSimple, const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->circularArcProc( firstPoint, secondPoint, thirdPoint, arcType, pExtrusion );
  }
  virtual void ellipArcProc(
    const OdGeEllipArc3d& ellipArc,
    const OdGePoint3d* endPointOverrides = 0,
    OdGiArcType arcType = kOdGiArcSimple, const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->ellipArcProc( ellipArc, endPointOverrides, arcType, pExtrusion );
  }
  virtual void nurbsProc(
    const OdGeNurbCurve3d& nurbsCurve )
  {
    m_pOut->nurbsProc( nurbsCurve );
  }
  virtual void textProc(
    const OdGePoint3d& position,
    const OdGeVector3d& direction,
    const OdGeVector3d& upVector,
    const OdChar* msg,
    OdInt32 numBytes,
    bool raw,
    const OdGiTextStyle* pTextStyle,
    const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->textProc( position, direction, upVector, msg, numBytes, raw, pTextStyle, pExtrusion );
  }
  virtual void shapeProc(
    const OdGePoint3d& position,
    const OdGeVector3d& direction,
    const OdGeVector3d& upVector,
    int shapeNumber,
    const OdGiTextStyle* pTextStyle,
    const OdGeVector3d* pExtrusion = 0 )
  {
    m_pOut->shapeProc( position, direction, upVector, shapeNumber, pTextStyle, pExtrusion );
  }
  virtual void rasterImageProc(
    const OdGePoint3d& origin,
    const OdGeVector3d& u,
    const OdGeVector3d& v,
    const OdGiRasterImage* pImage,
    const OdGePoint2d* uvBoundary,
    OdUInt32 numBoundPts,
    bool transparency = false,
    double brightness = 50.0,
    double contrast = 50.0,
    double fade = 0.0 )
  {
    m_pOut->rasterImageProc( origin, u, v, pImage, uvBoundary, numBoundPts, transparency, brightness, contrast, fade );
  }
  virtual void metafileProc(
    const OdGePoint3d& origin,
    const OdGeVector3d& u,
    const OdGeVector3d& v,
    const OdGiMetafile* pMetafile,
    bool dcAligned = true,
    bool allowClipping = false )
  {
    m_pOut->metafileProc( origin, u, v, pMetafile, dcAligned, allowClipping );
  }
  virtual void polypointProc(
    OdInt32 numPoints, const OdGePoint3d* vertexList, const OdCmEntityColor* pColors,
    const OdCmTransparency* pTransparency = 0, const OdGeVector3d* pNormals = 0, const OdGeVector3d* pExtrusions = 0,
    const OdGsMarker* pSubEntMarkers = 0, OdInt32 nPointSize = 0 )
  {
    m_pOut->polypointProc( numPoints, vertexList, pColors, pTransparency, pNormals, pExtrusions, pSubEntMarkers, nPointSize );
  }
  virtual void rowOfDotsProc(
    OdInt32 numPoints, const OdGePoint3d& startPoint, const OdGeVector3d& dirToNextPoint )
  {
    m_pOut->rowOfDotsProc( numPoints, startPoint, dirToNextPoint );
  }
  virtual void pointCloudProc( const OdGiPointCloud& pCloud, const OdGiPointCloudFilter* pFilter = NULL )
  {
    m_pOut->pointCloudProc( pCloud, pFilter );
  }
  virtual void edgeProc(
    const OdGiEdge2dArray& edges, const OdGeMatrix3d* pXform = 0 )
  {
    m_pOut->edgeProc( edges, pXform );
  }
};

class ExGsVisualizeClippedGeometryWrapper : public ExGsVisualizeGeometryWrapper
{
public:
  ExGsVisualizeClippedGeometryWrapper( ExGsVisualizeVectorizer* pVect, OdGiOrthoClipperEx* pClipper, OdGiAbstractClipBoundary* pClipInfo );
  virtual ~ExGsVisualizeClippedGeometryWrapper()
  {
  }
  virtual OdGiOrthoClipperEx* asClipper()
  {
    return m_pClipper;
  }

  virtual void pushModelTransform( const OdGeMatrix3d& xMat );
  virtual void popModelTransform();
protected:
  OdGiOrthoClipperEx* m_pClipper;
  OdTvMatrix3dStack m_matrixStack;

  OdGiAbstractClipBoundary* m_pClipInfo;
};

#include "TD_PackPop.h"

#endif // __OD_GS_VISUALIZE_CLIP__