TrackInfo.h

#ifndef __CRUNCHER_TRACKINFO
#define __CRUNCHER_TRACKINFO
 
#include "PolygonCruncherConfig.h"
#include "3DType.h"
#include "OffsetArray.h"
#include "3DPoint.h"
#include "3DFace.h"
#include "UVWFace.h"
#include "UVWPoint.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//////////////////////////////
// Minimum informations change
//////////////////////////////
#define CELL_INDEX_TO_ACTION(a) ((NewCellState)(a + 2))
#ifdef _DEBUG
    int CELL_ACTION_TO_INDEX(int a);
#else
#   define CELL_ACTION_TO_INDEX(a) (a-2)
#endif
 
typedef enum XEnumType(unsigned char)
{
    CELL_ACTION_UNDEFINED = 0,
 
    // Cell action contains CELL_FACE_INDEX0...CELL_FACE_INDEX3
    // or a number of isolated points for CTrackInvalidFace (it must be the LOW part of the byte (CTrackInvalidFace::SetIsolatedFacePointNumber)
    CELL_ACTION = 0x0F,
    CELL_INDEX_TO_VALUE = 2, // Beware check CELL_FACE_NOINDEX - CELL_INDEX_TO_VALUE is negative, check CELL_FACE_NOINDEX value before
    CELL_FACE_NOINDEX = 0x01, // The faces indexes remain the same (Occurs when interpolating, see ReplacePointInFaceList)
    CELL_FACE_INDEX0 = 0x02, // Index of the face change (beware we do CELL_FACE_INDEX0+j sometime, number must follows)
    CELL_FACE_INDEX1 = 0x03,
    CELL_FACE_INDEX2 = 0x04,
    CELL_SAME_AS_REMAINING = 0x01, // for CELL_KINDOF_MOVE_POINT
    CELL_SAME_AS_REMOVED = 0x02,
 
    // Defines the cell class
    CELL_KINDOF_MASK = 0xF0,
    CELL_KINDOF_EDGE_CONTRACTION = 0x10, // Refers to CTrackEdgeContraction
    CELL_KINDOF_UV_CONTRACTION = 0x20, // Refers to CTrackUVContraction
    CELL_KINDOF_NORMAL_CONTRACTION = 0x30, // Refers to CTrackNormalContraction
    CELL_KINDOF_INVALIDFACE = 0x40, // Refers to CTrackInvalidFace
    CELL_KINDOF_FACE = 0x50, // Refers to CTrackFace
    CELL_KINDOF_UVFACE = 0x60, // Refers to CTrackChannelFace
    CELL_KINDOF_NORMALFACE = 0x70, // Refers to CTrackNormalFace
    CELL_KINDOF_MOVE_DUPLICATED_POINT = 0x80, // Refers to CTrackMoveDuplicatedPoint
#ifdef PLY_FLIP_EDGES
    CELL_KINDOF_FACE2 = 0x90, // Refers to CTrackFace2
    CELL_KINDOF_UVFACE2 = 0xA0, // Refers to CUVTrackFace2
#endif
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
    // These allows to follow the flag state for point and face
    CELL_KINDOF_POINTFLAGS = 0xD0, // Refers to CTrackFlags
    CELL_KINDOF_FACEFLAGS = 0xE0, // Refers to CTrackFlags
    CELL_KINDOF_NORMALPTFLAGS = 0xF0, // Refers to CTrackFlags
#endif // MOOTOOLS_PRIVATE_DEBUG
    // beware state is a char
} NewCellState;
 
class CTrackContractions;
class CTrackInfo
{
    friend CTrackContractions;
 
protected:
    unsigned char state;
 
    void Init();
    void SetKindOf(NewCellState apply);
 
public:
    void SetChange(NewCellState state);
    unsigned char GetChange();
    unsigned int GetKindOf();
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackInfo::Init()
{
    state = CELL_ACTION_UNDEFINED;
}
 
inline void CTrackInfo::SetKindOf(NewCellState apply)
{
    state &= (unsigned char)(~CELL_KINDOF_MASK);
    state |= (unsigned char)apply;
}
 
inline void CTrackInfo::SetChange(NewCellState state)
{
    this->state &= (unsigned char)(~CELL_ACTION);
    this->state |= (unsigned char)state;
}
 
inline unsigned char CTrackInfo::GetChange()
{
    return (state & CELL_ACTION);
}
 
inline unsigned int CTrackInfo::GetKindOf() // unsigned int for KINDOF2OFFSET
{
    return (state & CELL_KINDOF_MASK);
}
#endif // MOOTOOLS_NO_INLINE
///////////////////////////////////////////
// Tracking point / normal / uv contraction
 
// Stack of all change that appears when contracting one pair
class DLLFUNCTION CTrackEdgeContraction : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    float pos[3];
 
    int ptIndexWas;
    int ptIndexBecome;
 
public:
    void SetPoint(C3DPoint& point);
    void GetPoint(C3DPoint& point);
    const float *GetPoint() const;
    void SetEdgeContraction(int indexwas, int indexbecome);
    void GetEdgeContraction(int& indexwas, int& indexbecome);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackEdgeContraction::SetPoint(C3DPoint& point)
{
    // We store the old position. The new one is stored in the mesh while it is created
    // Then we swap the position when modifying the resolution
    memcpy(pos, point.ValPtr(), 3 * sizeof(float));
}
 
inline void CTrackEdgeContraction::GetPoint(C3DPoint& point)
{
    memcpy(point.ValPtr(), pos, 3 * sizeof(float));
}
 
inline const float *CTrackEdgeContraction::GetPoint() const
{
    return pos;
}
 
inline void CTrackEdgeContraction::SetEdgeContraction(int indexwas, int indexbecome)
{
    ptIndexWas = indexwas;
    ptIndexBecome = indexbecome;
}
 
inline void CTrackEdgeContraction::GetEdgeContraction(int& indexwas, int& indexbecome)
{
    indexwas = ptIndexWas;
    indexbecome = ptIndexBecome;
}
#endif // MOOTOOLS_NO_INLINE
 
class DLLFUNCTION CTrackMoveDuplicatedPoint : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    int index;
 
public:
    void SetIndex(int index);
    int GetIndex() const;
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackMoveDuplicatedPoint::SetIndex(int index)
{
    this->index = index;
}
 
inline int CTrackMoveDuplicatedPoint::GetIndex() const
{
    return index;
}
#endif // MOOTOOLS_NO_INLINE
 
class DLLFUNCTION CTrackNormalContraction : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    float pos[3];
    int index;
 
public:
    void SetNormalIndex(int index);
    int GetNormalIndex() const;
    void SetNormal(C3DVector& normal);
    void GetNormal(C3DVector& normal);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackNormalContraction::SetNormalIndex(int index)
{
    this->index = index;
}
 
inline int CTrackNormalContraction::GetNormalIndex() const
{
    return index;
}
 
inline void CTrackNormalContraction::SetNormal(C3DVector& normal)
{
    memcpy(pos, normal.ValPtr(), 3 * sizeof(float));
}
 
inline void CTrackNormalContraction::GetNormal(C3DVector& normal)
{
    memcpy(normal.ValPtr(), pos, 3 * sizeof(float));
}
#endif // MOOTOOLS_NO_INLINE
 
class DLLFUNCTION CTrackUVContraction : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    float pos[3];
    int index;
    unsigned char channel;
 
public:
    void SetUVWIndex(int index);
    int GetUVWIndex() const;
 
    void SetUVWPoint(CUVWPoint& point);
    void GetUVWPoint(CUVWPoint& point);
    const float *GetUVWPoint() const;
    unsigned char GetChannel() const;
    void SetChannel(unsigned char channel);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackUVContraction::SetUVWIndex(int index)
{
    this->index = index;
}
 
inline int CTrackUVContraction::GetUVWIndex() const
{
    return index;
}
 
inline void CTrackUVContraction::SetUVWPoint(CUVWPoint& point)
{
    memcpy(pos, point.ValPtr(), 3 * sizeof(float));
}
 
inline void CTrackUVContraction::GetUVWPoint(CUVWPoint& point)
{
    memcpy(point.ValPtr(), pos, 3 * sizeof(float));
}
 
inline const float *CTrackUVContraction::GetUVWPoint() const
{
    return pos;
}
 
inline unsigned char CTrackUVContraction::GetChannel() const
{
    return channel;
}
 
inline void CTrackUVContraction::SetChannel(unsigned char channel)
{
    this->channel = channel;
}
#endif // MOOTOOLS_NO_INLINE
 
///////////////////////////////////////////
// Tracking face contraction
 
class DLLFUNCTION CTrackFace : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    int faceIndex; // index of the element which change
 
public:
    void SetCurrentFace(int faceIndex);
    int GetCurrentFace();
 
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackFace::SetCurrentFace(int faceIndex)
{
    this->faceIndex = faceIndex;
}
 
inline int CTrackFace::GetCurrentFace()
{
    return faceIndex;
}
#endif // MOOTOOLS_NO_INLINE
 
class DLLFUNCTION CTrackInvalidFace : public CTrackFace
{
public:
    // This value indicate how many points are removed when an isolated face
    // is removed (the edge contraction make the face invalid).
    // Others points of the face are then removed.
    int GetIsolatedFacePointNumber() const;
    void SetIsolatedFacePointNumber(int ptnbr);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline int CTrackInvalidFace::GetIsolatedFacePointNumber() const
{
    return (state & CELL_ACTION);
}
 
inline void CTrackInvalidFace::SetIsolatedFacePointNumber(int ptnbr)
{
    XASSERT(ptnbr >= 0 && ptnbr <= CELL_ACTION); // Should not be more than 3
    this->state = (unsigned char)(((unsigned char)(ptnbr) & CELL_ACTION) | (state & CELL_KINDOF_MASK));
}
#endif // MOOTOOLS_NO_INLINE
 
class DLLFUNCTION CTrackCell : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    int index;  // index (it could changes when decreasing or increasing ratio, swap occurs for channels)
 
public:
    void SetIndexChange(int index);
    int GetIndexChange();
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackCell::SetIndexChange(int index)
{
    this->index = index;
}
 
inline int CTrackCell::GetIndexChange()
{
    return index;
}
#endif // MOOTOOLS_NO_INLINE
 
#ifdef PLY_FLIP_EDGES
class DLLFUNCTION CTrackFace2 : public CTrackCell
{
    friend CTrackContractions;
 
protected:
    int faceIndex; // index of the element which change
 
public:
    void SetCurrentFace(int faceIndex);
    int GetCurrentFace();
};
 
#ifndef MOOTOOLS_NO_INLINE
inline void CTrackFace2::SetCurrentFace(int faceIndex)
{
    this->faceIndex = faceIndex;
}
 
inline int CTrackFace2::GetCurrentFace()
{
    return faceIndex;
}
#endif // MOOTOOLS_NO_INLINE
 
class DLLFUNCTION CTrackUVFace2 : public CTrackFace2
{
    friend CTrackContractions;
 
protected:
    unsigned char channel;
 
public:
    unsigned char GetChannel() const;
    void SetChannel(unsigned char channel);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline unsigned char CTrackUVFace2::GetChannel() const
{
    return channel;
}
 
inline void CTrackUVFace2::SetChannel(unsigned char channel)
{
    this->channel = channel;
}
#endif // MOOTOOLS_NO_INLINE
 
#endif
 
class DLLFUNCTION CTrackChannelFace : public CTrackCell
{
    friend CTrackContractions;
 
protected:
    unsigned char channel;
 
public:
    // In debug mode store the face index.
    // This is just for ensuring we are reading contraction data in the correct order
    // The faceindex is included in CTrackFace and UV contraction info refers to this faceindex
    // The contraction data are stored in the following order:
    // 
    // 1 CTrackEdgeContraction (first edge contraction)
    // 2 CTrackFace (face #2)
    // 3 CTrackChannelFace (face #2)
    // 4 CTrackChannelFace (face #2)
    // 4 CTrackChannelNormal (face #2)
    // 5 CTrackFace (face #10)
    // 6 CTrackChannelFace (face #10)
    // 7 CTrackChannelFace (face #10)
    // 4 CTrackChannelNormal (face #10)
    // 8 CTrackEdgeContraction (2nd edge contraction)
    // 9 CTrackFace (face #5)
    // 10 CTrackChannelFace (face #5)
    // ...
    // When reading contraction for adding or removing face of the multiresolution object we read these information
    // in the following order:
    // Decreasing faces: 1, 2, 3, 4, 5, 6, 7, 8, 9 (this is the real optimization order)
    // Increasing faces: 8, 9, 10, 1, 2, 3, 4, 5, 6, 7 (this is not the optimization order but the it gives the same result)
    // Following that order we always have CTrackFace before CTrackChannel
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
    unsigned int chnCurrentIndex;
    unsigned int chnFaceIndex;
#endif
    
    unsigned char GetChannel() const;
    void SetChannel(unsigned char channel);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline unsigned char CTrackChannelFace::GetChannel() const
{
    return channel;
}
 
inline void CTrackChannelFace::SetChannel(unsigned char channel)
{
    this->channel = channel;
}
#endif // MOOTOOLS_NO_INLINE
 
// The same thing as CTrackChannel except that there is only one normal channel handled
// The channelIndex is always 0
class DLLFUNCTION CTrackNormalFace : public CTrackCell
{
    friend CTrackContractions;
 
public:
#ifdef MOOTOOLS_PRIVATE_DEBUG
    unsigned int chnCurrentIndex;
    unsigned int chnFaceIndex;
#endif
};
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
///////////////////////////////////////////
// Tracking flags changes
 
class DLLFUNCTION CTrackFlags : public CTrackInfo
{
    friend CTrackContractions;
 
protected:
    unsigned int index, flags;
 
public:
    unsigned int GetIndex() const;
    void SetIndex(unsigned int index);
    unsigned int GetFlags() const;
    void SetFlags(unsigned int flags);
};
 
#ifndef MOOTOOLS_NO_INLINE
inline unsigned int CTrackFlags::GetIndex() const
{
    return index;
}
 
inline void CTrackFlags::SetIndex(unsigned int index)
{
    this->index = index;
}
 
inline unsigned int CTrackFlags::GetFlags() const
{
    return flags;
}
 
inline void CTrackFlags::SetFlags(unsigned int flags)
{
    this->flags = flags;
}
#endif // MOOTOOLS_NO_INLINE
 
#endif
 
class C3DFaceList;
class CExtPointList;
class C3DExtObject;
 
// CStack of all edge contraction...
class CTrackContractions : public CInstanciatedObject
{
protected:
    unsigned int revertTrackPos;
    CXArray<CTrackInfo *, CTrackInfo *> revertTrack;
    COffsetArray edgesContractionArray;
    unsigned char *data;
    SIZET dataSize, dataOffset;
    unsigned int edgeContractionNbr;
    unsigned int staticPtNbr, staticFaceNbr;
 
    int currentContraction; // Very important: must be signed
 
    virtual ~CTrackContractions(); // Use Delete instead
 
    void CheckSize(SIZET neededsize);
    CTrackInfo *GetNextTrackInfo(CTrackInfo *trackinfo) const;
 
    int GetNumberOfInvalidFaces();
    void InitStaticElements(int srcFaceNbr, int srcPointNbr);
 
public:
    CTrackContractions(int staticFaceSize = -1, int staticPtSize = -1);
 
    void InitSize(unsigned int edges, unsigned int channelnbr);
    void InitSizeFrom(const CTrackContractions *info);
    void Free();
    void FreeExtra();
    void SetCurrentContraction(int currentContraction); // Cursor point for constructing/deconstructing object
    int GetCurrentContraction() const;
    int GetContractionsNbr() const;
    int GetStaticFaceNbr() const;
    int GetStaticPointNbr() const;
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
    void UpdateIndex(CXUIntArray& newfaceindex, CXUIntArray& newpointindex, CXUIntArray& newnormalfaceindex, CXUIntArray *newuvfaceindex, int uvChannelNbr);
#else
    void UpdateIndex(CXUIntArray& newfaceindex, CXUIntArray& newpointindex);
#endif
 
#ifdef _DEBUG
    void Dump(C3DGeomObject *object, bool changeRatio = true) const;
    int GetRemovedFaceInContraction(CTrackEdgeContraction *edge) const;
#endif
 
    CTrackEdgeContraction *GetNewEdgeContraction();
    CTrackMoveDuplicatedPoint *GetNewMoveDuplicatedPoint();
    CTrackUVContraction *GetNewUVContraction();
    CTrackNormalContraction *GetNewNormalContraction();
    CTrackFace *GetNewTrackFace();
    CTrackInvalidFace *GetNewTrackInvalidFace();
    CTrackChannelFace *GetNewTrackChannelFace(NewCellState channeltype);
    CTrackNormalFace *GetNewTrackNormalFace();
#ifdef PLY_FLIP_EDGES
    CTrackFace2 *GetNewTrackFace2();
    CTrackUVFace2 *GetNewTrackUVFace2();
#endif
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
    CTrackFlags *GetNewTrackFlags(NewCellState trackFlagType);
#endif
 
    CTrackEdgeContraction *GetEdgeContraction(unsigned int contractionNbr) const;
    CTrackInfo *GetFirstCell(CTrackEdgeContraction *contraction) const;
    CTrackInfo *GetNextCell(CTrackInfo *cell) const;
    CTrackInfo *GetLastCell(CTrackEdgeContraction *contraction);
    CTrackInfo *GetPrevCell(CTrackInfo *cell);
    bool AddCell(CTrackInfo *cell);
 
    SIZET GetDataSize() const;
    const void *GetData(SIZET& size) const;
    bool InitFromData(const void *data, SIZET size);
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // __CRUNCHER_TRACKINFO