LeapUtil.h

Go to the documentation of this file.

/******************************************************************************\
* Copyright (C) Leap Motion, Inc. 2011-2013.                                   *
* Leap Motion proprietary and  confidential.  Not for distribution.            *
* Use subject to the terms of the Leap Motion SDK Agreement available at       *
* https://developer.leapmotion.com/sdk_agreement, or another agreement between *
* Leap Motion and you, your company or other organization.                     *
\******************************************************************************/

#ifndef __LeapUtil_h__
#define __LeapUtil_h__

#include "Leap.h"

// Define integer types for Visual Studio 2005
#if defined(_MSC_VER) && (_MSC_VER < 1600)
typedef __int8 int8_t;
typedef __int16 int16_t;
typedef unsigned __int8 uint8_t;
typedef unsigned __int16 uint16_t;
#endif

namespace LeapUtil {



static const float kfPi       = Leap::PI;
static const float kf2Pi      = kfPi + kfPi;
static const float kfHalfPi   = kfPi * 0.5f;
static const float kfEpsilon  = 0.00001f;

template<typename T>
T Min( T lhs, T rhs )
{
  return lhs < rhs ? lhs : rhs;
}

template<typename T>
T Max( T lhs, T rhs )
{
  return lhs > rhs ? lhs : rhs;
}

template<typename T>
T Clamp( T inVal, T minVal, T maxVal )
{
  return (inVal < minVal) ? minVal : ((inVal > maxVal) ? maxVal : inVal);
}

template<typename InterpType, typename ParamType>
InterpType Linterp( InterpType a, InterpType b, ParamType t )
{
  return a + static_cast<InterpType>((b - a) * t);
}

template<class Vec2>
Leap::Vector FromVector2( const Vec2& vIn, float fZ = 0.0f )
{
  return Leap::Vector( static_cast<float>(vIn.x), static_cast<float>(vIn.y), fZ );
}

template<class Vec3>
Leap::Vector FromVector3( const Vec3& vIn )
{
  return Leap::Vector( static_cast<float>(vIn.x), static_cast<float>(vIn.y), static_cast<float>(vIn.z) );
}

inline bool IsNearZero( float fVal )
{
 return fabs(fVal) <= kfEpsilon;
}

inline bool IsNearZero( const Leap::Vector& vVec )
{
  return IsNearZero(vVec.x) && IsNearZero(vVec.y) && IsNearZero(vVec.z);
}

template<typename T>
inline bool IsNearEqual( const T& a, const T& b )
{
  return IsNearZero( a - b );
}

inline Leap::Matrix ExtractRotation( const Leap::Matrix& mtxTransform )
{
  return Leap::Matrix( mtxTransform.xBasis, mtxTransform.yBasis, mtxTransform.zBasis );
}

inline Leap::Matrix RotationInverse( const Leap::Matrix& mtxRot )
{
  return Leap::Matrix(  Leap::Vector( mtxRot.xBasis.x, mtxRot.yBasis.x, mtxRot.zBasis.x ),
                        Leap::Vector( mtxRot.xBasis.y, mtxRot.yBasis.y, mtxRot.zBasis.y ),
                        Leap::Vector( mtxRot.xBasis.z, mtxRot.yBasis.z, mtxRot.zBasis.z ) );
}

inline Leap::Matrix RigidInverse( const Leap::Matrix& mtxTransform )
{
  Leap::Matrix  rigidInverse = RotationInverse( mtxTransform );
  rigidInverse.origin  = rigidInverse.transformDirection( -mtxTransform.origin );
  return rigidInverse;
}

inline Leap::Vector ComponentWiseMin( const Leap::Vector& vLHS, const Leap::Vector& vRHS )
{
  return Leap::Vector( Min( vLHS.x, vRHS.x ), Min( vLHS.y, vRHS.y ), Min( vLHS.z, vRHS.z ) );
}

inline Leap::Vector ComponentWiseMax( const Leap::Vector& vLHS, const Leap::Vector& vRHS )
{
  return Leap::Vector( Max( vLHS.x, vRHS.x ), Max( vLHS.y, vRHS.y ), Max( vLHS.z, vRHS.z ) );
}

inline Leap::Vector ComponentWiseScale( const Leap::Vector& vLHS, const Leap::Vector& vRHS )
{
  return Leap::Vector( vLHS.x * vRHS.x, vLHS.y * vRHS.y, vLHS.z * vRHS.z );
}

inline Leap::Vector ComponentWiseReciprocal( const Leap::Vector& vVec )
{
  return Leap::Vector( 1.0f/vVec.x, 1.0f/vVec.y, 1.0f/vVec.z );
}

inline float MinComponent( const Leap::Vector& vVec )
{
  return Min( vVec.x, Min( vVec.y, vVec.z ) );
}

inline float MaxComponent( const Leap::Vector& vVec )
{
  return Max( vVec.x, Max( vVec.y, vVec.z ) );
}

inline float Heading( const Leap::Vector& vVec )
{
  return atan2f( vVec.z, vVec.x );
}

inline float Elevation( const Leap::Vector& vVec )
{
  return atan2f( vVec.y, sqrtf(vVec.z * vVec.z + vVec.x * vVec.x) );
}

inline Leap::Vector CartesianToSpherical( const Leap::Vector& vCartesian )
{
  return Leap::Vector( vCartesian.magnitude(), Heading(vCartesian), Elevation(vCartesian) );
}

inline Leap::Vector NormalizeSpherical( const Leap::Vector& vSpherical )
{
  float fHeading  = vSpherical.y;
  float fElevation = vSpherical.z;

  for ( ; fElevation <= -kfPi; fElevation += kf2Pi );
  for ( ; fElevation > kfPi; fElevation -= kf2Pi );

  if ( fabs(fElevation) > kfHalfPi )
  {
    fHeading += kfPi;
    fElevation = fElevation > 0 ? (kfPi - fElevation) : -(kfPi + fElevation);
  }

  for ( ; fHeading <= -kfPi; fHeading += kf2Pi );
  for ( ; fHeading > kfPi; fHeading -= kf2Pi );

  return Leap::Vector( 1, fHeading, fElevation );
}

inline Leap::Vector SphericalToCartesian( const Leap::Vector& vSpherical )
{
  const float fMagnitude    = vSpherical.x;
  const float fCosHeading   = cosf( vSpherical.y );
  const float fSinHeading   = sinf( vSpherical.y );
  const float fCosElevation = cosf( vSpherical.z );
  const float fSinElevation = sinf( vSpherical.z );

  return Leap::Vector(  fCosHeading   * fCosElevation  * fMagnitude,
                                        fSinElevation  * fMagnitude,
                        fSinHeading   * fCosElevation  * fMagnitude);
}

inline const char* BoolToStr( uint32_t bVal )
{
  return bVal ? "On" : "Off";
}

template<int _HistoryLength=256>
class RollingAverage
{
public:
  enum
  {
    kHistoryLength = _HistoryLength
  };

public:
  RollingAverage() { Reset(); }

  void Reset()
  {
    m_uiCurIndex  = 0;
    m_fNumSamples = 0.0f;
    m_fSum        = 0.0f;
    m_fAverage    = 0.0f;
    for ( int i = 0; i < kHistoryLength; m_afSamples[i++] = 0.0f );
  }

  float AddSample( float fSample )
  {
    m_fNumSamples =   Min( (m_fNumSamples + 1.0f), static_cast<float>(kHistoryLength) );
    m_fSum        -=  m_afSamples[m_uiCurIndex];
    m_fSum        +=  fSample;
    m_fAverage    =   m_fSum * (1.0f/m_fNumSamples);

    m_afSamples[m_uiCurIndex] = fSample;

    m_uiCurIndex = static_cast<uint32_t>((m_uiCurIndex + 1) % kHistoryLength);

    return m_fAverage;
  }

  float     GetAverage()    const { return m_fAverage; }
  float     GetSum()        const { return m_fSum; }
  uint32_t  GetNumSamples() const { return static_cast<uint32_t>(m_fNumSamples); }

  float     operator[](uint32_t uiIdx) const { return m_afSamples[(m_uiCurIndex + uiIdx) % kHistoryLength]; }

private:
  uint32_t      m_uiCurIndex;
  float         m_fNumSamples;
  float         m_fSum;
  float         m_fAverage;
  float         m_afSamples[kHistoryLength];
};

class Camera
{
public:
  Camera()
    : m_fOrbitDistance(-1.0f),
      m_fMaxOrbitLatitude( LeapUtil::kfPi * 0.375f ),
      m_fNearClip( 0.1f ),
      m_fFarClip( 128.0f ),
      m_fVerticalFOVDegrees( 40.0f ),
      m_fAspectRatio( 4.0f/3.0f )
  {}

  const Leap::Matrix& GetPOV() const { return m_mtxPOV; }

  void SetPOV( const Leap::Matrix& mtxPOV ) { m_mtxPOV = mtxPOV; }

  Leap::Matrix GetView() const { return LeapUtil::RigidInverse(m_mtxPOV); }

  const Leap::Vector& GetPosition() const { return m_mtxPOV.origin; }

  void SetPosition( const Leap::Vector& vPos ) { m_mtxPOV.origin = vPos; }

  Leap::Matrix GetRotation() const { return LeapUtil::ExtractRotation(m_mtxPOV); }

  void SetRotation( const Leap::Vector& vAxis, float fRadians ) { m_mtxPOV.setRotation( vAxis, fRadians ); }

  void SetRotation( const Leap::Matrix& mtxRot )
  {
    m_mtxPOV.xBasis = mtxRot.xBasis;
    m_mtxPOV.yBasis = mtxRot.yBasis;
    m_mtxPOV.zBasis = mtxRot.zBasis;
  }

  void SetPOVLookAt( const Leap::Vector& vCameraPosition, const Leap::Vector& vTarget, Leap::Vector vUp = Leap::Vector::yAxis() );

  void SetRotationLookAt( const Leap::Vector& vTarget, const Leap::Vector& vUp = Leap::Vector::yAxis() )
  {
    SetPOVLookAt( m_mtxPOV.origin, vTarget, vUp );
  }

  void Move( const Leap::Vector& vDeltaPos )
  {
    m_mtxPOV.origin += vDeltaPos;
  }

  void Rotate( const Leap::Matrix& mtxRotation )
  {
    m_mtxPOV = m_mtxPOV * LeapUtil::ExtractRotation(mtxRotation);
  }

  void Rotate( const Leap::Vector& vAxis, float fRadians )
  {
    m_mtxPOV = m_mtxPOV * Leap::Matrix( vAxis, fRadians );
  }

  const Leap::Vector& GetOrbitTarget() const
  {
    return m_vOrbitTarget;
  }

  void SetOrbitTarget( const Leap::Vector& vOrbitTarget)
  {
    m_vOrbitTarget = vOrbitTarget;
    updateOrbitDistance();
  }

  void RotateOrbit( float fDeltaMagnitude, float fDeltaLongitude, float fDeltaLatitude );

  float GetMaxOrbitLatitude() const
  {
    return m_fMaxOrbitLatitude;
  }

  void SetMaxOrbitLatitude( float fMaxOrbitLatitude )
  {
    m_fMaxOrbitLatitude = fMaxOrbitLatitude;
  }

  float CalcViewDepth( const Leap::Vector& vPos ) const
  {
    return m_mtxPOV.zBasis.dot( m_mtxPOV.origin - vPos );
  }


  void OnMouseWheel( float fDeltaZ );

  void OnMouseDown( const Leap::Vector& vMousePos );

  void OnMouseMoveOrbit( const Leap::Vector& vMousePos );

  float GetNearClip() const { return m_fNearClip; }

  float GetFarClip() const { return m_fFarClip; }

  void SetNearClip( float fNearClip ) { m_fNearClip = Max( 0.01f, fNearClip ); }

  void SetFarClip( float fFarClip ) { m_fFarClip = fFarClip; }

  void SetClipPlanes( float fNearClip, float fFarClip )
  {
    SetNearClip( fNearClip );
    SetFarClip( fFarClip );
  }

  float GetVerticalFOVDegrees() const { return m_fVerticalFOVDegrees; }

  void SetVerticalFOVDegrees( float fFOV ) { m_fVerticalFOVDegrees = fFOV; }

  float GetAspectRatio() const { return m_fAspectRatio; }

  void SetAspectRatio( float fAspectRatio ) { m_fAspectRatio = fAspectRatio; }

private:
  void updateOrbitDistance()
  {
    float fOrbitDistance = (m_vOrbitTarget - m_mtxPOV.origin).magnitude();

    if ( !IsNearZero( fOrbitDistance - m_fOrbitDistance ) )
    {
      m_fOrbitDistance  = fOrbitDistance;
    }
  }

private:
  Leap::Matrix  m_mtxPOV;
  Leap::Vector  m_vLastMousePos;
  Leap::Vector  m_vOrbitTarget;
  float         m_fOrbitDistance;
  float         m_fMaxOrbitLatitude;
  float         m_fNearClip;
  float         m_fFarClip;
  float         m_fVerticalFOVDegrees;
  float         m_fAspectRatio;
};


class ScrollMomentum {
public:
  ScrollMomentum()
    : m_vDirection(Leap::Vector::yAxis()),
      m_fScrollSize(512.0f),
      m_fSpeed(0),
      m_fMinSpeed(0.125f),
      m_fDrag(0.4f),
      m_fDragPower(2.0f),
      m_fFixedTimeStep(1.0f/60.0f),
      m_fPendingDeltaTime(0.0f)
  {}

  const Leap::Vector& getPosition() const                             { return m_vPosition; }
  void                setPosition( const Leap::Vector& vPosition )    { m_vPosition = vPosition; }

  const Leap::Vector& getDirection() const                            { return m_vDirection; }
  void                setDirection( const Leap::Vector& vDirection )  { m_vDirection = vDirection.normalized(); }

  float               getScrollSize() const                                 { return m_fScrollSize; }
  void                setScrollSize( float fScrollSize )                    { m_fScrollSize = (fScrollSize > 0.0f ? fScrollSize : 1.0f); }

  float               getSpeed() const                                      { return m_fSpeed; }
  void                setSpeed( float fSpeed )                              { m_fSpeed = fSpeed; }

  float               getMinSpeed() const                                   { return m_fMinSpeed; }
  void                setMinSpeed( float fMinSpeed )                        { m_fMinSpeed = fabs(fMinSpeed); }

  float               getFixedTimeStep() const                              { return m_fMinSpeed; }
  void                setFixedTimeStep( float fFixedTimeStep )              { m_fFixedTimeStep = fabs(fFixedTimeStep); }

  float               getDrag() const                                       { return m_fDrag; }
  void                setDrag( float fDrag )                                { m_fDrag = fabs(fDrag); }

  float               getDragPower() const                                  { return m_fDragPower; }
  void                setDragPower( float fDragPower )                      { m_fDragPower = fDragPower; }

  const Leap::Vector  getVelocity() const                             { return m_vDirection * m_fSpeed; }

  void setVelocity( const Leap::Vector& vDirection, float fSpeed )
  {
    setDirection( vDirection );
    setSpeed( fSpeed );
  }

  void  update( float fDeltaTimeSeconds )
  {
    if ( fDeltaTimeSeconds <= 0.0f )
    {
      return;
    }

    if ( fabs(m_fSpeed) > m_fMinSpeed )
    {
      if ( m_fDrag > 0 )
      {
        // only force to fixed time step if doing drag calculation

        const float fMinScrollSpeed = m_fMinSpeed / m_fScrollSize;
        // fold the sign of speed into the scaling factor
        const float fScrollScale    = (m_fSpeed < 0.0f ? -1.0f : 1.0f) * m_fScrollSize;
        // absolute value of scaled speed (_scrollScale has same sign as speed, guaranteeing positive value)
        float fScrollSpeed          = m_fSpeed / fScrollScale;

        // include any left over time from previous update in the time to process for this update.
        fDeltaTimeSeconds += m_fPendingDeltaTime;

        // process time since last update in fixed chunks
        for ( ; fDeltaTimeSeconds >= m_fFixedTimeStep; fDeltaTimeSeconds -= m_fFixedTimeStep )
        {
          const float fDragForce = powf( fScrollSpeed, m_fDragPower ) * m_fDrag;

          // decelerate unsigned/scaled speed by drag
          fScrollSpeed -= fDragForce * m_fFixedTimeStep;

          // bail out if speed has hit minimum threshold
          if ( fScrollSpeed <= fMinScrollSpeed )
          {
            m_fSpeed = 0.0f;
            fDeltaTimeSeconds = 0.0f;
            break;
          }

          // update signed/unscaled speed
          m_fSpeed = fScrollSpeed * fScrollScale;

          // step position by velocity
          m_vPosition += m_vDirection * (m_fFixedTimeStep * m_fSpeed);
        }

        // keep track of any leftover time not processed during this update.
        m_fPendingDeltaTime = fDeltaTimeSeconds;
      }
      else
      {
        // simple position change with velocity and no drag - not affected by large time steps. no looping needed.
        m_vPosition += m_vDirection * ((m_fPendingDeltaTime + fDeltaTimeSeconds) * m_fSpeed);
        m_fPendingDeltaTime = 0.0f;
      }
    }
    else
    {
      // enforce zeroing of speeds below minimum absolute value.
      m_fSpeed = 0.0f;
      m_fPendingDeltaTime = 0.0f;
    }
  }

protected:
  Leap::Vector  m_vPosition;
  Leap::Vector  m_vDirection;
  float         m_fScrollSize;
  float         m_fSpeed;
  float         m_fMinSpeed;
  float         m_fDrag;
  float         m_fDragPower;
  float         m_fFixedTimeStep;
  float         m_fPendingDeltaTime;
};


template<typename T>
class SmartInstanceDestructor
{
public:
  static void Destroy( T* pPointer ) { delete pPointer; }
};

template<typename T>
class SmartArrayDestructor
{
public:
  static void Destroy( T* pPointer ) { delete[] pPointer; }
};

template< typename T,
          class Destructor = SmartInstanceDestructor<T>,
          unsigned int ManagedPointerPoolSize = 512 >
class SmartPointer
{
public:
  enum { kManagedPointerPoolSize = ManagedPointerPoolSize };

  typedef T ManagedType;

private:
  // a managed pointer is a pointer of the desired type plus a reference count.
  struct ManagedPointerEntry
  {
    ManagedType*  m_pPointer;
    uint32_t      m_uiRefCount;
  };

  // this private, embedded class manages a pool of smart pointers for the given type.
  // there are separate pools for each created type of smart pointer.
  // the pool is managed using a simple O(1) fixed size free list allocator
  struct ManagedPointerPool
  {
    enum { kPoolSize = kManagedPointerPoolSize, kDeadPointer = 0xdeadbea7 };

    ManagedPointerPool()
      : m_uiNextFree(0),
        m_uiNumAllocated(0)
    {
      for ( uint32_t i = 0; i < static_cast<uint32_t>(kPoolSize); i++ )
      {
        m_aEntryPool[i].m_pPointer    = reinterpret_cast<ManagedType*>(kDeadPointer);
        m_aEntryPool[i].m_uiRefCount  = i + 1;
      }
    }

    // allocate a managed pointer entry for a raw pointer
    ManagedPointerEntry* allocEntry( ManagedType* pPointer )
    {
      ManagedPointerEntry* pEntry = NULL;

      // this incurs a linear search penalty each time
      // we create a new smart pointer from a raw pointer
      // but adds significant safety - it prevents
      // assigning the same raw pointer to two different
      // member entries - this would result in double
      // deletion when the 2nd one hit its end of life.
      pEntry = findEntry( pPointer );

      if ( pEntry )
      {
        // we found an existing managed pointer entry, just increase the reference count
        pEntry->m_uiRefCount++;
      }
      else if ( (m_uiNextFree < kPoolSize) && pPointer )
      {
        // grab the next free entry from the head of the free list
        pEntry = m_aEntryPool + m_uiNextFree;

        // the head of the list now becomes the next free entry in the chain
        // (m_uiRefCount is serving double-duty as next index member for entries that are still in the pool)
        m_uiNextFree = pEntry->m_uiRefCount;

        // initialize the entry with the pointer and a reference count of 1.
        pEntry->m_pPointer = pPointer;
        pEntry->m_uiRefCount = 1;

        // book keeping.
        m_uiNumAllocated++;
      }

      return pEntry;
    }

    // return an entry to the pool
    void freeEntry( ManagedPointerEntry* pEntry )
    {
      // calculate the entry index as an offset from the start of the pool
      const uint32_t entryIndex = static_cast<uint32_t>(pEntry - m_aEntryPool);

      // if this is a valid allocated entry (from this pool, and not already freed)
      if (  (entryIndex < kPoolSize)  &&
            (m_uiNumAllocated != 0)   &&
            (pEntry->m_pPointer != reinterpret_cast<ManagedType*>(kDeadPointer)) )
      {
        // clear the entry
        pEntry->m_pPointer = NULL;

        // push it to the head of the free list
        pEntry->m_uiRefCount = m_uiNextFree;
        m_uiNextFree = entryIndex;

        // book keeping.
        m_uiNumAllocated--;
      }
    }

    // look for the managed pointer entry associated with a raw pointer. returns NULL
    // if pPointer is NULL, dead or not found.
    ManagedPointerEntry* findEntry( const ManagedType* pPointer )
    {
      // don't bother if the pointer is NULL or marked as our dead value
      if ( pPointer && (pPointer != reinterpret_cast<ManagedType*>(kDeadPointer)) )
      {
        // linear search. stop after testing as many live entries as are allocated instead of always
        // searching the entire pool.
        for ( uint32_t i = 0, j = 0; j < m_uiNumAllocated && i < static_cast<uint32_t>(kPoolSize); i++ )
        {
          // if the entry is live (allocated)
          if ( m_aEntryPool[i].m_pPointer != reinterpret_cast<ManagedType*>(kDeadPointer) )
          {
            // a match? return it.
            if ( m_aEntryPool[i].m_pPointer == pPointer )
            {
              return m_aEntryPool + i;
            }

            // not, increment the count of live entries encountered.
            j++;
          }
        }
      }

      return NULL;
    }

    // number of allocated managed pointer entries
    uint32_t getNumAllocated() const { return m_uiNumAllocated; }

    // number of available managed pointer entries.
    uint32_t getNumFree() const { return static_cast<uint32_t>(kPoolSize) - m_uiNumAllocated; }

    // actual entry pool
    ManagedPointerEntry m_aEntryPool[kPoolSize];

    // head of the free list
    uint32_t            m_uiNextFree;

    // number of entries that have been allocated from the free list
    uint32_t            m_uiNumAllocated;
  };

  // static instance of the managed pointer pool
  static ManagedPointerPool& s_pool()
  {
    static ManagedPointerPool _s_pool;
    return _s_pool;
  }

  void refInc()
  {
    if ( m_pManagedPointer )
    {
      m_pManagedPointer->m_uiRefCount++;
    }
  }

  void refDec()
  {
    if ( m_pManagedPointer )
    {
      if ( m_pManagedPointer->m_uiRefCount )
      {
        m_pManagedPointer->m_uiRefCount--;
      }

      if ( !m_pManagedPointer->m_uiRefCount )
      {
        Destructor::Destroy(m_pManagedPointer->m_pPointer);
        s_pool().freeEntry(m_pManagedPointer);
      }

      m_pManagedPointer = NULL;
    }
  }

public:
  SmartPointer()
    : m_pManagedPointer(NULL)
  {
  }

  explicit SmartPointer( ManagedType* pManaged )
    : m_pManagedPointer( s_pool().allocEntry( pManaged ) )
  {
  }

  SmartPointer( const SmartPointer& rhs )
    : m_pManagedPointer( rhs.m_pManagedPointer )
  {
    refInc();
  }

  const SmartPointer& operator =( const SmartPointer& rhs )
  {
    if ( m_pManagedPointer != rhs.m_pManagedPointer )
    {
      refDec();
      m_pManagedPointer = rhs.m_pManagedPointer;
      refInc();
    }

    return *this;
  }

  ~SmartPointer()
  {
    refDec();
  }

  ManagedType* GetPointer() const { return m_pManagedPointer ? m_pManagedPointer->m_pPointer : NULL; }

  uint32_t GetRefCount() const { return m_pManagedPointer ? m_pManagedPointer->m_uiRefCount : 0u; }

  operator ManagedType*() const { return GetPointer(); }

  ManagedType* operator ->() const { return GetPointer(); }

  operator bool() const { return m_pManagedPointer != NULL; }

  bool operator !() const { return !m_pManagedPointer; }

  bool operator ==( const ManagedType* pPointer ) const { return GetPointer() == pPointer; }

  bool operator !=( const ManagedType* pPointer ) const { return GetPointer() != pPointer; }

  bool operator ==( const SmartPointer& rhs ) const { return m_pManagedPointer == rhs.m_pManagedPointer; }

  bool operator !=( const SmartPointer& rhs ) const { return m_pManagedPointer != rhs.m_pManagedPointer; }

  void Release()
  {
    refDec();
  }

  static const SmartPointer& Null()
  {
    static SmartPointer _s_null;
    return _s_null;
  }

  static bool IsManaged( const ManagedType* pPointer )
  {
    return s_pool().findEntry( pPointer ) != NULL;
  }

  static uint32_t GetNumManagedPointers() { return s_pool().getNumAllocated(); }

private:
  ManagedPointerEntry* m_pManagedPointer;
};

} // namespace Leap

#endif // __LeapUtil_h__