kfbxlayer.h

Go to the documentation of this file.

/****************************************************************************************

   Copyright (C) 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.

****************************************************************************************/

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXLAYER_H
#define FBXFILESDK_KFBXPLUGINS_KFBXLAYER_H


#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/components/kbaselib/klib/kstring.h>
#include <fbxfilesdk/components/kbaselib/klib/karrayul.h>
#include <fbxfilesdk/components/kbaselib/klib/kdebug.h>

#include <fbxfilesdk/kfbxmath/kfbxvector2.h>
#include <fbxfilesdk/kfbxmath/kfbxvector4.h>
#include <fbxfilesdk/kfbxplugins/kfbxcolor.h>
#include <fbxfilesdk/kfbxplugins/kfbxdatatypes.h>
#include <fbxfilesdk/kfbxplugins/kfbxstream.h>
#include <fbxfilesdk/kfbxplugins/kfbxsurfacematerial.h>
#include <fbxfilesdk/kfbxplugins/kfbxtexture.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFbxTexture;
class KFbxSurfaceMaterial;
class KFbxSdkManager;

class KFbxGeometryBase;
class KFbxLayer;
class KFbxLayerContainer;
class KFbxMesh;
class KFbxNode;


class KFBX_DLL KFbxLayerElement
{

public:

    typedef enum 
    {
        eUNDEFINED,

        //NON-TEXTURE LAYER ELEMENT BEGIN
        eNORMAL,
        eBINORMAL,
        eTANGENT,
        eMATERIAL,
        ePOLYGON_GROUP,
        eUV,
        eVERTEX_COLOR,
        eSMOOTHING,
        eVERTEX_CREASE,
        eEDGE_CREASE,
        eHOLE,
        eUSER_DATA,
        eVISIBILITY,
        //NEW NON-TEXTURE LAYER ELEMENT ADD HERE...

        //NON-TEXTURE LAYER ELEMENT END

        //TEXTURE LAYER ELEMENT BEGIN
        eDIFFUSE_TEXTURES,
        eDIFFUSE_FACTOR_TEXTURES,
        eEMISSIVE_TEXTURES,
        eEMISSIVE_FACTOR_TEXTURES,
        eAMBIENT_TEXTURES,
        eAMBIENT_FACTOR_TEXTURES,
        eSPECULAR_TEXTURES,
        eSPECULAR_FACTOR_TEXTURES,
        eSHININESS_TEXTURES,
        eNORMALMAP_TEXTURES,
        eBUMP_TEXTURES,
        eTRANSPARENT_TEXTURES,
        eTRANSPARENCY_FACTOR_TEXTURES,
        eREFLECTION_TEXTURES,
        eREFLECTION_FACTOR_TEXTURES,
        eDISPLACEMENT_TEXTURES,
        //NEW TEXTURE LAYER ELEMENT ADD HERE...
        eVECTOR_DISPLACEMENT_TEXTURES,

        //TEXTURE LAYER ELEMENT END

        eLAST_ELEMENT_TYPE
    } ELayerElementType;

    //common used constant for looping through and access layer element

    const static int LAYERELEMENT_TYPE_TEXTURE_START_INDEX = int(eDIFFUSE_TEXTURES);

    const static int LAYERELEMENT_TYPE_TEXTURE_END_INDEX = int(eLAST_ELEMENT_TYPE) - 1;

    const static int LAYERELEMENT_TYPE_TEXTURE_COUNT = LAYERELEMENT_TYPE_TEXTURE_END_INDEX - LAYERELEMENT_TYPE_TEXTURE_START_INDEX + 1;

    const static int LAYERELEMENT_TYPE_NON_TEXTURE_START_INDEX = int(eNORMAL);

    const static int LAYERELEMENT_TYPE_NON_TEXTURE_END_INDEX = int(eVISIBILITY);

    const static int LAYERELEMENT_TYPE_NON_TEXTURE_COUNT = LAYERELEMENT_TYPE_NON_TEXTURE_END_INDEX - LAYERELEMENT_TYPE_NON_TEXTURE_START_INDEX + 1;

    //names for different textures and non-textures channels

    static const char* const TEXTURE_NAMES[];

    static const char* const TEXTURE_UV_NAMES[];

    static const char* const NON_TEXTURE_NAMES[];

    static const KFbxDataType TEXTURE_TYPES[];

    static const char* const TEXTURE_CHANNEL_NAMES[];

    typedef enum 
    {
        eNONE,
        eBY_CONTROL_POINT,
        eBY_POLYGON_VERTEX,
        eBY_POLYGON,
        eBY_EDGE,
        eALL_SAME
    } EMappingMode;

    typedef enum 
    {
        eDIRECT,
        eINDEX,
        eINDEX_TO_DIRECT
    } EReferenceMode;

    
    void SetMappingMode(EMappingMode pMappingMode) { mMappingMode = pMappingMode; }

    void SetReferenceMode(EReferenceMode pReferenceMode) { mReferenceMode = pReferenceMode; }

    EMappingMode GetMappingMode() const { return mMappingMode; }

    EReferenceMode GetReferenceMode() const { return mReferenceMode; }

    void SetName(const char* pName) { mName = KString(pName); }

    const char* GetName() const { return ((KFbxLayerElement*)this)->mName.Buffer(); }

    bool operator==(const KFbxLayerElement& pOther) const
    {
        return (mName == pOther.mName) && 
               (mMappingMode == pOther.mMappingMode) &&
               (mReferenceMode == pOther.mReferenceMode);
    }

    KFbxLayerElement& operator=( KFbxLayerElement const& pOther )
    {
        mMappingMode = pOther.mMappingMode;
        mReferenceMode = pOther.mReferenceMode;
        // name, type and owner should not be copied because they are
        // initialized when this object is created
        return *this;
    }

    void Destroy();

    virtual bool Clear() 
    { 
        return true;
    }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void SetType(const KFbxDataType* pType) { mType = pType; }
    const KFbxLayerContainer* GetOwner() const { return mOwner; }

protected:
    KFbxLayerElement() 
        : mMappingMode(eNONE)
        , mReferenceMode(eDIRECT)
        , mName("")
        , mOwner(NULL)
    {
    }
    
    virtual ~KFbxLayerElement()
    {
    }

    EMappingMode mMappingMode;
    EReferenceMode mReferenceMode;

    KString mName;
    const KFbxDataType* mType;
    KFbxLayerContainer* mOwner;

    void Destruct() { FbxSdkDelete(this); }
    virtual void SetOwner(KFbxLayerContainer* pOwner);

    KFBXNEW_DECLARE_FRIEND
    friend class KFbxLayerContainer;

public:
    virtual int MemorySize() const { return 0; }


    virtual bool ContentWriteTo(KFbxStream& pStream) const;

    virtual bool ContentReadFrom(const KFbxStream& pStream);

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

class KFBX_DLL LockAccessStatus
{
public:
    typedef enum {
        eSuccess,
        eUnsupportedDTConversion,
        eCorruptedCopyback,
        eBadValue,
        eLockMismatch,
        eNoWriteLock,
        eNoReadLock,
        eNotOwner,
        eDirectLockExist
    } ELockAccessStatus;
};

class KFBX_DLL KFbxLayerElementArray
{
public:

    KFbxLayerElementArray(EFbxType pDataType);

    virtual ~KFbxLayerElementArray();



    inline                                void ClearStatus()     { mStatus = LockAccessStatus::eSuccess; }

    inline LockAccessStatus::ELockAccessStatus GetStatus() const { return mStatus; }


    inline bool IsWriteLocked() const { return mWriteLock; };

    inline int  GetReadLockCount() const { return mReadLockCount; }

    bool    IsInUse() const;

    int     ReadLock() const;

    int     ReadUnlock() const;

    bool    WriteLock() const;

    void    WriteUnlock() const;

    bool    ReadWriteLock() const;

    void    ReadWriteUnlock() const;


    typedef enum {
        eREAD_LOCK = 1,
        eWRITE_LOCK = 2,
        eREADWRITE_LOCK = 3
    } ELockMode;

    virtual void*   GetLocked(ELockMode pLockMode, EFbxType pDataType);

    void*   GetLocked(ELockMode pLockMode=eREADWRITE_LOCK) { return GetLocked(pLockMode, mDataType); }

    template <class T> inline T* GetLocked(T* dummy=NULL, ELockMode pLockMode=eREADWRITE_LOCK) {T v; return (T*)GetLocked(pLockMode, _FbxTypeOf(v)); }

    virtual void   Release(void** pDataPtr, EFbxType pDataType);

    void   Release(void** pDataPtr) { Release(pDataPtr, mDataType); }

    template <class T> inline void Release(T** pDataPtr, T* dummy) { Release((void**)pDataPtr, _FbxTypeOf(*dummy)); }

    virtual size_t GetStride() const;


    int     GetCount() const;

    void    SetCount(int pCount);

    void    Clear();

    void    Resize(int pItemCount);

    void    AddMultiple(int pItemCount);

    int     Add(void const* pItem, EFbxType pValueType);

    int     InsertAt(int pIndex, void const* pItem, EFbxType pValueType);

    void    SetAt(int pIndex, void const* pItem, EFbxType pValueType);

    void    SetLast(void const* pItem, EFbxType pValueType);

    void    RemoveAt(int pIndex, void** pItem, EFbxType pValueType);

    void    RemoveLast(void** pItem, EFbxType pValueType);

    bool    RemoveIt(void** pItem, EFbxType pValueType);

    bool    GetAt(int pIndex, void** pItem, EFbxType pValueType) const;

    bool    GetFirst(void** pItem, EFbxType pValueType) const;

    bool    GetLast(void** pItem, EFbxType pValueType) const;

    int     Find(void const* pItem, EFbxType pValueType) const;

    int     FindAfter(int pAfterIndex, void const* pItem, EFbxType pValueType) const;

    int     FindBefore(int pBeforeIndex, void const* pItem, EFbxType pValueType) const;

    bool    IsEqual(const KFbxLayerElementArray& pArray) const;

    template <class T> inline int  Add(T const& pItem)                               { return Add((void const*)&pItem, _FbxTypeOf(pItem)); }

    template <class T> inline int  InsertAt(int pIndex, T const& pItem)              { return InsertAt(pIndex, (void const*)&pItem, _FbxTypeOf(pItem)); }

    template <class T> inline void SetAt(int pIndex, T const& pItem)                 { SetAt(pIndex, (void const*)&pItem, _FbxTypeOf(pItem)); }

    template <class T> inline void SetLast(T const& pItem)                           { SetLast((void const*)&pItem, _FbxTypeOf(pItem)); }

    template <class T> inline void RemoveAt(int pIndex, T* pItem)                    { RemoveAt(pIndex, (void**)&pItem, _FbxTypeOf(*pItem)); }

    template <class T> inline void RemoveLast(T* pItem)                              { RemoveLast((void**)&pItem, _FbxTypeOf(*pItem)); }

    template <class T> inline bool RemoveIt(T* pItem)                                { return RemoveIt((void**)&pItem, _FbxTypeOf(*pItem)); }

    template <class T> inline bool GetAt(int pIndex, T* pItem) const                 { return GetAt(pIndex, (void**)&pItem, _FbxTypeOf(*pItem)); }

    template <class T> inline bool GetFirst(T* pItem) const                          { return GetFirst((void**)&pItem, _FbxTypeOf(*pItem)); }

    template <class T> inline bool GetLast(T* pItem) const                           { return GetLast((void**)&pItem, _FbxTypeOf(*pItem)); }

    template <class T> inline int Find(T const& pItem) const                         { return Find((void const*)&pItem, _FbxTypeOf(pItem)); }

    template <class T> inline int FindAfter(int pAfterIndex, T const& pItem) const   { return FindAfter(pAfterIndex, (void const*)&pItem, _FbxTypeOf(pItem)); }

    template <class T> inline int FindBefore(int pBeforeIndex, T const& pItem) const { return FindBefore(pBeforeIndex, (void const*)&pItem, _FbxTypeOf(pItem)); }


    template<typename T> inline void CopyTo(KArrayTemplate<T>& pDst)
    {
        T src;
        T* srcPtr = &src;

        pDst.Clear();
        if (mDataType != _FbxTypeOf(src))
        {
            SetStatus(LockAccessStatus::eUnsupportedDTConversion);
            return;
        }

        pDst.SetCount(GetCount());
        for (int i = 0; i < GetCount(); i++)
        {
            if (GetAt(i, (void**)&srcPtr, mDataType))
            {
                pDst.SetAt(i, src);
            }
        }
        SetStatus(LockAccessStatus::eSuccess);
    }

protected:
    void*   GetDataPtr();
    void*   GetReference(int pIndex, EFbxType pValueType);
    void    GetReferenceTo(int pIndex, void** pRef, EFbxType pValueType);

    inline void SetStatus(LockAccessStatus::ELockAccessStatus pVal) const
    {
        const_cast<KFbxLayerElementArray*>(this)->mStatus = pVal;
    }

            void   SetImplementation(void* pImplementation);
    inline  void*  GetImplementation() { return mImplementation; }
    virtual void   ConvertDataType(EFbxType pDataType, void** pDataPtr, size_t* pStride);

    EFbxType mDataType;

private:
    LockAccessStatus::ELockAccessStatus mStatus;

    int           mReadLockCount;
    bool          mWriteLock;
    void*         mImplementation;
    size_t        mStride;
    int           mDirectLockOn;
    bool          mDirectAccessOn;

    KArrayTemplate<void*>   mConvertedData;

};

template <typename T>
struct KFbxLayerElementArrayReadLock
{
    KFbxLayerElementArrayReadLock(KFbxLayerElementArray& pArray) : mArray(pArray)
    {
        mLockedData = mArray.GetLocked((T*)NULL, KFbxLayerElementArray::eREAD_LOCK);
    }

    ~KFbxLayerElementArrayReadLock()
    {
        if( mLockedData )
        {
            mArray.Release((void **) &mLockedData);
        }
    }

    const T* GetData() const
    {
        return mLockedData;
    }

private:
    KFbxLayerElementArray&  mArray;
    T* mLockedData;
};

class KFbxLayerElementUserData;

template <class T> class KFbxLayerElementArrayTemplate : public KFbxLayerElementArray
{
public:

    KFbxLayerElementArrayTemplate(EFbxType pDataType) :
        KFbxLayerElementArray(pDataType)
        {
        }

    inline int  Add( T const &pItem )                       { return KFbxLayerElementArray::Add(pItem); }

    inline int  InsertAt(int pIndex, T const &pItem)        { return KFbxLayerElementArray::InsertAt(pIndex, pItem); }

    inline void SetAt(int pIndex, T const &pItem)           { KFbxLayerElementArray::SetAt(pIndex, pItem); }

    inline void SetLast( T const &pItem)                    { KFbxLayerElementArray::SetLast(pItem); }

    inline T RemoveAt(int pIndex)                           { T lValue; KFbxLayerElementArray::RemoveAt(pIndex, &lValue); return lValue; }

    inline T RemoveLast()                                   { T lValue; KFbxLayerElementArray::RemoveLast(&lValue); return lValue; }

    inline bool RemoveIt(T const &pItem)                    { return KFbxLayerElementArray::RemoveIt(&pItem); }

    inline T  GetAt(int pIndex) const                       { T lValue; KFbxLayerElementArray::GetAt(pIndex, &lValue); return lValue; }

    inline T  GetFirst() const                              { T lValue; KFbxLayerElementArray::GetFirst(&lValue); return lValue; }

    inline T  GetLast() const                               { T lValue; KFbxLayerElementArray::GetLast(&lValue); return lValue; }

    inline int Find(T const &pItem)                         { return KFbxLayerElementArray::Find(pItem); }

    inline int FindAfter(int pAfterIndex, T const &pItem)   { return KFbxLayerElementArray::FindAfter(pAfterIndex, pItem); }

    inline int FindBefore(int pBeforeIndex, T const &pItem) { return KFbxLayerElementArray::FindBefore(pBeforeIndex, pItem); }

    T  operator[](int pIndex) const                         { T lValue; KFbxLayerElementArray::GetAt(pIndex, &lValue); return lValue; } 

    KFbxLayerElementArray& operator=(const KArrayTemplate<T>& pArrayTemplate)
    {
        SetStatus(LockAccessStatus::eNoWriteLock);
        if (WriteLock())
        {
            SetCount(pArrayTemplate.GetCount());
            for (int i = 0; i < pArrayTemplate.GetCount(); i++)
                SetAt(i, pArrayTemplate.GetAt(i));
            WriteUnlock();
            SetStatus(LockAccessStatus::eSuccess);
        }
        return *this;
    }

    KFbxLayerElementArrayTemplate<T>& operator=(const KFbxLayerElementArrayTemplate<T>& pArrayTemplate)
    {
        if ( this != &pArrayTemplate )
        {
            SetStatus(LockAccessStatus::eNoWriteLock);
            if (WriteLock())
            {
                SetCount(pArrayTemplate.GetCount());
                for (int i = 0; i < pArrayTemplate.GetCount(); i++)
                    SetAt(i, pArrayTemplate.GetAt(i));
                WriteUnlock();
                SetStatus(LockAccessStatus::eSuccess);
            }
        }
        return *this;
    }

private:
    // This one is not the best thing to do, but at least I don't get deprecated calls inside this file.
    // Note that KFbxLayerElementUserData is kind of a weird class in the first place anyway. So either
    // we clean it up, or we live with this piece of code ;-)
    friend class KFbxLayerElementUserData;
    T& AsReference(int pIndex)      { T* v = (T*)KFbxLayerElementArray::GetReference(pIndex, mDataType); return (v)?*v:dummy;}

    T dummy;
};


extern int RemapIndexArrayTo(KFbxLayerElement* pLayerEl, 
                             KFbxLayerElement::EMappingMode pNewMapping, 
                             KFbxLayerElementArrayTemplate<int>* pIndexArray);


template <class Type> class KFbxLayerElementTemplate : public KFbxLayerElement
{
public:

    KFbxLayerElementArrayTemplate<Type>& GetDirectArray() const
    { 
        K_ASSERT(mReferenceMode == KFbxLayerElement::eDIRECT || mReferenceMode == KFbxLayerElement::eINDEX_TO_DIRECT);
        return *mDirectArray; 
    }

    KFbxLayerElementArrayTemplate<Type>& GetDirectArray()
    { 
        K_ASSERT(mReferenceMode == KFbxLayerElement::eDIRECT || mReferenceMode == KFbxLayerElement::eINDEX_TO_DIRECT);
        return *mDirectArray; 
    }

    KFbxLayerElementArrayTemplate<int>& GetIndexArray() const
    { 
        K_ASSERT(mReferenceMode == KFbxLayerElement::eINDEX || mReferenceMode == KFbxLayerElement::eINDEX_TO_DIRECT);
        return *mIndexArray; 
    }

    KFbxLayerElementArrayTemplate<int>& GetIndexArray()
    { 
        K_ASSERT(mReferenceMode == KFbxLayerElement::eINDEX || mReferenceMode == KFbxLayerElement::eINDEX_TO_DIRECT);
        return *mIndexArray; 
    }

    bool Clear()
    {
        bool ret = true;
        mDirectArray->Clear();
        ret = (mDirectArray->GetStatus() == LockAccessStatus::eSuccess);

        mIndexArray->Clear();
        ret |= (mIndexArray->GetStatus() == LockAccessStatus::eSuccess);

        return ret;
    }

public:

    bool operator==(const KFbxLayerElementTemplate& pOther) const
    {
        bool ret = true;

        if (pOther.GetReferenceMode() == KFbxLayerElement::eDIRECT || 
            pOther.GetReferenceMode() == KFbxLayerElement::eINDEX_TO_DIRECT)
        {
            const KFbxLayerElementArrayTemplate<Type>& directArray = pOther.GetDirectArray();
            if( directArray.GetCount() != mDirectArray->GetCount() || 
                !directArray.ReadLock() || !mDirectArray->ReadLock() )
            {
                ret = false;
            }

            if( ret && !mDirectArray->IsEqual(directArray) )
                ret = false;

            directArray.ReadUnlock();
            mDirectArray->ReadUnlock();
        }

        if (ret)
        {
            if (pOther.GetReferenceMode() == KFbxLayerElement::eINDEX || 
                pOther.GetReferenceMode()  == KFbxLayerElement::eINDEX_TO_DIRECT)
            {
                const KFbxLayerElementArrayTemplate<int>& indexArray = pOther.GetIndexArray();
                if( indexArray.GetCount() != mIndexArray->GetCount() ||
                    !indexArray.ReadLock() || !mIndexArray->ReadLock() )
                {
                    ret = false;
                }

                if( ret && !mIndexArray->IsEqual(indexArray) )
                    ret = false;

                indexArray.ReadUnlock();
                mIndexArray->ReadUnlock();
            }
        }

        if (ret == false)
            return false;

        return KFbxLayerElement::operator==(pOther);
    }

    KFbxLayerElementTemplate& operator=( KFbxLayerElementTemplate const& pOther )
    {
        K_ASSERT(mDirectArray != NULL);
        K_ASSERT(mIndexArray != NULL);

        if (pOther.GetReferenceMode() == KFbxLayerElement::eDIRECT || 
            pOther.GetReferenceMode() == KFbxLayerElement::eINDEX_TO_DIRECT)
        {
            const KFbxLayerElementArrayTemplate<Type>& directArray = pOther.GetDirectArray();
            *mDirectArray = directArray;
        }

        if (pOther.GetReferenceMode() == KFbxLayerElement::eINDEX || 
            pOther.GetReferenceMode()  == KFbxLayerElement::eINDEX_TO_DIRECT)
        {
            const KFbxLayerElementArrayTemplate<int>& indexArray = pOther.GetIndexArray();
            *mIndexArray = indexArray;
        }
        
        KFbxLayerElement* myself = (KFbxLayerElement*)this;
        KFbxLayerElement* myOther = (KFbxLayerElement*)&pOther;
        *myself = *myOther;
        return *this; 
    }

    int RemapIndexTo(KFbxLayerElement::EMappingMode pNewMapping)
    {
        return RemapIndexArrayTo(this, pNewMapping, mIndexArray);
    }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxLayerElementTemplate() 
    {
        mDirectArray = NULL;
        mIndexArray = NULL;
    }

    ~KFbxLayerElementTemplate() 
    {
        FbxSdkDelete(mDirectArray);
        FbxSdkDelete(mIndexArray);
    }

    virtual void AllocateArrays()
    {
        mDirectArray = FbxSdkNew< KFbxLayerElementArrayTemplate<Type> >(mType->GetType());
        mIndexArray = FbxSdkNew< KFbxLayerElementArrayTemplate<int> >(DTInteger.GetType());
    }

public:
    virtual int MemorySize() const
    {
        int size = KFbxLayerElement::MemorySize();
        size += (mDirectArray->GetCount()*sizeof(Type));
        size += (mIndexArray->GetCount()*sizeof(int));
        return size;
    }

    virtual bool ContentWriteTo(KFbxStream& pStream) const
    {
        void* a;
        int s,v;
        int count = 0;

        // direct array
        count = mDirectArray->GetCount();
        s = pStream.Write(&count, sizeof(int)); 
        if (s != sizeof(int)) return false;
        if (count > 0)
        {
            a = mDirectArray->GetLocked();
            K_ASSERT(a != NULL);
            v = count*sizeof(Type);
            s = pStream.Write(a, v); 
            mDirectArray->Release(&a);
            if (s != v) return false;
        }

        // index array
        count = mIndexArray->GetCount();
        s = pStream.Write(&count, sizeof(int)); 
        if (s != sizeof(int)) return false;
        if (count > 0)
        {
            a = mIndexArray->GetLocked();
            K_ASSERT(a != NULL);
            v = count*sizeof(int);
            s = pStream.Write(a, v);
            mIndexArray->Release(&a);
            if (s != v) return false;
        }

        return KFbxLayerElement::ContentWriteTo(pStream);
    }

    virtual bool ContentReadFrom(const KFbxStream& pStream)
    {
        void* a;
        int s,v;
        int count = 0;

        // direct array
        s = pStream.Read(&count, sizeof(int)); 
        if (s != sizeof(int)) return false;
        mDirectArray->Resize(count);
        if (count > 0)
        {
            a = mDirectArray->GetLocked();
            K_ASSERT(a != NULL);
            v = count*sizeof(Type);
            s = pStream.Read(a, v); 
            mDirectArray->Release(&a);
            if (s != v) return false;
        }

        // index array
        s = pStream.Read(&count, sizeof(int)); 
        if (s != sizeof(int)) return false;
        mIndexArray->Resize(count);     
        if (count > 0)
        {
            a = mIndexArray->GetLocked();
            K_ASSERT(a != NULL);
            v = count*sizeof(int);
            s = pStream.Read(a, v);
            mIndexArray->Release(&a);
            if (s != v) return false;
        }
        return KFbxLayerElement::ContentReadFrom(pStream);
    }

    typedef Type ArrayElementType;
    typedef KFbxLayerElementArrayTemplate<Type> DirectArrayType;
    typedef KFbxLayerElementArrayTemplate<int> IndexArrayType;

    KFbxLayerElementArrayTemplate<Type>* mDirectArray;
    KFbxLayerElementArrayTemplate<int>*  mIndexArray;
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#define CREATE_DECLARE(classDesc) \
    KFBXNEW_DECLARE_FRIEND        \
    static KFbx##classDesc* Create(KFbxLayerContainer* pOwner, char const *pName);

class KFBX_DLL KFbxLayerElementNormal : public KFbxLayerElementTemplate<KFbxVector4>
{
public:

    CREATE_DECLARE(LayerElementNormal);
    
protected:
    KFbxLayerElementNormal();
    ~KFbxLayerElementNormal();
};

class KFBX_DLL KFbxLayerElementBinormal : public KFbxLayerElementTemplate<KFbxVector4>
{
public:

    CREATE_DECLARE(LayerElementBinormal);
    
protected:
    KFbxLayerElementBinormal();
    ~KFbxLayerElementBinormal();
};

class KFBX_DLL KFbxLayerElementTangent : public KFbxLayerElementTemplate<KFbxVector4>
{
public:

    CREATE_DECLARE(LayerElementTangent);
    
protected:
    KFbxLayerElementTangent();
    ~KFbxLayerElementTangent();
};

class KFBX_DLL KFbxLayerElementMaterial : public KFbxLayerElementTemplate<KFbxSurfaceMaterial*>
{
public:
    typedef KFbxLayerElementTemplate<KFbxSurfaceMaterial*> ParentClass;

    CREATE_DECLARE(LayerElementMaterial);
    
    class LayerElementArrayProxy : public KFbxLayerElementArrayTemplate<KFbxSurfaceMaterial*>
    {
    public:
        typedef KFbxLayerElementArrayTemplate<KFbxSurfaceMaterial*> ParentClass;

        LayerElementArrayProxy(EFbxType pType);
        void SetContainer( KFbxLayerContainer* pContainer, int pInstance = 0);
    };

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

    virtual void AllocateArrays();
    virtual void SetOwner( KFbxLayerContainer* pOwner, int pInstance = 0);
    virtual void SetInstance( int pInstance ) { SetOwner( mOwner, pInstance ); }

protected:
    KFbxLayerElementMaterial();
    ~KFbxLayerElementMaterial();

private:
    KFbxLayerElementArrayTemplate<KFbxSurfaceMaterial*>& GetDirectArray() const
    { 
        return ParentClass::GetDirectArray();
    }

    KFbxLayerElementArrayTemplate<KFbxSurfaceMaterial*>& GetDirectArray()
    { 
        return ParentClass::GetDirectArray();
    }
    
    friend class KFbxLayerContainer;

#endif //DOXYGEN_SHOULD_SKIP_THIS
}; 

class KFBX_DLL KFbxLayerElementPolygonGroup : public KFbxLayerElementTemplate<int>
{
public:

    CREATE_DECLARE(LayerElementPolygonGroup);
    
protected:
    KFbxLayerElementPolygonGroup();
    ~KFbxLayerElementPolygonGroup();
};

class KFBX_DLL KFbxLayerElementUV : public KFbxLayerElementTemplate<KFbxVector2>
{
public:
    CREATE_DECLARE(LayerElementUV);
    
protected:
    KFbxLayerElementUV();
    ~KFbxLayerElementUV();
};

class KFBX_DLL KFbxLayerElementVertexColor : public KFbxLayerElementTemplate<KFbxColor>
{
public:

    CREATE_DECLARE(LayerElementVertexColor);
    
protected:
    KFbxLayerElementVertexColor();
    ~KFbxLayerElementVertexColor();
};

const int kNoMapping = -1;

template <class T> inline KFbxLayerElementArrayTemplate<T>&       KFbxGetDirectArray(KFbxLayerElementUserData       *pLayerElement, int pIndex, bool* pStatus = NULL);
template <class T> inline KFbxLayerElementArrayTemplate<T> const& KFbxGetDirectArray(KFbxLayerElementUserData const *pLayerElement, int pIndex, bool* pStatus = NULL);
template <class T> inline KFbxLayerElementArrayTemplate<T>&       KFbxGetDirectArray(KFbxLayerElementUserData       *pLayerElement, const char* pName, bool* pStatus = NULL );
template <class T> inline KFbxLayerElementArrayTemplate<T> const& KFbxGetDirectArray(KFbxLayerElementUserData const *pLayerElement, const char* pName, bool* pStatus = NULL );

class KFBX_DLL KFbxLayerElementUserData : public KFbxLayerElementTemplate<void*>
{
public:
    KFBXNEW_DECLARE_FRIEND

    static KFbxLayerElementUserData* Create(KFbxLayerContainer* pOwner, char const *pName, int pId, KArrayTemplate<KFbxDataType>& pDataTypes, KArrayTemplate<const char*>& pDataNames);

    static KFbxLayerElementUserData* Create(KFbxLayerContainer* pOwner, KFbxLayerElementUserData const& pOther );

    KFbxLayerElementArrayTemplate<void*>* GetDirectArrayVoid( int pIndex, bool* pStatus = NULL)
    {       
        if( pIndex >= 0 || pIndex < GetDirectArray().GetCount() )
        {
            if (pStatus) *pStatus = true;
            return (KFbxLayerElementArrayTemplate<void*>*)GetDirectArray().AsReference(pIndex);
        }
        else
        {
            if( pStatus ) *pStatus = false;
            K_ASSERT_MSG_NOW("Index out of bounds");
            return (KFbxLayerElementArrayTemplate<void*>*)NULL;
        }
    }

    KFbxLayerElementArrayTemplate<void*> const* GetDirectArrayVoid( int pIndex, bool* pStatus = NULL) const
    {
        if( pIndex >= 0 || pIndex < GetDirectArray().GetCount() )
        {
            if (pStatus) *pStatus = true;
            return (KFbxLayerElementArrayTemplate<void*>*)GetDirectArray().AsReference(pIndex);
        }
        else
        {
            if( pStatus ) *pStatus = false;
            K_ASSERT_MSG_NOW("Index out of bounds");
            return (KFbxLayerElementArrayTemplate<void*> const*)NULL;
        }
    }


    KFbxLayerElementArrayTemplate<void *>* GetDirectArrayVoid ( const char* pName, bool* pStatus = NULL )
    {
        KString lName( pName );
        for( int i = 0; i < mDataNames.GetCount(); ++i )
        {
            if( *mDataNames[i] == lName )
                return GetDirectArrayVoid(i, pStatus);
        }

        if (pStatus) *pStatus = false;
        return (KFbxLayerElementArrayTemplate<void *>*)NULL;
    }
 
    KFbxLayerElementArrayTemplate<void *> const* GetDirectArrayVoid ( const char* pName, bool* pStatus = NULL ) const
    {
        KString lName( pName );
        for( int i = 0; i < mDataNames.GetCount(); ++i )
        {
            if( *mDataNames[i] == lName )
                return GetDirectArrayVoid(i, pStatus);
        }

        if (pStatus) *pStatus = false;
        return (KFbxLayerElementArrayTemplate<void *> const*)NULL;
    }

    KFbxDataType GetDataType( int pIndex ) const
    {
        if( pIndex < 0 || pIndex >= mDataTypes.GetCount() )
            return DTNone;

        return mDataTypes[pIndex];
    }

    KFbxDataType GetDataType( const char* pName ) const
    {
        KString lName( pName );

        for( int i = 0; i < mDataNames.GetCount(); ++i )
        {
            if( *mDataNames[i] == lName )
                return mDataTypes[i];
        }

        return DTNone;
    }

    const char* GetDataName( int pIndex ) const
    {
        if( pIndex >= 0 && pIndex < mDataNames.GetCount() )
            return mDataNames[pIndex]->Buffer();

        return NULL;
    }

    void ResizeAllDirectArrays( int pSize )
    {
        for( int i = 0; i < GetDirectArray().GetCount(); ++i )
        {
            switch( mDataTypes[i].GetType() )
            {
                case eBOOL1:    KFbxGetDirectArray<bool>(this,i).Resize( pSize )  ; break;
                case eINTEGER1: KFbxGetDirectArray<int>(this,i).Resize( pSize )   ; break;
                case eFLOAT1:   KFbxGetDirectArray<float>(this,i).Resize( pSize ) ; break;
                case eDOUBLE1:  KFbxGetDirectArray<double>(this,i).Resize( pSize ); break;
                //case eDOUBLE3:    GetDirectArray< fbxDouble3 >(i).Resize( pSize );    break;
                //case eDOUBLE4:    GetDirectArray< fbxDouble4 >(i).Resize( pSize );    break;
                //case eDOUBLE44:   GetDirectArray< fbxDouble44>(i).Resize( pSize );    break;  
                default:
                    K_ASSERT_MSG_NOW("unknown type" ); break;
            }
        }
    }

    void RemoveFromAllDirectArrays( int pIndex )
    {
        for( int i = 0; i < GetDirectArray().GetCount(); ++i )
        {
            switch( mDataTypes[i].GetType() )
            {
                case eBOOL1:    KFbxGetDirectArray<bool>(this,i).RemoveAt( pIndex )  ; break;
                case eINTEGER1: KFbxGetDirectArray<int>(this,i).RemoveAt( pIndex )   ; break;
                case eFLOAT1:   KFbxGetDirectArray<float>(this,i).RemoveAt( pIndex ) ; break;
                case eDOUBLE1:  KFbxGetDirectArray<double>(this,i).RemoveAt( pIndex ); break;
                //case eDOUBLE3:    GetDirectArray< fbxDouble3 >(i).RemoveAt( pIndex ); break;
                //case eDOUBLE4:    GetDirectArray< fbxDouble4 >(i).RemoveAt( pIndex ); break;
                //case eDOUBLE44:   GetDirectArray< fbxDouble44>(i).RemoveAt( pIndex ); break;  
                default:
                    K_ASSERT_MSG_NOW("unknown type" ); break;
            }
        }
    }

    int GetArrayCount( int pIndex ) const 
    {
        if( pIndex >= 0 && pIndex < GetDirectArray().GetCount() )
        {
            switch( mDataTypes[pIndex].GetType() )
            {
                case eBOOL1:    return KFbxGetDirectArray<bool>(this,pIndex).GetCount();
                case eINTEGER1: return KFbxGetDirectArray<int>(this,pIndex).GetCount();
                case eFLOAT1:   return KFbxGetDirectArray<float>(this,pIndex).GetCount();
                case eDOUBLE1:  return KFbxGetDirectArray<double>(this,pIndex).GetCount();
                //case eDOUBLE3:    return GetDirectArray< fbxDouble3 >(pIndex).GetCount();
                //case eDOUBLE4:    return GetDirectArray< fbxDouble4 >(pIndex).GetCount();
                //case eDOUBLE44:   return GetDirectArray< fbxDouble44>(pIndex).GetCount();
                default:
                    K_ASSERT_MSG_NOW("Unknown type" ); break;
            }
        }

        return -1;
    }

    int GetId() const { return mId; }

    int GetDirectArrayCount() const { return GetDirectArray().GetCount(); }

    KFbxLayerElementUserData& operator=( KFbxLayerElementUserData const& pOther )
    {
        if (this == &pOther)
            return *this;

        Clear();

        mId = pOther.mId;
        mDataTypes = pOther.mDataTypes;
        mDataNames.Resize(pOther.mDataNames.GetCount());
        for(int i = 0; i < pOther.mDataNames.GetCount(); ++i)
            mDataNames.SetAt(i,  FbxSdkNew< KString >( *pOther.mDataNames[i] ) );

        Init();
        for(int i = 0; i < pOther.GetDirectArrayCount(); ++i)
        {
            switch (mDataTypes[i].GetType())
            {
            case eBOOL1:
                KFbxGetDirectArray<bool>(this, i) = KFbxGetDirectArray<bool>(&pOther, i);
                break;

            case eINTEGER1:
                KFbxGetDirectArray<int>(this, i) = KFbxGetDirectArray<int>(&pOther, i);
                break;

            case eFLOAT1:
                KFbxGetDirectArray<float>(this, i) = KFbxGetDirectArray<float>(&pOther, i);
                break;

            case eDOUBLE1:
                KFbxGetDirectArray<double>(this, i) = KFbxGetDirectArray<double>(&pOther, i);
                break;

            default:
                K_ASSERT_MSG_NOW("Unknown type" );
                break;
            }
        }

        if ( ( mReferenceMode == KFbxLayerElement::eINDEX || 
               mReferenceMode == KFbxLayerElement::eINDEX_TO_DIRECT) &&
             ( pOther.GetReferenceMode() == KFbxLayerElement::eINDEX || 
               pOther.GetReferenceMode()  == KFbxLayerElement::eINDEX_TO_DIRECT))
        {
            GetIndexArray() = pOther.GetIndexArray();
        }

        return *this;
    }

    bool Clear()
    {
        int i;
        const int lCount = GetDirectArray().GetCount();
        KFbxLayerElementArray** directArray = NULL;
        directArray = GetDirectArray().GetLocked(directArray);
        for( i = 0; directArray != NULL && i < lCount; ++i )
        {
            if( directArray[i] )
                FbxSdkDelete(directArray[i]);
        }
        GetDirectArray().Release((void**)&directArray);

        for( i = 0; i < mDataNames.GetCount(); ++i )
        {
            KFBX_SAFE_DELETE_PTR(mDataNames[i]);
        }
        mDataNames.Clear();
        mDataTypes.Clear();

        KFbxLayerElementTemplate<void*>::Clear();

        return true;
    }

    virtual int MemorySize() const
    {
        int size = KFbxLayerElementTemplate<void*>::MemorySize();
        size += sizeof(mId);

        for(int i = 0; i < mDataTypes.GetCount(); i++)
        {
            size += sizeof(mDataTypes[i]);
        }
        size += (mDataNames.GetCount() * sizeof(KString*));

        return size;
    }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxLayerElementUserData( int pId, KArrayTemplate<KFbxDataType>& pDataTypes, KArrayTemplate<const char*>& pDataNames )
        :
        mId( pId ),
        mDataTypes( pDataTypes )
    {
        K_ASSERT( pDataTypes.GetCount() == pDataNames.GetCount() );
        for( int i = 0; i < pDataNames.GetCount(); ++i )
        {
            mDataNames.Add( FbxSdkNew< KString >( pDataNames[i] ) );
        }
    }

    KFbxLayerElementUserData( KFbxLayerElementUserData const& pOther ) : mId(pOther.mId), mDataTypes(pOther.mDataTypes)
    {
        for (int lIndex = 0; lIndex < pOther.mDataNames.GetCount(); ++lIndex)
        {
            mDataNames.Add(FbxSdkNew<KString>(*(pOther.mDataNames[lIndex])));
        }

        SetType(&DTLayerElementUserData);
        AllocateArrays();

        for(int i = 0; i < pOther.GetDirectArrayCount(); ++i)
        {
            switch (mDataTypes[i].GetType())
            {
            case eBOOL1:
                KFbxGetDirectArray<bool>(this, i) = KFbxGetDirectArray<bool>(&pOther, i);
                break;

            case eINTEGER1:
                KFbxGetDirectArray<int>(this, i) = KFbxGetDirectArray<int>(&pOther, i);
                break;

            case eFLOAT1:
                KFbxGetDirectArray<float>(this, i) = KFbxGetDirectArray<float>(&pOther, i);
                break;

            case eDOUBLE1:
                KFbxGetDirectArray<double>(this, i) = KFbxGetDirectArray<double>(&pOther, i);
                break;

            default:
                K_ASSERT_MSG_NOW("Unknown type" );
                break;
            }
        }

        if ( ( mReferenceMode == KFbxLayerElement::eINDEX || 
            mReferenceMode == KFbxLayerElement::eINDEX_TO_DIRECT) &&
            ( pOther.GetReferenceMode() == KFbxLayerElement::eINDEX || 
            pOther.GetReferenceMode()  == KFbxLayerElement::eINDEX_TO_DIRECT))
        {
            GetIndexArray() = pOther.GetIndexArray();
        }
    }

    ~KFbxLayerElementUserData()
    {
        Clear();
    }

    virtual void AllocateArrays()
    {
        KFbxLayerElementTemplate<void*>::AllocateArrays();
        Init();
    }


private:

    void Init()
    {
        int i;
        GetDirectArray().Resize( mDataTypes.GetCount() );

        // initialize arrays
        for( i = 0; i < mDataTypes.GetCount(); ++i )
        {
            kReference** dst = NULL;
            dst = GetDirectArray().GetLocked(dst);
            if (dst)
            {
                switch( mDataTypes[i].GetType() )
                {
                    case eBOOL1:    dst[i] = (kReference*)FbxSdkNew< KFbxLayerElementArrayTemplate<bool> >(mDataTypes[i].GetType());    break;
                    case eINTEGER1: dst[i] = (kReference*)FbxSdkNew< KFbxLayerElementArrayTemplate<int> >(mDataTypes[i].GetType()); break;
                    case eFLOAT1:   dst[i] = (kReference*)FbxSdkNew< KFbxLayerElementArrayTemplate<float> >(mDataTypes[i].GetType());   break;
                    case eDOUBLE1:  dst[i] = (kReference*)FbxSdkNew< KFbxLayerElementArrayTemplate<double> >(mDataTypes[i].GetType());  break;
                    //case eDOUBLE3:    mDirectArray[i] = new KArrayTemplate< fbxDouble3 >();   break;  
                    //case eDOUBLE4:    mDirectArray[i] = new KArrayTemplate< fbxDouble4 >();   break;
                    //case eDOUBLE44:   mDirectArray[i] = new KArrayTemplate< fbxDouble44 >();  break;  
                    default:
                        K_ASSERT_MSG_NOW("Trying to assign an unknown type" ); break;
                }
                GetDirectArray().Release((void**)&dst);
            }
        }
    }

    int mId;
    KArrayTemplate<KFbxDataType> mDataTypes;
    KArrayTemplate<KString*> mDataNames;
  #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

template <class T>
inline KFbxLayerElementArrayTemplate<T>& KFbxGetDirectArray( KFbxLayerElementUserData *pLayerElement,int pIndex, bool* pStatus)
{
    return *(KFbxLayerElementArrayTemplate<T>*)pLayerElement->GetDirectArrayVoid(pIndex,pStatus);
}

template <class T>
inline KFbxLayerElementArrayTemplate<T> const& KFbxGetDirectArray(KFbxLayerElementUserData const *pLayerElement, int pIndex, bool* pStatus)
{
    return *(KFbxLayerElementArrayTemplate<T> const*)pLayerElement->GetDirectArrayVoid(pIndex,pStatus);
}


template <class T>
inline KFbxLayerElementArrayTemplate<T>& KFbxGetDirectArray( KFbxLayerElementUserData *pLayerElement,const char* pName, bool* pStatus )
{
    return *(KFbxLayerElementArrayTemplate<T>*)pLayerElement->GetDirectArrayVoid(pName,pStatus);
}

template <class T>
inline KFbxLayerElementArrayTemplate<T> const& KFbxGetDirectArray(KFbxLayerElementUserData const *pLayerElement, const char* pName, bool* pStatus )
{
    return *(KFbxLayerElementArrayTemplate<T> const*)pLayerElement->GetDirectArrayVoid(pName,pStatus);
}


class KFBX_DLL KFbxLayerElementSmoothing : public KFbxLayerElementTemplate<int>
{
public:
    KFBXNEW_DECLARE_FRIEND

    static KFbxLayerElementSmoothing* Create(KFbxLayerContainer* pOwner, char const *pName);

    void SetReferenceMode( KFbxLayerElement::EReferenceMode pMode )
    {
        if( pMode != KFbxLayerElement::eDIRECT )
        {
            K_ASSERT_MSG_NOW( "Smoothing layer elements must be direct mapped" );
            return;
        }
    }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

protected:
    KFbxLayerElementSmoothing()
    {
        mReferenceMode = KFbxLayerElement::eDIRECT;
    }
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

class KFBX_DLL KFbxLayerElementCrease : public KFbxLayerElementTemplate<double>
{
public:
    KFBXNEW_DECLARE_FRIEND

    static KFbxLayerElementCrease* Create(KFbxLayerContainer* pOwner, char const *pName);

    void SetReferenceMode( KFbxLayerElement::EReferenceMode pMode )
    {
        if( pMode != KFbxLayerElement::eDIRECT )
        {
            K_ASSERT_MSG_NOW( "Crease layer elements must be direct mapped" );
            return;
        }
    }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

protected:
    KFbxLayerElementCrease()
    {
        mReferenceMode = KFbxLayerElement::eDIRECT;
    }
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

class KFBX_DLL KFbxLayerElementHole : public KFbxLayerElementTemplate<bool>
{
public:
    KFBXNEW_DECLARE_FRIEND

        static KFbxLayerElementHole* Create(KFbxLayerContainer* pOwner, char const *pName);

    void SetReferenceMode( KFbxLayerElement::EReferenceMode pMode )
    {
        if( pMode != KFbxLayerElement::eDIRECT )
        {
            K_ASSERT_MSG_NOW( "hole layer elements must be direct mapped" );
            return;
        }
    }

    //
    //  WARNING!
    //
    //  Anything beyond these lines may not be documented accurately and is 
    //  subject to change without notice.
    //
#ifndef DOXYGEN_SHOULD_SKIP_THIS

protected:
    KFbxLayerElementHole()
    {
        mReferenceMode = KFbxLayerElement::eDIRECT;
    }
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

class KFBX_DLL KFbxLayerElementVisibility : public KFbxLayerElementTemplate<bool>
{
public:

    CREATE_DECLARE(LayerElementVisibility);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxLayerElementVisibility();
    ~KFbxLayerElementVisibility();
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

typedef class KFBX_DLL KFbxLayerElementTemplate<KFbxTexture*>  KFbxLayerElementTextureBase;

class KFBX_DLL KFbxLayerElementTexture : public KFbxLayerElementTextureBase
{

public:

    CREATE_DECLARE(LayerElementTexture);

    typedef enum 
    {
        eTRANSLUCENT,
        eADD,
        eMODULATE,
        eMODULATE2,
        eOVER,
        eNORMAL,        
        eDISSOLVE,
        eDARKEN,            
        eCOLORBURN,
        eLINEARBURN,    
        eDARKERCOLOR,
        eLIGHTEN,           
        eSCREEN,        
        eCOLORDODGE,
        eLINEARDODGE,
        eLIGHTERCOLOR,
        eSOFTLIGHT,     
        eHARDLIGHT,     
        eVIVIDLIGHT,
        eLINEARLIGHT,
        ePINLIGHT,      
        eHARDMIX,       
        eDIFFERENCE,        
        eEXCLUSION,         
        eSUBTRACT,
        eDIVIDE,
        eHUE,           
        eSATURATION,        
        eCOLOR,     
        eLUMINOSITY,
        eMAXBLEND
    } EBlendMode;

    void       SetBlendMode(EBlendMode pBlendMode) { mBlendMode = pBlendMode; }

    void       SetAlpha(double pAlpha)
    {
        if (pAlpha > 1.0)
            mAlpha = 1.0;
        else if (pAlpha < 0.0)
            mAlpha = 0.0;
        else
            mAlpha = pAlpha;
    }

    EBlendMode GetBlendMode() const                      { return mBlendMode; } 

    double     GetAlpha() const                          { return mAlpha; }

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

    virtual int MemorySize() const
    {
        int size = KFbxLayerElementTextureBase::MemorySize();
        size += sizeof(mBlendMode);
        size += sizeof(mAlpha);
        return size;
    }

protected:
    KFbxLayerElementTexture() : mBlendMode(eTRANSLUCENT)
    {
        mReferenceMode = eINDEX_TO_DIRECT;
        mAlpha         = 1.0;
    }

private:
    EBlendMode mBlendMode;
    double     mAlpha;
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};


class KFBX_DLL KFbxLayer
{

public:
    KFBXNEW_DECLARE_FRIEND


    KFbxLayerElementNormal* GetNormals();   

    KFbxLayerElementNormal const* GetNormals() const;

    KFbxLayerElementTangent* GetTangents(); 

    KFbxLayerElementTangent const* GetTangents() const;

    KFbxLayerElementBinormal* GetBinormals();   

    KFbxLayerElementBinormal const* GetBinormals() const;

    KFbxLayerElementMaterial* GetMaterials();

    KFbxLayerElementMaterial const* GetMaterials() const;

    KFbxLayerElementPolygonGroup* GetPolygonGroups();

    KFbxLayerElementPolygonGroup const* GetPolygonGroups() const;

    KFbxLayerElementUV* GetUVs(KFbxLayerElement::ELayerElementType pTypeIdentifier=KFbxLayerElement::eDIFFUSE_TEXTURES);

    KFbxLayerElementUV const* GetUVs(KFbxLayerElement::ELayerElementType pTypeIdentifier=KFbxLayerElement::eDIFFUSE_TEXTURES) const;


    int GetUVSetCount() const;
    
    KArrayTemplate<KFbxLayerElement::ELayerElementType> GetUVSetChannels() const;

    KArrayTemplate<KFbxLayerElementUV const*> GetUVSets() const;

    KFbxLayerElementVertexColor* GetVertexColors();

    KFbxLayerElementVertexColor const* GetVertexColors() const;

    KFbxLayerElementSmoothing* GetSmoothing();

    KFbxLayerElementSmoothing const* GetSmoothing() const;

    KFbxLayerElementCrease* GetVertexCrease();

    KFbxLayerElementCrease const* GetVertexCrease() const;

    KFbxLayerElementCrease* GetEdgeCrease();

    KFbxLayerElementCrease const* GetEdgeCrease() const;

    KFbxLayerElementHole* GetHole();

    KFbxLayerElementHole const* GetHole() const;

    KFbxLayerElementUserData* GetUserData();

    KFbxLayerElementUserData const* GetUserData() const;

    KFbxLayerElementVisibility* GetVisibility();

    KFbxLayerElementVisibility const* GetVisibility() const;

    KFbxLayerElementTexture* GetTextures(KFbxLayerElement::ELayerElementType pType);

    KFbxLayerElementTexture const* GetTextures(KFbxLayerElement::ELayerElementType pType) const;

    void SetTextures(KFbxLayerElement::ELayerElementType pType, KFbxLayerElementTexture* pTextures);

    KFbxLayerElement* GetLayerElementOfType(KFbxLayerElement::ELayerElementType pType, bool pIsUV=false);

    KFbxLayerElement const* GetLayerElementOfType(KFbxLayerElement::ELayerElementType pType, bool pIsUV=false) const;

    void SetNormals(KFbxLayerElementNormal* pNormals);

    void SetBinormals(KFbxLayerElementBinormal* pBinormals);

    void SetTangents(KFbxLayerElementTangent* pTangents);

    void SetMaterials(KFbxLayerElementMaterial* pMaterials);

    void SetPolygonGroups(KFbxLayerElementPolygonGroup* pPolygonGroups);

    void SetUVs(KFbxLayerElementUV* pUVs, KFbxLayerElement::ELayerElementType pTypeIdentifier=KFbxLayerElement::eDIFFUSE_TEXTURES);

    void SetVertexColors (KFbxLayerElementVertexColor* pVertexColors);

    void SetSmoothing (KFbxLayerElementSmoothing* pSmoothing);

    void SetVertexCrease (KFbxLayerElementCrease* pCrease);

    void SetEdgeCrease (KFbxLayerElementCrease* pCrease);

    void SetHole (KFbxLayerElementHole* pHole);

    void SetUserData (KFbxLayerElementUserData* pUserData);

    void SetVisibility( KFbxLayerElementVisibility* pVisibility );

    void SetLayerElementOfType(KFbxLayerElement* pLayerElement, KFbxLayerElement::ELayerElementType pType, bool pIsUV=false);

    KFbxLayerElement* CreateLayerElementOfType(KFbxLayerElement::ELayerElementType pType, bool pIsUV=false);

    void Clone(KFbxLayer const& pSrcLayer, KFbxSdkManager* pSdkManager);    
    
    
//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is 
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxLayer& operator=(KFbxLayer const& pSrcLayer);
private:

    KFbxLayer(KFbxLayerContainer& pOwner);
    virtual ~KFbxLayer();

    void Clear();

    KFbxLayerContainer& mOwner;

    KFbxLayerElement*             mNonTexturesArray[KFbxLayerElement::LAYERELEMENT_TYPE_NON_TEXTURE_COUNT];
    KFbxLayerElementUV*           mUVsArray[KFbxLayerElement::LAYERELEMENT_TYPE_TEXTURE_COUNT];
    KFbxLayerElementTexture*      mTexturesArray[KFbxLayerElement::LAYERELEMENT_TYPE_TEXTURE_COUNT];


    friend class KFbxLayerContainer;

public:
        bool ContentWriteTo(KFbxStream& pStream) const;
        bool ContentReadFrom(const KFbxStream& pStream);
    virtual int MemoryUsage() const;

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#define FOR_EACH_TEXTURE(lLayerIndex) for((lLayerIndex) = 0; (lLayerIndex) < KFbxLayerElement::LAYERELEMENT_TYPE_TEXTURE_COUNT; (lLayerIndex)++)

#define FOR_EACH_NON_TEXTURE(lLayerIndex) for((lLayerIndex) = 0; (lLayerIndex) < KFbxLayerElement::LAYERELEMENT_TYPE_NON_TEXTURE_COUNT; (lLayerIndex)++)

#define TEXTURE_INDEX(ElementType) (int(ElementType) - KFbxLayerElement::LAYERELEMENT_TYPE_TEXTURE_START_INDEX)

#define TEXTURE_TYPE(TextureIndex) (KFbxLayerElement::ELayerElementType((TextureIndex) + KFbxLayerElement::LAYERELEMENT_TYPE_TEXTURE_START_INDEX))

#define NON_TEXTURE_INDEX(ElementType) (int(ElementType) - KFbxLayerElement::LAYERELEMENT_TYPE_NON_TEXTURE_START_INDEX)

#define NON_TEXTURE_TYPE(Index) (KFbxLayerElement::ELayerElementType((Index) + KFbxLayerElement::LAYERELEMENT_TYPE_NON_TEXTURE_START_INDEX))


typedef KFbxLayerElement KFbxGeometryElement;
typedef KFbxLayerElementNormal KFbxGeometryElementNormal;
typedef KFbxLayerElementBinormal KFbxGeometryElementBinormal;
typedef KFbxLayerElementTangent KFbxGeometryElementTangent;
typedef KFbxLayerElementMaterial KFbxGeometryElementMaterial;
typedef KFbxLayerElementPolygonGroup KFbxGeometryElementPolygonGroup;
typedef KFbxLayerElementUV KFbxGeometryElementUV;
typedef KFbxLayerElementVertexColor KFbxGeometryElementVertexColor;
typedef KFbxLayerElementUserData KFbxGeometryElementUserData;
typedef KFbxLayerElementSmoothing KFbxGeometryElementSmoothing;
typedef KFbxLayerElementCrease KFbxGeometryElementCrease;
typedef KFbxLayerElementHole KFbxGeometryElementHole;
typedef KFbxLayerElementVisibility KFbxGeometryElementVisibility;


#undef CREATE_DECLARE
#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXLAYER_H