Show in Contents

Add to Favorites

Home: FBX SDK Programmers Guide

 

 

 

FBX SDK Reference Guide: kfbxlayer.h Source File

Go to the documentation of this file.

#ifndef _FBXSDK_LAYER_H_
#define _FBXSDK_LAYER_H_

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

 Copyright © 2001 - 2008 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material 
 (collectively the "Data") in these files contain unpublished information 
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 
 Canada and United States of America federal copyright law and by international 
 treaties. 
 
 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE. 

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

#include <kaydaradef.h>
#ifndef KFBX_DLL 
    #define KFBX_DLL K_DLLIMPORT
#endif

#include <kaydara.h>

#include <klib/kstring.h>
#include <klib/karrayul.h>
#include <klib/kdebug.h>

#ifndef MB_FBXSDK
#include <kbaselib_nsuse.h>
#endif

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

#include <fbxfilesdk_nsbegin.h>

class KFbxTexture;
class KFbxSurfaceMaterial;
class KFbxSdkManager;

class KFbxGeometryBase;
class KFbxLayer;
class KFbxLayerContainer;
class KFbxMesh;
class KFbxNode;
class KFbxReader3DS;
class KFbxReaderFbx;
class KFbxReaderFbx6;
class KFbxReaderObj;

//class KFbxReaderCollada;


class KFBX_DLL KFbxLayerElement
{

public:

    typedef enum 
    {
        eUNDEFINED,
        eNORMAL,
        eMATERIAL,
        eDIFFUSE_TEXTURES,
        ePOLYGON_GROUP,
        eUV,
        eVERTEX_COLOR,
        eSMOOTHING,
        eUSER_DATA,
        eVISIBILITY,
        eEMISSIVE_TEXTURES,
        eEMISSIVE_FACTOR_TEXTURES,
        eAMBIENT_TEXTURES,
        eAMBIENT_FACTOR_TEXTURES,
        eDIFFUSE_FACTOR_TEXTURES,
        eSPECULAR_TEXTURES,
        eNORMALMAP_TEXTURES,
        eSPECULAR_FACTOR_TEXTURES,
        eSHININESS_TEXTURES,
        eBUMP_TEXTURES,
        eTRANSPARENT_TEXTURES,
        eTRANSPARENCY_FACTOR_TEXTURES,
        eREFLECTION_TEXTURES,
        eREFLECTION_FACTOR_TEXTURES,
        eLAST_ELEMENT_TYPE
    } ELayerElementType;

    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();

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void SetType(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;
    KFbxDataType* mType;
    KFbxLayerContainer* mOwner;

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

    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;


    // Data access
    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);

    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)
    {
        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;
    }

    K_DEPRECATED       T*   GetArray()          { return (T*)GetDataPtr(); }
    K_DEPRECATED const T*   GetArray() const    { return (const T*)(const_cast<KFbxLayerElementArrayTemplate<T> *>(this)->GetDataPtr()); }
    K_DEPRECATED T& operator[](int pIndex)      { T* v = (T*)KFbxLayerElementArray::GetReference(pIndex, mDataType); return (v)?*v:dummy;}

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
    {
        const KFbxLayerElementArrayTemplate<Type>& directArray = pOther.GetDirectArray();
        const KFbxLayerElementArrayTemplate<int>& indexArray = pOther.GetIndexArray();

        bool ret = true;
        if( directArray.GetCount() != mDirectArray->GetCount() || 
            indexArray.GetCount() != mIndexArray->GetCount() ||
            !directArray.ReadLock() || !indexArray.ReadLock() ||
            !mDirectArray->ReadLock() || !mIndexArray->ReadLock() )
        {
            ret = false;
        }

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

            if (ret == true)
            {
                if( !mDirectArray->IsEqual(directArray) )
                    ret = false;
            }
        }

        directArray.ReadUnlock();
        indexArray.ReadUnlock();
        mDirectArray->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() 
    {
        delete mDirectArray;
        delete mIndexArray;
    }

    virtual void AllocateArrays()
    {
        mDirectArray = new KFbxLayerElementArrayTemplate<Type>(mType->GetType());
        mIndexArray = new 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);
    }

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

#define CREATE_DECLARE(classDesc) \
    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 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);
    };


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

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

//
//  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();

#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:

    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 )
    {
        int i;
        Clear();

        // Build descriptives.
        //
        mDataNames.Resize(pOther.mDataNames.GetCount());
        for( i = 0; i < pOther.mDataNames.GetCount(); ++i )
            mDataNames.SetAt(i,  new KString( *pOther.mDataNames[i] ) );

        mDataTypes.Resize(pOther.mDataTypes.GetCount());
        for( i = 0; i < pOther.mDataTypes.GetCount(); ++i )
            mDataTypes.SetAt(i, pOther.mDataTypes[i] );


        Init();
        kReference** dummy = NULL;
        for( i = 0; i < pOther.GetDirectArrayCount(); ++i )
        {
            kReference** src = pOther.GetDirectArray().GetLocked(dummy, KFbxLayerElementArray::eREAD_LOCK);
            kReference** dst = GetDirectArray().GetLocked(dummy, KFbxLayerElementArray::eREADWRITE_LOCK);

            if (src && dst)
            {
                *dst[i] = *src[i];
                /*switch( mDataTypes[i].GetType() )
                {
                    case eBOOL1:    ((KArrayTemplate<bool>*)mDirectArray[i])->operator=( (*(const KArrayTemplate<bool>*)pOther.mDirectArray[i]) ); break;
                    case eINTEGER1: ((KArrayTemplate<int>*)mDirectArray[i])->operator=( (*(const KArrayTemplate<int>*)pOther.mDirectArray[i]) ); break;
                    case eFLOAT1:   ((KArrayTemplate<float>*)mDirectArray[i])->operator=( (*(const KArrayTemplate<float>*)pOther.mDirectArray[i]) ); break;
                    case eDOUBLE1:  ((KArrayTemplate<double>*)mDirectArray[i])->operator=( (*(const KArrayTemplate<double>*)pOther.mDirectArray[i]) ); break;
                    //case eDOUBLE3:    GetDirectArray< fbxDouble3 >(pIndex).SetAt(j, pOther.GetDirectArray<bool>(i)[j] );
                    //case eDOUBLE4:    GetDirectArray< fbxDouble4 >(pIndex).SetAt(j, pOther.GetDirectArray<bool>(i)[j] );
                    //case eDOUBLE44:   GetDirectArray< fbxDouble44>(pIndex).SetAt(j, pOther.GetDirectArray<bool>(i)[j] );
                    default:
                        K_ASSERT_MSG_NOW("Unknown type" ); break;
                }*/

                GetDirectArray().Release((void**)&dst);
                pOther.GetDirectArray().Release((void**)&src);
            }
            else
                K_ASSERT_MSG_NOW("Unable to get lock");
        }

        mId = pOther.mId;

        GetIndexArray() = pOther.GetIndexArray();

        return *this;
    }

    void 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] )
                delete directArray[i];
        }
        GetDirectArray().Release((void**)&directArray);

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

        KFbxLayerElementTemplate<void*>::Clear();
    }

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

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( new KString( pDataNames[i] ) );
        }
    }

    KFbxLayerElementUserData( KFbxLayerElementUserData const& pOther )
    {
        *this = pOther;
    }

    ~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*)new KFbxLayerElementArrayTemplate<bool>(mDataTypes[i].GetType()); break;
                    case eINTEGER1: dst[i] = (kReference*)new KFbxLayerElementArrayTemplate<int>(mDataTypes[i].GetType());  break;
                    case eFLOAT1:   dst[i] = (kReference*)new KFbxLayerElementArrayTemplate<float>(mDataTypes[i].GetType());    break;
                    case eDOUBLE1:  dst[i] = (kReference*)new 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;
};

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:
    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;
        }
    }

protected:
    KFbxLayerElementSmoothing()
    {
        mReferenceMode = KFbxLayerElement::eDIRECT;
    }

};

class KFBX_DLL KFbxLayerElementVisibility : public KFbxLayerElementTemplate<bool>
{
public:
    CREATE_DECLARE(LayerElementVisibility);

protected:
    KFbxLayerElementVisibility();
    ~KFbxLayerElementVisibility();
};

typedef class KFBX_DLL KFbxLayerElementTemplate<KFbxTexture*>  KFbxLayerElementTextureBase;

class KFBX_DLL KFbxLayerElementTexture : public KFbxLayerElementTextureBase
{

public:
    CREATE_DECLARE(LayerElementTexture);

    typedef enum 
    {
        eTRANSLUCENT,
        eADD,
        eMODULATE,
        eMODULATE2,
        eMAXBLEND
    } EBlendMode;

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

    void       SetAlpha(double pAlpha)             
    { 
        mAlpha = pAlpha > 1.0 ? 1.0 : pAlpha;
        mAlpha = pAlpha < 0.0 ? 0.0 : pAlpha;
    }

    EBlendMode GetBlendMode()                      { return mBlendMode; } 

    double     GetAlpha()                          { 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:


    KFbxLayerElementNormal* GetNormals();   

    KFbxLayerElementNormal const* GetNormals() const;   

    KFbxLayerElementMaterial* GetMaterials();

    KFbxLayerElementMaterial const* GetMaterials() const;

    KFbxLayerElementPolygonGroup* GetPolygonGroups();

    KFbxLayerElementPolygonGroup const* GetPolygonGroups() const;


    KFbxLayerElementUV* GetEmissiveUV();

    KFbxLayerElementUV const* GetEmissiveUV() const;

    KFbxLayerElementUV* GetEmissiveFactorUV();

    KFbxLayerElementUV const* GetEmissiveFactorUV() const;

    KFbxLayerElementUV* GetAmbientUV();

    KFbxLayerElementUV const* GetAmbientUV() const;

    KFbxLayerElementUV* GetAmbientFactorUV();

    KFbxLayerElementUV const* GetAmbientFactorUV() const;
    
    KFbxLayerElementUV* GetDiffuseUV();

    KFbxLayerElementUV const* GetDiffuseUV() const;

    KFbxLayerElementUV* GetDiffuseFactorUV();

    KFbxLayerElementUV const* GetDiffuseFactorUV() const;

    KFbxLayerElementUV* GetSpecularUV();

    KFbxLayerElementUV const* GetSpecularUV() const;

    KFbxLayerElementUV* GetSpecularFactorUV();

    KFbxLayerElementUV const* GetSpecularFactorUV() const;

    KFbxLayerElementUV* GetShininessUV();

    KFbxLayerElementUV const* GetShininessUV() const;

    KFbxLayerElementUV* GetNormalMapUV();

    KFbxLayerElementUV const* GetNormalMapUV() const;

    KFbxLayerElementUV* GetBumpUV();

    KFbxLayerElementUV const* GetBumpUV() const;

    KFbxLayerElementUV* GetTransparentUV();

    KFbxLayerElementUV const* GetTransparentUV() const;

    KFbxLayerElementUV* GetTransparencyFactorUV();

    KFbxLayerElementUV const* GetTransparencyFactorUV() const;

    KFbxLayerElementUV* GetReflectionUV();

    KFbxLayerElementUV const* GetReflectionUV() const;

    KFbxLayerElementUV* GetReflectionFactorUV();

    KFbxLayerElementUV const* GetReflectionFactorUV() 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;

    KFbxLayerElementUserData* GetUserData();

    KFbxLayerElementUserData const* GetUserData() const;

    KFbxLayerElementVisibility* GetVisibility();

    KFbxLayerElementVisibility const* GetVisibility() const;

    KFbxLayerElementTexture* GetEmissiveTextures();

    KFbxLayerElementTexture const* GetEmissiveTextures() const;

    KFbxLayerElementTexture* GetEmissiveFactorTextures();

    KFbxLayerElementTexture const* GetEmissiveFactorTextures() const;

    KFbxLayerElementTexture* GetAmbientTextures();

    KFbxLayerElementTexture const* GetAmbientTextures() const;

    KFbxLayerElementTexture* GetAmbientFactorTextures();

    KFbxLayerElementTexture const* GetAmbientFactorTextures() const;
    
    KFbxLayerElementTexture* GetDiffuseTextures();

    KFbxLayerElementTexture const* GetDiffuseTextures() const;

    KFbxLayerElementTexture* GetDiffuseFactorTextures();

    KFbxLayerElementTexture const* GetDiffuseFactorTextures() const;

    KFbxLayerElementTexture* GetSpecularTextures();

    KFbxLayerElementTexture const* GetSpecularTextures() const;

    KFbxLayerElementTexture* GetSpecularFactorTextures();

    KFbxLayerElementTexture const* GetSpecularFactorTextures() const;

    KFbxLayerElementTexture* GetShininessTextures();

    KFbxLayerElementTexture const* GetShininessTextures() const;

    KFbxLayerElementTexture* GetNormalMapTextures();

    KFbxLayerElementTexture const* GetNormalMapTextures() const;

    KFbxLayerElementTexture* GetBumpTextures();

    KFbxLayerElementTexture const* GetBumpTextures() const;

    KFbxLayerElementTexture* GetTransparentTextures();

    KFbxLayerElementTexture const* GetTransparentTextures() const;

    KFbxLayerElementTexture* GetTransparencyFactorTextures();

    KFbxLayerElementTexture const* GetTransparencyFactorTextures() const;

    KFbxLayerElementTexture* GetReflectionTextures();

    KFbxLayerElementTexture const* GetReflectionTextures() const;

    KFbxLayerElementTexture* GetReflectionFactorTextures();

    KFbxLayerElementTexture const* GetReflectionFactorTextures() 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 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 SetUserData (KFbxLayerElementUserData* pUserData);

    void SetVisibility( KFbxLayerElementVisibility* pVisibility );

    void SetEmissiveTextures(KFbxLayerElementTexture* pTextures);

    void SetEmissiveFactorTextures(KFbxLayerElementTexture* pTextures);

    void SetAmbientTextures(KFbxLayerElementTexture* pTextures);

    void SetAmbientFactorTextures(KFbxLayerElementTexture* pTextures);

    void SetDiffuseTextures(KFbxLayerElementTexture* pTextures);

    void SetDiffuseFactorTextures(KFbxLayerElementTexture* pTextures);

    void SetSpecularTextures(KFbxLayerElementTexture* pTextures);

    void SetSpecularFactorTextures(KFbxLayerElementTexture* pTextures);

    void SetShininessTextures(KFbxLayerElementTexture* pTextures);

    void SetNormalMapTextures(KFbxLayerElementTexture* pTextures);

    void SetBumpTextures(KFbxLayerElementTexture* pTextures);

    void SetTransparentTextures(KFbxLayerElementTexture* pTextures);

    void SetTransparencyFactorTextures(KFbxLayerElementTexture* pTextures);

    void SetReflectionTextures(KFbxLayerElementTexture* pTextures);

    void SetReflectionFactorTextures(KFbxLayerElementTexture* pTextures);


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


    void Clone(KFbxLayer const& pSrcLayer, KFbxSdkManager* pSdkManager);    
    
    //KFbxLayer& operator=(KFbxLayer const& pSrcLayer); 
    
//
//  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;

    KFbxLayerElementNormal*       mNormals;
    KFbxLayerElementMaterial*     mMaterials;
    KFbxLayerElementPolygonGroup* mPolygonGroups;
    KFbxLayerElementUV*           mUVs; 
    KFbxLayerElementVertexColor*  mVertexColors;
    KFbxLayerElementSmoothing*    mSmoothing;
    KFbxLayerElementUserData*     mUserData;
    KFbxLayerElementVisibility*   mVisibility;

    KFbxLayerElementUV*      mEmissiveUV;
    KFbxLayerElementUV*      mEmissiveFactorUV;
    KFbxLayerElementUV*      mAmbientUV;
    KFbxLayerElementUV*      mAmbientFactorUV;
    KFbxLayerElementUV*      mDiffuseFactorUV;
    KFbxLayerElementUV*      mSpecularUV;
    KFbxLayerElementUV*      mSpecularFactorUV;
    KFbxLayerElementUV*      mShininessUV;
    KFbxLayerElementUV*      mNormalMapUV;
    KFbxLayerElementUV*      mBumpUV;
    KFbxLayerElementUV*      mTransparentUV;
    KFbxLayerElementUV*      mTransparencyFactorUV;
    KFbxLayerElementUV*      mReflectionUV;
    KFbxLayerElementUV*      mReflectionFactorUV;


    KFbxLayerElementTexture*      mEmissiveTextures;
    KFbxLayerElementTexture*      mEmissiveFactorTextures;
    KFbxLayerElementTexture*      mAmbientTextures;
    KFbxLayerElementTexture*      mAmbientFactorTextures;
    KFbxLayerElementTexture*      mDiffuseTextures;
    KFbxLayerElementTexture*      mDiffuseFactorTextures;
    KFbxLayerElementTexture*      mSpecularTextures;
    KFbxLayerElementTexture*      mSpecularFactorTextures;
    KFbxLayerElementTexture*      mShininessTextures;
    KFbxLayerElementTexture*      mNormalMapTextures;
    KFbxLayerElementTexture*      mBumpTextures;
    KFbxLayerElementTexture*      mTransparentTextures;
    KFbxLayerElementTexture*      mTransparencyFactorTextures;
    KFbxLayerElementTexture*      mReflectionTextures;
    KFbxLayerElementTexture*      mReflectionFactorTextures;

    friend class KFbxLayerContainer;

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

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#undef CREATE_DECLARE
#include <fbxfilesdk_nsend.h>

#endif // #ifndef _FBXSDK_LAYER_H_