#ifndef __SLICES_H__
#define __SLICES_H__

// (Steve)
#include <iostream>
#include <fstream>
using namespace std;

#include "genlib.h"
#include "datalib.h"

#include "ledsvertex.h"
#include "ledsedgeuse.h"
#include "ledsgeometry.h"
#include "sifpart.h"


#define NDISPLAY
#define REMOVE_COLINEAR

enum SliceContourType {ctUnknown, ctInner, ctOuter};

class CLEDSliteVertex;
class CComponent;
class CSIFPart;

/*
In CSlices, we put CContourElts and CComponents into lists as shown here:

pListComponents      
        |                                           EU                EU   
       \/                                           /                 /
CComponent                             CContourElt /     CContourElt /
 ______________                        __________ /_     __________ /_
| contour----------------------->---->|          /  |   |          /  | 
| type         |<--------\      /\    | edgePtr-/   |   | edgePtr-/   |
| container------\        \      |------handle------------handle      |   
| contained------------\   -------------component---------component   |
|______________|                      |_____________|   |_____________|
| next--\      |  |     |             | next----------->| next------------>(etc)
--------|-------  |     |           /---prev        |<----prev        |     /\
        |         \/    |           | |             |   |             |      |   
        |        null   |           |  -------------     --------------      |
        |               |            ---------------------------------------- 
        |               |
        |              \/
        |             CList
        |           _____________    
        |          |              |  
        |          |    component----\
        |          |              |  |
        |          |______________|  |
        |          | next--\      |  | 
        |          --------|------   | 
        |                  |         |
        |                 \/         |
        \/               etc         |
CComponent                           |
 ______________                      |
|              |<--------------------/           
|              |           
| (etc)        |           
|              |           
| next--\      |           
--------|-------   
       \/          
      etc


*/

VOID StartLayerOutput();
VOID StartLoop();
VOID StartNested1dOutput();
VOID EndConstructOutput();
VOID StartUnionOutput();
VOID StartIntersectionOutput();
VOID StartDifferenceOutput();
VOID OutputSIFVertex(UINT_32 *, FLOAT *, FLOAT *, FLOAT *);
VOID OutputLSIFVertex(INT_32, UINT_32, Point *);
VOID OutputVertex(INT_32, UINT_32, Point *);

//////////////////////////////////////////////////////////////////////////////
// CContourElt Class
//

class CContourElt
{
//////////////////////////////////////////////////
// Initialization
//
public:
inline CContourElt();
inline ~CContourElt();
inline VOID Init();
inline VOID Init(CLEDSliteEdgeUse *);
inline VOID Uninit();

//////////////////////////////////////////////////
// Iteration Functions
//
 inline CContourElt *GetPrevLink() {return m_pPrev;};
 inline VOID SetPrevLink(CContourElt *pContourElt) {m_pPrev = pContourElt;};
 inline CContourElt *GetNextLink() {return m_pNext;};
 inline VOID SetNextLink(CContourElt *pContourElt) {m_pNext = pContourElt;};
 Point *GetPrevPt();
 Point *GetNextPt();
 CContourElt *GetPrevPtLink();
 CContourElt *GetNextPtLink();

 inline CContourElt *GetPrev() {return m_pPrev;};
 inline VOID SetPrev(CContourElt *pContourElt) {m_pPrev = pContourElt;};
 inline CContourElt *GetNext() {return m_pNext;};
 inline VOID SetNext(CContourElt *pContourElt) {m_pNext = pContourElt;};

//////////////////////////////////////////////////
// Geometric Computations
//
public:
//////////////////////////////////////////////////
// Rendering
//
public:

//////////////////////////////////////////////////
// Output Functions
//
public:
inline VOID Display();
//////////////////////////////////////////////////
// Accessor Functions
//
public:
inline CLEDSliteEdgeUse *GetEdge();
inline CCircObjectList<CContourElt> **GetContourHandle();
inline CCircObjectList<CContourElt> *GetContour();
inline CComponent *GetComponent();

inline VOID SetEdge(CLEDSliteEdgeUse *);
inline VOID SetContourHandle(CCircObjectList<CContourElt> **);
inline VOID SetContour(CCircObjectList<CContourElt> *);
inline VOID SetComponent(CComponent *);

//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
public:
protected:
CLEDSliteEdgeUse *m_peuEdge;
CCircObjectList<CContourElt> **m_ppClistContour;
CComponent *m_pClistComponent;
CContourElt *m_pPrev;
CContourElt *m_pNext;
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//
inline CContourElt::CContourElt()
{
  m_peuEdge = NULL;
  m_ppClistContour = NULL;
  m_pClistComponent = NULL;
}

inline  CContourElt::~CContourElt()
{
  Uninit();
}

inline VOID CContourElt::Init()
{
}

inline VOID CContourElt::Uninit()
{
}

inline VOID CContourElt::Init(CLEDSliteEdgeUse *peuEdge)
{
  m_peuEdge = peuEdge;
}

inline VOID CContourElt::Display()
{
  m_peuEdge->Display();
}


inline CLEDSliteEdgeUse *CContourElt::GetEdge()
{
  return m_peuEdge;
}

inline CCircObjectList<CContourElt> **CContourElt::GetContourHandle()
{
  return m_ppClistContour;
}

inline CCircObjectList<CContourElt> *CContourElt::GetContour()
{
  return *m_ppClistContour;
}

inline CComponent *CContourElt::GetComponent()
{
  return m_pClistComponent;
}


inline VOID CContourElt::SetEdge(CLEDSliteEdgeUse *peuEdge)
{
  m_peuEdge = peuEdge;
}

inline VOID CContourElt::SetContourHandle(CCircObjectList<CContourElt> **ppClistContour)
{
  m_ppClistContour = ppClistContour;
}

inline VOID CContourElt::SetContour(CCircObjectList<CContourElt> *pClistContour)
{
  if (!m_ppClistContour)
	m_ppClistContour = new (CCircObjectList<CContourElt> *);

  *(m_ppClistContour) = pClistContour;
}

inline VOID CContourElt::SetComponent(CComponent *pClistComponent)
{
  m_pClistComponent = pClistComponent;
}




//////////////////////////////////////////////////////////////////////////////
// CSliceInfo Class
//
//  This class is used for the extra information for edges

class CSliceInfo
{
//////////////////////////////////////////////////
// Initialization
//
public:
inline CSliceInfo();
inline ~CSliceInfo();
inline VOID Init();
inline VOID Init(CContourElt *);

//////////////////////////////////////////////////
// Accessor Functions
//
public:
inline BOOL InContour();
Point *UpdatePt(FLOAT, CLEDSliteEdgeUse *, FLOAT);
inline Point *GetLastPt() { return &m_ptLast; }

inline VOID SetContourEltLink(CContourElt *);
inline CContourElt *GetContourEltLink();
inline VOID SetInContour(BOOL bInContour) {m_bInContour = bInContour;};
#ifdef REMOVE_COLINEAR
inline VOID SetColinear(BOOL b);
inline BOOL GetColinear() {return m_bPtColinear;};
#endif

//inline VOID SetVtxId(UINT_32);
//inline UINT_32 GetVtxId();
/*
inline VOID AddFlags(UINT_32);
inline VOID SetFlags(UINT_32);
inline VOID RemoveFlags(UINT_32);
inline VOID ClearFlags();
*/
//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
public:
protected:
BOOL m_bInContour;
BOOL m_bPtSet;

#ifdef REMOVE_COLINEAR
BOOL m_bPtColinear;
#endif

CContourElt *m_pContourEltLink;
Point m_ptLast;
Point m_ptTop;
FLOAT m_fDelX, m_fDelY, m_fDelZ;
FLOAT m_fFraction;
//UINT_32 m_uiFlags;
//UINT_32 m_uiVtxId;
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//
inline CSliceInfo::CSliceInfo()
{
  m_bInContour = TRUE;
#ifdef REMOVE_COLINEAR
  m_bPtColinear = FALSE;
#endif
  m_bPtSet = FALSE;
  m_pContourEltLink = NULL;
  m_fFraction = 0.0;
}

inline CSliceInfo::~CSliceInfo()
{

}

inline VOID CSliceInfo::Init()
{
  m_bInContour = TRUE;
#ifdef REMOVE_COLINEAR
  m_bPtColinear = FALSE;
#endif
  m_bPtSet = FALSE;
  m_pContourEltLink = NULL;
  m_fFraction = 0.0;
}

inline VOID CSliceInfo::Init(CContourElt *pContourEltLink)
{
  m_bInContour = TRUE;
  m_pContourEltLink = pContourEltLink;
}

inline BOOL CSliceInfo::InContour()
{
  return m_bInContour;
}

inline CContourElt *CSliceInfo::GetContourEltLink()
{
  return m_pContourEltLink;
}

#ifdef REMOVE_COLINEAR
inline VOID CSliceInfo::SetColinear(BOOL bColinear)
{
#ifndef NDEBUG
  // Overwrite old intersection point with something clearly invalid
  if (bColinear) {
	m_ptLast.Set(FLT_MAX, FLT_MAX, FLT_MAX);
  }
#endif
  m_bPtColinear = bColinear;
}
#endif

inline VOID CSliceInfo::SetContourEltLink(CContourElt *pContourEltLink)
{
  m_pContourEltLink = pContourEltLink;
}
/*
inline VOID CSliceInfo::SetVtxId(UINT_32 uiId)
{
  m_uiVtxId = uiId;
}

inline UINT_32 CSliceInfo::GetVtxId()
{
  return m_uiVtxId;
}
*/
/*
inline VOID CSliceInfo::AddFlags(UINT_32 uiAdd)
{
  m_uiFlags |= uiAdd;
}

inline VOID CSliceInfo::SetFlags(UINT_32 uiFlags)
{
  m_uiFlags = uiFlags;
}

inline VOID CSliceInfo::ClearFlags()
{
  m_uiFlags = 0;
}

inline VOID CSliceInfo::RemoveFlags(UINT_32 uiRemove)
{
  UINT_32 uiMask;
  
  uiMask = !uiRemove;
  m_uiFlags &= uiMask;
}
*/

//////////////////////////////////////////////////////////////////////////////
// CComponent Class
//

class CComponent
{
//////////////////////////////////////////////////
// Friends
//
public:
//////////////////////////////////////////////////
// Enumerated Types
//
//////////////////////////////////////////////////
// Initialization
//
public:
  CComponent();
inline  ~CComponent();
inline  VOID Init();
inline  VOID Init(CCircObjectList<CContourElt> *);
  VOID Uninit();

//////////////////////////////////////////////////
// Iteration Functions
//

//////////////////////////////////////////////////
// Geometric Computations
//
public:
CContourElt *GetRightmostElt();
SliceContourType DeriveType();
SliceContourType FindType(CList<Point *, UINT_8> *);
BOOL CalculateNormalZ(FLOAT *pfNormalZ, CList<Point *, UINT_8> *pCListVerts);
VOID NewPtInComponent(Point *, CList<Point *, UINT_8> *,
					  UINT_32 *, FLOAT);
//CList<Point *, UINT_8> *
VOID IntersectContour(FLOAT fZ, FLOAT fThick, FLOAT fEps);
//////////////////////////////////////////////////
// Rendering
//
public:

//////////////////////////////////////////////////
// Output Functions
//
public:
VOID Output(INT_32);
VOID OutputVertices(INT_32);
VOID PrintLoopVertices();
//////////////////////////////////////////////////
// Accessor Functions
//
public:
inline SliceContourType GetType() {return m_ctType;};
inline CCircObjectList<CContourElt> **GetContourHandle();
inline CCircObjectList<CContourElt> *GetContour();
inline CList<CComponent *, UINT_8> *GetContained();
inline CComponent *GetContainer();
inline FLOAT GetMinX();
inline FLOAT GetMaxX();
inline FLOAT GetMinY();
inline FLOAT GetMaxY();
inline UINT_32 GetFirstID();
inline UINT_32 GetLastID();

inline VOID SetContourHandle(CCircObjectList<CContourElt> **);
inline VOID SetContour(CCircObjectList<CContourElt> *);
inline VOID SetType(SliceContourType);
inline VOID UnsetType();
inline VOID SetContained(CList<CComponent *, UINT_8> *);
inline VOID SetContainer(CComponent *);
VOID SetContainerMutual(CComponent *);
inline VOID SetMinX(FLOAT);
inline VOID SetMaxX(FLOAT);
inline VOID SetMinY(FLOAT);
inline VOID SetMaxY(FLOAT);
inline VOID SetFirstID(UINT_32);
inline VOID SetLastID(UINT_32);
inline CList<Point *, UINT_8> *GetListVertices() {return m_pCListVerts;};

VOID InvalidateNesting();
VOID RemoveFromContainer();
float CalculateArea();
//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
public:
protected:
SliceContourType m_ctType;
CCircObjectList<CContourElt> **m_ppClistContour;
//CListInt *m_pClistContained;
CList<CComponent *, UINT_8> *m_pClistContained;
CComponent *m_pCComponentContainer;
FLOAT m_fMinX;
FLOAT m_fMaxX;
FLOAT m_fMinY;
FLOAT m_fMaxY;
UINT_32 m_uiFirstID;
UINT_32 m_uiLastID;
CList<Point *, UINT_8> *m_pCListVerts;
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//

inline CComponent::~CComponent()
{
  Uninit();
}

inline VOID CComponent::Init()
{

}

inline VOID CComponent::Init(CCircObjectList<CContourElt> *pClistContour)
{
  SetContour(pClistContour);
}

/*
inline SliceContourType CComponent::GetType()
{
  return m_ctType;
}
*/
inline CCircObjectList<CContourElt> **CComponent::GetContourHandle()
{
  return m_ppClistContour;
}

inline CCircObjectList<CContourElt> *CComponent::GetContour()
{
  return *m_ppClistContour;
}

inline CList<CComponent *, UINT_8> *CComponent::GetContained()
{
  return m_pClistContained;
}

inline CComponent *CComponent::GetContainer()
{
  return m_pCComponentContainer;
}

inline FLOAT CComponent::GetMinX()
{
  return m_fMinX;
}

inline FLOAT CComponent::GetMaxX()
{
  return m_fMaxX;
}

inline FLOAT CComponent::GetMinY()
{
  return m_fMinY;
}

inline FLOAT CComponent::GetMaxY()
{
  return m_fMaxY;
}

inline UINT_32 CComponent::GetFirstID()
{
  return m_uiFirstID;
}

inline UINT_32 CComponent::GetLastID()
{
  return m_uiLastID;
}


inline VOID CComponent::SetType(SliceContourType Type)
{
 m_ctType = Type;
}

inline VOID CComponent::UnsetType()
{
 m_ctType = ctUnknown;
}

inline VOID CComponent::SetContourHandle(CCircObjectList<CContourElt> **ppClistContour)
{
 m_ppClistContour = ppClistContour;
}

inline VOID CComponent::SetContour(CCircObjectList<CContourElt> *pClistContour)
{
  if (!m_ppClistContour)
	m_ppClistContour = new (CCircObjectList<CContourElt> *);

  *(m_ppClistContour) = pClistContour;
}

inline VOID CComponent::SetContained(CList<CComponent *, UINT_8> *pClistContained)
{
  m_pClistContained = pClistContained;
}

inline VOID CComponent::SetContainer(CComponent *pCComponentContainer)
{
  m_pCComponentContainer = pCComponentContainer;
}

inline VOID CComponent::SetMinX(FLOAT fMinX)
{
  m_fMinX = fMinX;
}

inline VOID CComponent::SetMaxX(FLOAT fMaxX)
{
  m_fMaxX = fMaxX;
}

inline VOID CComponent::SetMinY(FLOAT fMinY)
{
 m_fMinY = fMinY;
}

inline VOID CComponent::SetMaxY(FLOAT fMaxY)
{
 m_fMaxY = fMaxY;
}

inline VOID CComponent::SetFirstID(UINT_32 uiFirstID)
{
 m_uiFirstID = uiFirstID;
}

inline VOID CComponent::SetLastID(UINT_32 uiLastID)
{
 m_uiLastID = uiLastID;
}




//////////////////////////////////////////////////////////////////////////////
// CSlices Class
//

class CSlices// : public 
{
//////////////////////////////////////////////////
// Friends
//
public:
  friend class CSlicesIter;
  friend class CSlicesInfo;

//////////////////////////////////////////////////
// Enumerated Types
//

//////////////////////////////////////////////////
// Initialization
//
public:
  CSlices();
   ~CSlices();
   VOID Init();
//   VOID Init(CLEDSGeometry *);
   VOID Init(CSIFPart *);
   VOID Uninit();

  //   BOOL Valid();

//////////////////////////////////////////////////
// Iteration Functions
//
public:
// CGeometryIter *AllocateIter();
// VOID FreeIter(CGeometryIter *pCSlicesIter);

//////////////////////////////////////////////////
// Geometric Computations
//
public:
VOID SliceIt();
protected:
//VOID oldDoIntersect(FLOAT, CList<CComponent *, UINT_8> *);
VOID DoIntersect(FLOAT);
//VOID OutputVertices(CComponent *);
//VOID OutputVertices(CList<Point *, UINT_8> *, CComponent *);
//VOID IntersectContour(FLOAT, CComponent *);
VOID IntersectEdge(FLOAT, CLEDSliteEdgeUse *, FLOAT *, FLOAT *);
VOID SetNesting(CComponent *, CList<CComponent *, UINT_8> *);
VOID CoincidentPointTest(CList<CContourElt *, DOUBLE> *, CContourElt *,
						 CContourElt *, CComponent *, CComponent *, DOUBLE, 
						 DOUBLE, DOUBLE, DOUBLE, Point *, Point *);
VOID RayCastNesting(CComponent *, CList<CComponent *, UINT_8> *);
DOUBLE *IntersectTest(DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, BOOL *);
CComponent *AreaTest(CComponent *, CList<CComponent *, UINT_8> *);
CComponent *ProcessIntersectionList(CComponent *,CList<CContourElt *,DOUBLE> *);
//VOID StartLayerOutput();
//VOID StartLoop();
//VOID PrintLoopVertices(CComponent *pComponent);
//VOID StartNested1dOutput();
//VOID EndConstructOutput();
VOID OutputThickness(float);
VOID OutputHeader(CSIFPart *);
VOID OutputSIFHeader();
VOID OutputLSIFHeader(CSIFPart *);
VOID OutputTrailer();
//VOID OutputSIFVertex(UINT_32 *, FLOAT *, FLOAT *, FLOAT *);
//VOID OutputLSIFVertex(INT_32, UINT_32, Point *);
//VOID OutputVertex(UINT_32, Point *);
VOID ModifyComponents(CLEDSliteVertex *, CList<CComponent *, UINT_8> *);
CCircularListInt *MakeContour(CListInt *);

#ifdef CONCAVE_FACES
CContourElt *SpecialCase(CContourElt *, CContourElt **, CContourElt **);
VOID SpliceSpecial(CContourElt *, CContourElt *, CContourElt *, CContourElt *);
#endif // CONCAVE_FACES

CList<CCircObjectList<CContourElt> *, UINT_8> *MakeContours(CLEDSliteVertex *pVtx);
VOID MakeContour(CLEDSliteEdgeUse *, CCircObjectList<CContourElt> *);
VOID ProcessNewContour(CCircObjectList<CContourElt> *, CList<CComponent *, UINT_8> *);
VOID ProcessAllBegins(CCircObjectList<CContourElt> *, CList<CComponent *, UINT_8> *);
VOID ProcessAllEnds(CContourElt *, CList<CComponent *, UINT_8> *);
CContourElt *GetMatch(CContourElt *);
VOID Splice(CContourElt *, CContourElt *, 
			CContourElt *, CContourElt *);
CComponent *SplitOrMerge(CContourElt *, CContourElt *,
						 CContourElt *,  CContourElt *,
						 CList<CComponent *, UINT_8> *);
VOID DeleteMatchingEndRun(CContourElt *, CContourElt *);
VOID UpdateLinksContourInfo(CContourElt *,
									 CContourElt *,
									 CComponent *);
VOID SearchBackwardsFirstEnd(CContourElt *pLinkCurr, 
									  CContourElt *pLinkCurrMatch, 
									  CContourElt **ppLinkFirstEnd, 
									  CContourElt **ppLinkFirstEndMatch);
VOID UpdateContourElt(CContourElt *, CComponent *);
CComponent *MakeNewComponent(CCircObjectList<CContourElt> *, CList<CComponent *, UINT_8> *);

VOID DeletePair(CContourElt *pLinkCurr);
VOID CleanFaces();
//////////////////////////////////////////////////
// Rendering
//
public:

//////////////////////////////////////////////////
// Output Functions
//
public:
private:
VOID PrintComponents(CList<CComponent *, UINT_8> *pListComponents);
//////////////////////////////////////////////////
// Accessor Functions
//
public:
inline  CDynamicArray<CLEDSliteVertex *> *GetpVertexArray();
inline  UINT_32 GetuiNumVerts();
inline  FLOAT GetOffset();
inline  FLOAT GetThickness();
inline  FLOAT GetMinZ();
inline  FLOAT GetSliceZ();
inline  Vector GetvUp();

inline  VOID SetpVertexArray(CDynamicArray<CLEDSliteVertex *> *);
inline  VOID SetuiNumVerts(UINT_32);
inline  VOID SetPrecisionExp(INT_32);
inline  VOID SetOffset(FLOAT);
inline  VOID SetThickness(FLOAT);
inline  VOID SetScale(FLOAT);
inline  VOID SetMinZ(FLOAT);
inline  VOID SetSliceZ(FLOAT);
inline  VOID SetvUp(Vector);

//////////////////////////////////////////////////
// Class Variables
//
public:

//////////////////////////////////////////////////
// Member Variables
//
public:
protected:
//  CLEDSGeometry *m_pCLEDSGeometry;
  // CListInt *m_pListVertices;
  // CListInt *m_pListComponents;
  CDynamicArray<CLEDSliteVertex *> *m_pVertexArray;
  UINT_32 m_uiNumVerts;
  FLOAT m_fOffset;
  FLOAT m_fThickness;
  FLOAT m_fScale;
  FLOAT m_fMinZ;
  FLOAT m_fSliceZ;
  Vector m_vUp;
  INT_32 m_iPrecisionExp;
  FLOAT m_fEps;
  CSIFPart *m_pCSIFPart;
};

//////////////////////////////////////////////////////////////////////////////
// Inlined Functions
//
/*
inline  CListInt *CSlices::GetpListVertices()
{
  return m_pListVertices;
}

inline  CListInt *CSlices::GetpListComponents()
{
  return m_pListComponents;
}
*/
inline CDynamicArray<CLEDSliteVertex *> *CSlices::GetpVertexArray()
{
  return m_pVertexArray;
}

inline  UINT_32 CSlices::GetuiNumVerts()
{
  return m_uiNumVerts;
}

inline  FLOAT CSlices::GetOffset()
{
  return m_fOffset;
}

inline  FLOAT CSlices::GetThickness()
{
  return m_fThickness;
}

inline  FLOAT CSlices::GetMinZ()
{
  return m_fMinZ;
}

inline  FLOAT CSlices::GetSliceZ()
{
  return m_fSliceZ;
}

inline  Vector CSlices::GetvUp()
{
  return m_vUp;
}

/*
inline  VOID CSlices::SetpListVertices(CListInt *pListVertices)
{
  m_pListVertices = pListVertices;
}

inline  VOID CSlices::SetpListComponents(CListInt *pListComponents)
{
  m_pListComponents = pListComponents;
}
*/
inline  VOID CSlices::SetpVertexArray(CDynamicArray<CLEDSliteVertex *> *pVertexArray)
{
  m_pVertexArray = pVertexArray;
}

inline  VOID CSlices::SetuiNumVerts(UINT_32 uiNumVerts)
{
  m_uiNumVerts = uiNumVerts;
}

inline  VOID CSlices::SetOffset(FLOAT Offset)
{
  m_fOffset = Offset;
}

inline  VOID CSlices::SetThickness(FLOAT Thickness)
{
  m_fThickness = Thickness;
}

inline  VOID CSlices::SetScale(FLOAT fScale)
{
  m_fScale = fScale;
}

inline  VOID CSlices::SetPrecisionExp(INT_32 iPrecisionExp)
{
   m_iPrecisionExp = iPrecisionExp; 
}

inline  VOID CSlices::SetMinZ(FLOAT MinZ)
{
  m_fMinZ = MinZ;
}

inline  VOID CSlices::SetSliceZ(FLOAT SliceZ)
{
  m_fSliceZ = SliceZ;
}

inline  VOID CSlices::SetvUp(Vector vUp)
{
  m_vUp = vUp;
}




//////////////////////////////////////////////////////////////////////////////
// CSlicesIter Class
//

#endif // __SLICES_H__