MaterialRequiredStreams.h

Go to the documentation of this file.

//
// Copyright 2010 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which 
// otherwise accompanies this software in either electronic or hard copy form.   
//
//

#pragma once

#include "./DataBridgeExport.h"
#include "./Types.h"
#include "./GeometryEnums.h"

#include "../MaxHeap.h"
#include "../tab.h"

namespace MaxSDK { namespace Graphics {

struct MaterialRequiredStreamElement : public MaxHeapOperators
{
public:
    DataBridgeAPI MaterialRequiredStreamElement();
    DataBridgeAPI MaterialRequiredStreamElement(const MaterialRequiredStreamElement& from);
    DataBridgeAPI MaterialRequiredStreamElement& operator = (const MaterialRequiredStreamElement& from);
    DataBridgeAPI ~MaterialRequiredStreamElement();

    DataBridgeAPI int Compare(const MaterialRequiredStreamElement& rhs) const;

    inline int GetChannelID() const;

    inline VertexFieldType GetType() const;

    inline MeshChannelCategory GetChannelCategory() const;

    inline unsigned short GetUsageIndex() const;

    inline void SetChannelID(int maxMapChannel);

    inline void SetType(VertexFieldType type);

    inline void SetChannelCategory(MeshChannelCategory channelCategory);

    inline void SetUsageIndex(unsigned short usageIndex);

    inline bool operator == (const MaterialRequiredStreamElement& rhs) const;
    inline bool operator != (const MaterialRequiredStreamElement& rhs) const;
    inline bool operator < (const MaterialRequiredStreamElement& rhs) const;
    inline bool operator <= (const MaterialRequiredStreamElement& rhs) const;
    inline bool operator > (const MaterialRequiredStreamElement& rhs) const;
    inline bool operator >= (const MaterialRequiredStreamElement& rhs) const;

protected:
#pragma warning(disable:4201)
    union DataUnion
    {
        unsigned __int64 mKey;
        struct
        {
            unsigned long mChannelId;
            unsigned short mUsageIndex;
            unsigned char mFieldType; // VertexFieldType
            unsigned char mChannelCategory; // MeshChannelCategory
        };
    };
#pragma warning(default:4201)

    DataUnion mData;
};

enum MaterialRequirementFlags
{
    MaterialRequirementSplitByMaterialID        = 0x00000001, 
};

class MaterialRequiredStreamsImpl;

class MaterialRequiredStreams : public MaxHeapOperators
{
public:
    DataBridgeAPI MaterialRequiredStreams();
    DataBridgeAPI MaterialRequiredStreams(const MaterialRequiredStreams& from);
    DataBridgeAPI MaterialRequiredStreams& operator = (const MaterialRequiredStreams& from);
    DataBridgeAPI ~MaterialRequiredStreams();

    DataBridgeAPI void Clear();

    DataBridgeAPI size_t AddStream(
        const MaterialRequiredStreamElement& streamElement);

    DataBridgeAPI size_t FindStream(
        const MaterialRequiredStreamElement& streamElement) const;

    DataBridgeAPI void RemoveStream(size_t index);

    DataBridgeAPI size_t GetNumberOfStreams() const;

    DataBridgeAPI const MaterialRequiredStreamElement& GetStreamElement(size_t i) const;

    DataBridgeAPI int Compare(const MaterialRequiredStreams& rhs) const;

    DataBridgeAPI unsigned long GetFlags() const;

    DataBridgeAPI void SetFlags(unsigned long flags);

    inline bool operator == (const MaterialRequiredStreams& rhs) const;
    inline bool operator != (const MaterialRequiredStreams& rhs) const;
    inline bool operator < (const MaterialRequiredStreams& rhs) const;
    inline bool operator <= (const MaterialRequiredStreams& rhs) const;
    inline bool operator > (const MaterialRequiredStreams& rhs) const;
    inline bool operator >= (const MaterialRequiredStreams& rhs) const;

private:
    MaterialRequiredStreamsImpl* mpImpl;
};

inline int MaterialRequiredStreamElement::GetChannelID() const
{
    return (int)((unsigned int)(mData.mChannelId));
}

inline VertexFieldType MaterialRequiredStreamElement::GetType() const
{
    return (VertexFieldType)(mData.mFieldType);
}

inline MeshChannelCategory MaterialRequiredStreamElement::GetChannelCategory() const
{
    return (MeshChannelCategory)(mData.mChannelCategory);
}

inline unsigned short MaterialRequiredStreamElement::GetUsageIndex() const
{
    return mData.mUsageIndex;
}

inline void MaterialRequiredStreamElement::SetChannelID(int maxMapChannel)
{
    mData.mChannelId = (unsigned long)((unsigned int)maxMapChannel);
}

inline void MaterialRequiredStreamElement::SetType(VertexFieldType type)
{
    mData.mFieldType = (unsigned char)type;
}

inline void MaterialRequiredStreamElement::SetChannelCategory(MeshChannelCategory channelCategory)
{
    mData.mChannelCategory = (unsigned char)channelCategory;
}

inline void MaterialRequiredStreamElement::SetUsageIndex(unsigned short usageIndex)
{
    mData.mUsageIndex = usageIndex;
}

inline bool MaterialRequiredStreamElement::operator == (
    const MaterialRequiredStreamElement& rhs) const
{
    return Compare(rhs) == 0;
}

inline bool MaterialRequiredStreamElement::operator != (
    const MaterialRequiredStreamElement& rhs) const
{
    return Compare(rhs) != 0;
}

inline bool MaterialRequiredStreamElement::operator < (
    const MaterialRequiredStreamElement& rhs) const
{
    return Compare(rhs) < 0;
}

inline bool MaterialRequiredStreamElement::operator <= (
    const MaterialRequiredStreamElement& rhs) const
{
    return Compare(rhs) <= 0;
}

inline bool MaterialRequiredStreamElement::operator > (
    const MaterialRequiredStreamElement& rhs) const
{
    return Compare(rhs) > 0;
}

inline bool MaterialRequiredStreamElement::operator >= (
    const MaterialRequiredStreamElement& rhs) const
{
    return Compare(rhs) >= 0;
}

inline bool MaterialRequiredStreams::operator == (const MaterialRequiredStreams& rhs) const
{
    return Compare(rhs) == 0;
}

inline bool MaterialRequiredStreams::operator != (const MaterialRequiredStreams& rhs) const
{
    return Compare(rhs) != 0;
}

inline bool MaterialRequiredStreams::operator < (const MaterialRequiredStreams& rhs) const
{
    return Compare(rhs) < 0;
}

inline bool MaterialRequiredStreams::operator <= (const MaterialRequiredStreams& rhs) const
{
    return Compare(rhs) <= 0;
}

inline bool MaterialRequiredStreams::operator > (const MaterialRequiredStreams& rhs) const
{
    return Compare(rhs) > 0;
}

inline bool MaterialRequiredStreams::operator >= (const MaterialRequiredStreams& rhs) const
{
    return Compare(rhs) >= 0;
}

} } // namespace