statusingridbase.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/querysystem/workingmemcontainers/workingmemcontainerbase.h"
#include "gwnavruntime/database/activedata.h"
#include "gwnavruntime/containers/bitfieldutils.h"

namespace Kaim
{

struct BitFieldInBuffer
{
    BitFieldInBuffer() : m_offSet(KyUInt32MAXVAL) {}

    KyUInt32* GetWords() const { return (KyUInt32*)((char*)this + m_offSet); }
    void SetWords(KyUInt32* words) { m_offSet = (KyUInt32)((char*)words - (char*)(this)); }

    bool IsValid() const { return m_offSet != KyUInt32MAXVAL; }

    bool IsBitSet(KyUInt32 idx) const { return BitFieldUtils::IsBitSet(GetWords(), idx); }
    void SetBit(KyUInt32 idx) const { BitFieldUtils::SetBit(GetWords(), idx); }

private:
    KyUInt32 m_offSet; // relative to this &m_offSet == this

private:
    BitFieldInBuffer(const BitFieldInBuffer&);
    BitFieldInBuffer& operator=(const BitFieldInBuffer&) { return *this; }
};

template <class T>
struct ArrayInBuffer
{
    ArrayInBuffer() : m_offSet(KyUInt32MAXVAL) {}

    T* GetArrayData() const { return (T*)((char*)this + m_offSet); }
    void SetArrayData(T* buffer) { m_offSet = (KyUInt32)((char*)buffer - (char*)(this)); }

    bool IsValid() const { return m_offSet != KyUInt32MAXVAL; }

    T*       Get(KyUInt32 idx)       { return GetArrayData() + idx; }
    const T* Get(KyUInt32 idx) const { return GetArrayData() + idx; }

private:
    KyUInt32 m_offSet; // relative to this &m_offSet == this

private:
    ArrayInBuffer(const ArrayInBuffer<T>&);
    ArrayInBuffer& operator=(const ArrayInBuffer<T>&) { return *this; }
};



// Used as implementation detail of TriangleStatusInGrid and NavFloorAndNavGraphEdgeStatusInGrid
// This functionality should be put directly in the WorkingMemContainerBase (WorkingMemBuffer)
class AllocatorBuffer
{
public:
    AllocatorBuffer() {}

    AllocatorBuffer(WorkingMemory* workingMemory)
    {
        m_buffer.Init(workingMemory);
        m_allocatedSize = 0;
    }

    void Init(WorkingMemory* workingMemory)
    {
        m_buffer.Init(workingMemory);
        m_allocatedSize = 0;
    }

    void ReleaseWorkingMemoryBuffer() { m_buffer.ReleaseBuffer(); }

    void* AllocInBuffer(KyUInt32 sizeOfOneElementInBytes, KyUInt32 numberOfElements, KyUInt8 memsetValue)
    {
        KY_DEBUG_ASSERTN(sizeOfOneElementInBytes % 4 == 0, ("AllocateInBufferAndMemset only accepts sizeOfOneElementInBytes that are mulptiples of 4"));

        const KyUInt32 deltaSize = sizeOfOneElementInBytes * numberOfElements;
        const KyUInt32 newAllocatedSize = m_allocatedSize + deltaSize;

        if (m_buffer.Realloc(m_allocatedSize, newAllocatedSize) == nullptr)
            return nullptr;

        char* ptr = GetDataPtr() + m_allocatedSize;

        memset(ptr, memsetValue, deltaSize);

        m_allocatedSize = newAllocatedSize;
        return ptr;
    }

    template<typename T>
    T* AllocInBuffer(KyUInt32 count, KyUInt8 memsetValue)
    {
        return (T*)AllocInBuffer(sizeof(T), count, memsetValue); // ugly, let's use T() ctr to init the memory
    }


    KyUInt32* AllocBitFieldWords(KyUInt32 bitCount)
    {
        return (KyUInt32*)AllocInBuffer(sizeof(KyUInt32), BitFieldUtils::GetWordsCount(bitCount), 0);
    }

    char* GetDataPtr() const { return m_buffer.GetDataPtr(); }

    bool IsInitialized() const { return m_buffer.IsInitialized(); }

    KyUInt32 GetOffset(void* ptr) const { return (KyUInt32)((char*)ptr - GetDataPtr()); }

    template<typename T>
    T* GetPtr(KyUInt32 offset) const { return (T*)(GetDataPtr() + offset); }

public:
    WorkingMemContainerBase m_buffer;
    KyUInt32 m_allocatedSize; // in m_buffer
};



}