DependentChannels.h

Go to the documentation of this file.

//! @file DependentChannels.h
//! @brief CDependentChannels class definition which handles a CChannel array
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_DEPENDENTCHANNELS_H__79EB93C3_8866_11D3_A029_8FE73A9B677B__INCLUDED_)
#define AFX_DEPENDENTCHANNELS_H__79EB93C3_8866_11D3_A029_8FE73A9B677B__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Channel.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
typedef CXUIntArray CChannelList;
 
// As there can be several channels in an object with the same ChannelID,
// this struct can be used to identify one and only one channel because
// there are only one ChannelID of a given type...
class DLL_3DFUNCTION CChannelInfo
{
public:
    ChannelID id;
    Channel3DType type;
    unsigned int flags;
 
    CChannelInfo(CChannel *channel = NULL);
    CChannelInfo(ChannelID id, Channel3DType type);
};
 
template <> class CHashMethods<CChannelInfo>
{
public:
    static inline unsigned int HashValue(const CChannelInfo& info)
    {
        return HashMixValue(info.id) + info.type;
    }
 
    static inline bool HashCompare(const CChannelInfo& info1, const CChannelInfo& info2)
    {
        if (info1.id != info2.id)
            return false;
        if (info1.type != info2.type)
            return false;
 
        return true;
    }
};
 
//! @class CDependentChannels
//! @brief This class contains an array of CChannel information which are associated to the object.
//! @details Any geometrical object (OBJECT_GEOM) have a CDependentChannels associated to it, which can be retrieved by C3DGeomObject::GetChannels
class DLL_3DFUNCTION CDependentChannels : protected CXArray<CChannel *, CChannel *>, public CInstanciatedObject
{
 
public:
    CDependentChannels();
    virtual ~CDependentChannels(); // Use Delete instead, unless the CDependentChannels is created on the stack (take care that it is referenced once only in this case)
    static CDependentChannels *Create();  // Allocates and creates an empty set of channel. Use CDependentChannels::Delete to delete it. Same as xNew(CDependentChannels).
 
    using CXArray<CChannel *, CChannel *>::GetSize;
    using CXArray::operator[];
 
    // Channel informations
    int GetSize() const;
    int GetChannelsNumber(unsigned int type, bool onlyValid = true);
    int GetChannels(unsigned int type, CChannelList& list, unsigned int excludedFlags = CHANNEL_IS_INVALID, unsigned int neededFlags = CHANNEL_NONE) const;
    Channel3DType GetChannelType(int i);
    int GetChannelIndex(const CChannel *channel) const; // return -1 if channel not find in the CDependentChannels
 
    CChannel *GetChannelByIndex(int i, unsigned int type = CHANNEL_TYPE_UNDEFINED, bool onlyValid = true);
    CChannel *GetChannelByID(ChannelID id, Channel3DType type = CHANNEL_TYPE_UNDEFINED); // Specify channel type to be sure the returned channel has the given type.
    CChannel *GetChannelByIndex(int i, CFaceList *&channelfaces, CPointList *&channelpoints, Channel3DType type = CHANNEL_TYPE_UNDEFINED);  // channelfaces / channelpoints set to NULL if no channel exists
    CChannel *GetChannelByID(ChannelID id, CFaceList *&channelfaces, CPointList *&channelpoints, Channel3DType type); // channelfaces / channelpoints set to NULL if no channel exists
 
    CUVWChannel *GetUVWChannelByIndex(int i, CUVWFaceList *&uvfaces, CUVWPointList *&uvpoints); // uvfaces / uvpoints set to NULL if no channel exists
    CUVWChannel *GetUVWChannelByID(ChannelID id, CUVWFaceList *&uvfaces, CUVWPointList *&uvpoints); // uvfaces / uvpoints set to NULL if no channel exists
 
    CVCChannel *GetVCChannelByIndex(int i, CVCFaceList *&vcfaces, CVCPointList *&vcpoints);
    CVCChannel *GetVCChannelByID(ChannelID id, CVCFaceList *&vcfaces, CVCPointList *&vcpoints);
 
    int GetChannelIndex(ChannelID id, Channel3DType type, bool onlyValid = true);
    ChannelID ModifyChannelIDByID(ChannelID newid, ChannelID currentID, Channel3DType type);
    ChannelID ModifyChannelIDByIndex(ChannelID newid, int index, Channel3DType type = CHANNEL_TYPE_UNDEFINED, bool onlyValid = true); // Reassign a new channel ID to #index or #index of #type. Return the assign channelID which can be different if provided newid exists.
 
    CSpecNormalChannel *GetSpecNormalChannel();
    CSpecNormalChannel *GetSpecNormalChannel(CNormalFaceList *&channelfaces, C3DVectorList *&channelnormals);
    
    CPointNormalChannel *GetPointNormalChannel(bool createChannelIfNeeded = true);
    CPointNormalChannel* GetPointNormalChannel(CNormalFaceList*& channelfaces, C3DVectorList*& channelnormals, bool createChannelIfNeeded = true);
    CFaceNormalChannel* GetFaceNormalChannel(bool createChannelIfNeeded = true);
    CFaceNormalChannel *GetFaceNormalChannel(C3DVectorList*& channelnormals, bool createChannelIfNeeded = true);
 
    // Channel update
    bool InvalidateChannels(unsigned int type = ALL_CHANNELS_TYPE); // Invalidate cache for channels that have cache data (ie autogenrated or CSpecNormalChannels), if type specified, only invalidate for the given type
    int CleanChannels(const CGeomInfo *info, CXUIntArray *newfaceindex, CXUIntArray *newpointindex);
    bool SwapCoordinates(unsigned int swapMode, unsigned int channelType = ALL_CHANNELS_TYPE);
    bool MatrixTransform(const C4x4Matrix& matrix, unsigned int channelType = ALL_CHANNELS_TYPE, POINT_PROPERTIES property = POINT_NONE, bool set = true);
    bool Weld(const CGeomInfo *info, double tolerance, unsigned int channelType = ALL_CHANNELS_TYPE);
    bool InitBreakFlags(const CGeomInfo *info, unsigned int channelType = ALL_CHANNELS_TYPE, float uvTolerance = 0.0f, int vcTolerance = 0, float normalThreshold = DEG2RADF(DEFAULT_NORMAL_THRESHOLD_VALUE));
    void FreeExtra();
 
    // Create, Add, remove channels
    ChannelID AddChannel(CChannel *channel, ChannelID id = CHANNELID_UNDEFINED); // Add the channel and check the provided id. If duplicated or CHANNELID_UNDEFINED, then a new id is assigned to the channel and returned.
    CChannel* AddChannel(Channel3DType channelType, ChannelID id = CHANNELID_UNDEFINED); // Create a channel of the given type and add it to the channels. If id is let to CHANNELID_UNDEFINED, then an id is automatically assigned
    int CopyChannels(const CDependentChannels& srcChannels, unsigned int channelType, unsigned int channelCopyFlags, CXUIntArray *channelIndexMatches = NULL);
    bool RemoveChannelsByFlag(CHANNEL_PROPERTIES channelFlags, Channel3DType type = CHANNEL_TYPE_UNDEFINED, bool flagIsSet = true, bool deleteChannel = true);
    bool RemoveChannelByIndex(int i, Channel3DType type = CHANNEL_TYPE_UNDEFINED, bool deleteChannel = true);
    bool RemoveChannelsByType(unsigned int channelType, bool deleteChannel = true);
    bool RemoveChannelByID(ChannelID id, Channel3DType type, bool deleteChannel = true);
    bool RemoveChannel(CChannel *channel, bool deleteChannel = true);
    void RemoveAll();
 
    void SetFlag(unsigned int type, CHANNEL_PROPERTIES flag, bool set);
 
    static ChannelID GetFirstChannelIDByType(Channel3DType channelType); // Return the first default channel ID value, depending on channelType
 
    // operators
    CDependentChannels& operator=(CDependentChannels& channel);
 
    virtual void Serialize(CXArchive& ar);
 
#ifdef _DEBUG
    virtual void Dump(unsigned int flags) const;
    unsigned int MemoryStats() const;
#endif
    
    protected:
        CHashTable<CChannelInfo> ids;
 
        void RemoveAt(int index, bool deleteChannel);
        ChannelID GetNextChannelID(ChannelID baseid, Channel3DType channelType); // Return the next channel id available looking the existing channel, in order to avoid channel conflict.
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_DEPENDENTCHANNELS_H__79EB93C3_8866_11D3_A029_8FE73A9B677B__INCLUDED_)