//-----------------------------------------------------------------------------------
    void KfTransformArrayMemoryManager::createNewNode( KfTransform **outTransform )
    {
        const size_t nextSlot = createNewSlot();
        for( size_t i=0; i<ARRAY_PACKED_REALS - 1; ++i )
            createNewSlot();

        const unsigned char nextSlotIdx = nextSlot % ARRAY_PACKED_REALS;
        const size_t nextSlotBase       = nextSlot - nextSlotIdx;

        //Set memory ptrs
        *outTransform = reinterpret_cast<KfTransform*>( mMemoryPools[KfTransformType] +
                                                    nextSlotBase * mElementsMemSizes[KfTransformType] );

        //Set default values
        (*outTransform)->mPosition      = ArrayVector3::ZERO;
        (*outTransform)->mOrientation   = ArrayQuaternion::IDENTITY;
        (*outTransform)->mScale         = ArrayVector3::UNIT_SCALE;
    }
    void ObjectDataArrayMemoryManager::createNewNode( ObjectData &outData )
    {
        const size_t nextSlot = createNewSlot();
        const unsigned char nextSlotIdx = nextSlot % ARRAY_PACKED_REALS;
        const size_t nextSlotBase       = nextSlot - nextSlotIdx;

        //Set memory ptrs
        outData.mIndex = nextSlotIdx;
        outData.mParents            = reinterpret_cast<DiNode**>( mMemoryPools[Parent] +
                                                nextSlotBase * mElementsMemSizes[Parent] );
        outData.mOwner              = reinterpret_cast<DiTransUnitPtr*>( mMemoryPools[Owner] +
                                                nextSlotBase * mElementsMemSizes[Owner] );
        outData.mLocalAabb          = reinterpret_cast<ArrayAabb*>( mMemoryPools[LocalAabb] +
                                                nextSlotBase * mElementsMemSizes[LocalAabb] );
        outData.mWorldAabb          = reinterpret_cast<ArrayAabb*>( mMemoryPools[WorldAabb] +
                                                nextSlotBase * mElementsMemSizes[WorldAabb] );
        outData.mLocalRadius        = reinterpret_cast<float*>( mMemoryPools[LocalRadius] +
                                                nextSlotBase * mElementsMemSizes[LocalRadius] );
        outData.mWorldRadius        = reinterpret_cast<float*>( mMemoryPools[WorldRadius] +
                                                nextSlotBase * mElementsMemSizes[WorldRadius] );
        outData.mUpperDistance      = reinterpret_cast<float*>( mMemoryPools[UpperDistance] +
                                                nextSlotBase * mElementsMemSizes[UpperDistance] );
        outData.mVisibilityFlags    = reinterpret_cast<uint32*>( mMemoryPools[VisibilityFlags] +
                                                nextSlotBase * mElementsMemSizes[VisibilityFlags] );
        outData.mQueryFlags         = reinterpret_cast<uint32*>( mMemoryPools[QueryFlags] +
                                                nextSlotBase * mElementsMemSizes[QueryFlags] );
        outData.mLightMask          = reinterpret_cast<uint32*>( mMemoryPools[LightMask] +
                                                nextSlotBase * mElementsMemSizes[LightMask] );

        //Set default values
        outData.mParents[nextSlotIdx]   = mDummyNode;
        outData.mOwner[nextSlotIdx]     = 0; //Caller has to fill it. Otherwise a crash is a good warning
        outData.mLocalAabb->setFromAabb( Aabb::BOX_INFINITE, nextSlotIdx );
        outData.mWorldAabb->setFromAabb( Aabb::BOX_INFINITE, nextSlotIdx );
        outData.mWorldRadius[nextSlotIdx]           = 0;
        outData.mUpperDistance[nextSlotIdx]         = std::numeric_limits<float>::max();
        outData.mVisibilityFlags[nextSlotIdx]       = DiTransformUnit::GetDefaultVisibilityFlags();
        outData.mQueryFlags[nextSlotIdx]            = DiTransformUnit::GetDefaultQueryFlags();
        outData.mLightMask[nextSlotIdx]             = 0xFFFFFFFF;
    }