Bump OculusVR RIFT SDK to 0.4.4

1 files changed, 86 insertions, 82 deletions

diff --git a/LibOVR/Src/Kernel/OVR_Array.h b/LibOVR/Src/Kernel/OVR_Array.h
index 7a715ba..7855a5b 100644
--- a/LibOVR/Src/Kernel/OVR_Array.h
+++ b/LibOVR/Src/Kernel/OVR_Array.h
@@ -1,21 +1,21 @@
 /************************************************************************************
 
-PublicHeader:   OVR.h
+PublicHeader:   OVR_Kernel.h
 Filename    :   OVR_Array.h
 Content     :   Template implementation for Array
 Created     :   September 19, 2012
 Notes       : 
 
-Copyright   :   Copyright 2014 Oculus VR, Inc. All Rights reserved.
+Copyright   :   Copyright 2014 Oculus VR, LLC All Rights reserved.
 
-Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); 
+Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); 
 you may not use the Oculus VR Rift SDK except in compliance with the License, 
 which is provided at the time of installation or download, or which 
 otherwise accompanies this software in either electronic or hard copy form.
 
 You may obtain a copy of the License at
 
-http://www.oculusvr.com/licenses/LICENSE-3.1 
+http://www.oculusvr.com/licenses/LICENSE-3.2 
 
 Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
 distributed under the License is distributed on an "AS IS" BASIS,
@@ -44,14 +44,14 @@ struct ArrayDefaultPolicy
     ArrayDefaultPolicy() : Capacity(0) {}
     ArrayDefaultPolicy(const ArrayDefaultPolicy&) : Capacity(0) {}
 
-    UPInt GetMinCapacity() const { return 0; }
-    UPInt GetGranularity() const { return 4; }
+    size_t GetMinCapacity() const { return 0; }
+    size_t GetGranularity() const { return 4; }
     bool  NeverShrinking() const { return 0; }
 
-    UPInt GetCapacity()    const      { return Capacity; }
-    void  SetCapacity(UPInt capacity) { Capacity = capacity; }
+    size_t GetCapacity()    const      { return Capacity; }
+    void  SetCapacity(size_t capacity) { Capacity = capacity; }
 private:
-    UPInt Capacity;
+    size_t Capacity;
 };
 
 
@@ -68,14 +68,14 @@ struct ArrayConstPolicy
     ArrayConstPolicy() : Capacity(0) {}
     ArrayConstPolicy(const SelfType&) : Capacity(0) {}
 
-    UPInt GetMinCapacity() const { return MinCapacity; }
-    UPInt GetGranularity() const { return Granularity; }
+    size_t GetMinCapacity() const { return MinCapacity; }
+    size_t GetGranularity() const { return Granularity; }
     bool  NeverShrinking() const { return NeverShrink; }
 
-    UPInt GetCapacity()    const      { return Capacity; }
-    void  SetCapacity(UPInt capacity) { Capacity = capacity; }
+    size_t GetCapacity()    const      { return Capacity; }
+    void  SetCapacity(size_t capacity) { Capacity = capacity; }
 private:
-    UPInt Capacity;
+    size_t Capacity;
 };
 
 //-----------------------------------------------------------------------------------
@@ -103,7 +103,7 @@ struct ArrayDataBase
         Allocator::Free(Data);
     }
 
-    UPInt GetCapacity() const 
+    size_t GetCapacity() const 
     { 
         return Policy.GetCapacity(); 
     }
@@ -117,7 +117,7 @@ struct ArrayDataBase
         Policy.SetCapacity(0);
     }
 
-    void Reserve(UPInt newCapacity)
+    void Reserve(size_t newCapacity)
     {
         if (Policy.NeverShrinking() && newCapacity < GetCapacity())
             return;
@@ -137,7 +137,7 @@ struct ArrayDataBase
         }
         else
         {
-            UPInt gran = Policy.GetGranularity();
+            size_t gran = Policy.GetGranularity();
             newCapacity = (newCapacity + gran - 1) / gran * gran;
             if (Data)
             {
@@ -148,7 +148,7 @@ struct ArrayDataBase
                 else
                 {
                     T* newData = (T*)Allocator::Alloc(sizeof(T) * newCapacity);
-                    UPInt i, s;
+                    size_t i, s;
                     s = (Size < newCapacity) ? Size : newCapacity;
                     for (i = 0; i < s; ++i)
                     {
@@ -176,9 +176,9 @@ struct ArrayDataBase
     // This version of Resize DOES NOT construct the elements.
     // It's done to optimize PushBack, which uses a copy constructor 
     // instead of the default constructor and assignment
-    void ResizeNoConstruct(UPInt newSize)
+    void ResizeNoConstruct(size_t newSize)
     {
-        UPInt oldSize = Size;
+        size_t oldSize = Size;
 
         if (newSize < oldSize)
         {
@@ -199,7 +199,7 @@ struct ArrayDataBase
     }
 
     ValueType*  Data;
-    UPInt       Size;
+    size_t      Size;
     SizePolicy  Policy;
 };
 
@@ -222,16 +222,16 @@ struct ArrayData : ArrayDataBase<T, Allocator, SizePolicy>
     ArrayData()
         : BaseType() { }
 
-    ArrayData(UPInt size)
+    ArrayData(size_t size)
         : BaseType() { Resize(size); }
 
     ArrayData(const SelfType& a)
         : BaseType(a.Policy) { Append(a.Data, a.Size); }
 
 
-    void Resize(UPInt newSize)
+    void Resize(size_t newSize)
     {
-        UPInt oldSize = this->Size;
+        size_t oldSize = this->Size;
         BaseType::ResizeNoConstruct(newSize);
         if(newSize > oldSize)
             Allocator::ConstructArray(this->Data + oldSize, newSize - oldSize);
@@ -240,6 +240,7 @@ struct ArrayData : ArrayDataBase<T, Allocator, SizePolicy>
     void PushBack(const ValueType& val)
     {
         BaseType::ResizeNoConstruct(this->Size + 1);
+        OVR_ASSERT(this->Data != NULL);
         Allocator::Construct(this->Data + this->Size - 1, val);
     }
 
@@ -251,11 +252,11 @@ struct ArrayData : ArrayDataBase<T, Allocator, SizePolicy>
     }
 
     // Append the given data to the array.
-    void Append(const ValueType other[], UPInt count)
+    void Append(const ValueType other[], size_t count)
     {
         if (count)
         {
-            UPInt oldSize = this->Size;
+            size_t oldSize = this->Size;
             BaseType::ResizeNoConstruct(this->Size + count);
             Allocator::ConstructArray(this->Data + oldSize, count, other);
         }
@@ -281,16 +282,16 @@ struct ArrayDataCC : ArrayDataBase<T, Allocator, SizePolicy>
     ArrayDataCC(const ValueType& defval)
         : BaseType(), DefaultValue(defval) { }
 
-    ArrayDataCC(const ValueType& defval, UPInt size)
+    ArrayDataCC(const ValueType& defval, size_t size)
         : BaseType(), DefaultValue(defval) { Resize(size); }
 
     ArrayDataCC(const SelfType& a)
         : BaseType(a.Policy), DefaultValue(a.DefaultValue) { Append(a.Data, a.Size); }
 
 
-    void Resize(UPInt newSize)
+    void Resize(size_t newSize)
     {
-        UPInt oldSize = this->Size;
+        size_t oldSize = this->Size;
         BaseType::ResizeNoConstruct(newSize);
         if(newSize > oldSize)
             Allocator::ConstructArray(this->Data + oldSize, newSize - oldSize, DefaultValue);
@@ -310,11 +311,11 @@ struct ArrayDataCC : ArrayDataBase<T, Allocator, SizePolicy>
     }
 
     // Append the given data to the array.
-    void Append(const ValueType other[], UPInt count)
+    void Append(const ValueType other[], size_t count)
     {
         if (count)
         {
-            UPInt oldSize = this->Size;
+            size_t oldSize = this->Size;
             BaseType::ResizeNoConstruct(this->Size + count);
             Allocator::ConstructArray(this->Data + oldSize, count, other);
         }
@@ -359,64 +360,65 @@ public:
 
     ArrayBase()
         : Data() {}
-    ArrayBase(UPInt size)
+    ArrayBase(size_t size)
         : Data(size) {}
     ArrayBase(const SelfType& a)
         : Data(a.Data) {}
 
     ArrayBase(const ValueType& defval)
         : Data(defval) {}
-    ArrayBase(const ValueType& defval, UPInt size)
+    ArrayBase(const ValueType& defval, size_t size)
         : Data(defval, size) {}
   
     SizePolicyType* GetSizePolicy() const                  { return Data.Policy; }
     void            SetSizePolicy(const SizePolicyType& p) { Data.Policy = p; }
 
     bool    NeverShrinking()const       { return Data.Policy.NeverShrinking(); }
-    UPInt   GetSize()       const       { return Data.Size;  }
-    bool    IsEmpty()       const       { return Data.Size == 0; }
-    UPInt   GetCapacity()   const       { return Data.GetCapacity(); }
-    UPInt   GetNumBytes()   const       { return Data.GetCapacity() * sizeof(ValueType); }
+	size_t  GetSize()       const       { return Data.Size; }
+	int     GetSizeI()      const       { return (int)Data.Size; }
+	bool    IsEmpty()       const       { return Data.Size == 0; }
+    size_t  GetCapacity()   const       { return Data.GetCapacity(); }
+    size_t  GetNumBytes()   const       { return Data.GetCapacity() * sizeof(ValueType); }
 
     void    ClearAndRelease()           { Data.ClearAndRelease(); }
     void    Clear()                     { Data.Resize(0); }
-    void    Resize(UPInt newSize)       { Data.Resize(newSize); }
+    void    Resize(size_t newSize)       { Data.Resize(newSize); }
 
     // Reserve can only increase the capacity
-    void    Reserve(UPInt newCapacity)  
+    void    Reserve(size_t newCapacity)  
     { 
         if (newCapacity > Data.GetCapacity())
             Data.Reserve(newCapacity); 
     }
 
     // Basic access.
-    ValueType& At(UPInt index)
+    ValueType& At(size_t index)
     {
-        OVR_ASSERT(index < Data.Size);
-        return Data.Data[index]; 
+        OVR_ASSERT((Data.Data) && (index < Data.Size)); // Asserting that Data.Data is valid helps static analysis tools.
+        return Data.Data[index];
     }
-    const ValueType& At(UPInt index) const
+    const ValueType& At(size_t index) const
     {
-        OVR_ASSERT(index < Data.Size);
-        return Data.Data[index]; 
+        OVR_ASSERT((Data.Data) && (index < Data.Size));
+        return Data.Data[index];
     }
 
-    ValueType ValueAt(UPInt index) const
+    ValueType ValueAt(size_t index) const
     {
-        OVR_ASSERT(index < Data.Size);
-        return Data.Data[index]; 
+        OVR_ASSERT((Data.Data) && (index < Data.Size));
+        return Data.Data[index];
     }
 
     // Basic access.
-    ValueType& operator [] (UPInt index)
+    ValueType& operator [] (size_t index)
     {
-        OVR_ASSERT(index < Data.Size);
+        OVR_ASSERT((Data.Data) && (index < Data.Size));
         return Data.Data[index]; 
     }
-    const ValueType& operator [] (UPInt index) const
+    const ValueType& operator [] (size_t index) const
     {
-        OVR_ASSERT(index < Data.Size);
-        return Data.Data[index]; 
+        OVR_ASSERT((Data.Data) && (index < Data.Size));
+        return Data.Data[index];
     }
 
     // Raw pointer to the data. Use with caution!
@@ -440,7 +442,7 @@ public:
     }
 
     // Remove the last element.
-    void    PopBack(UPInt count = 1)
+    void    PopBack(size_t count = 1)
     {
         OVR_ASSERT(Data.Size >= count);
         Data.Resize(Data.Size - count);
@@ -454,6 +456,7 @@ public:
 
     ValueType Pop()
     {
+        OVR_ASSERT((Data.Data) && (Data.Size > 0));
         ValueType t = Back();
         PopBack();
         return t;
@@ -472,14 +475,15 @@ public:
     const SelfType& operator = (const SelfType& a)   
     {
         Resize(a.GetSize());
-        for (UPInt i = 0; i < Data.Size; i++) {
+        OVR_ASSERT((Data.Data != NULL) || (Data.Size == 0));
+        for (size_t i = 0; i < Data.Size; i++) {
             *(Data.Data + i) = a[i];
         }
         return *this;
     }
 
     // Removing multiple elements from the array.
-    void    RemoveMultipleAt(UPInt index, UPInt num)
+    void    RemoveMultipleAt(size_t index, size_t num)
     {
         OVR_ASSERT(index + num <= Data.Size);
         if (Data.Size == num)
@@ -502,9 +506,9 @@ public:
     // If order of elements in the array is not important then use 
     // RemoveAtUnordered, that could be much faster than the regular
     // RemoveAt.
-    void    RemoveAt(UPInt index)
+    void    RemoveAt(size_t index)
     {
-        OVR_ASSERT(index < Data.Size);
+        OVR_ASSERT((Data.Data) && (index < Data.Size));
         if (Data.Size == 1)
         {
             Clear();
@@ -523,9 +527,9 @@ public:
     // Removes an element from the array without respecting of original order of 
     // elements for better performance. Do not use on array where order of elements
     // is important, otherwise use it instead of regular RemoveAt().
-    void    RemoveAtUnordered(UPInt index)
+    void    RemoveAtUnordered(size_t index)
     {
-        OVR_ASSERT(index < Data.Size);
+        OVR_ASSERT((Data.Data) && (index < Data.Size));
         if (Data.Size == 1)
         {
             Clear();
@@ -535,7 +539,7 @@ public:
             // copy the last element into the 'index' position 
             // and decrement the size (instead of moving all elements
             // in [index + 1 .. size - 1] range).
-            const UPInt lastElemIndex = Data.Size - 1;
+            const size_t lastElemIndex = Data.Size - 1;
             if (index < lastElemIndex)
             {
                 AllocatorType::Destruct(Data.Data + index);
@@ -547,7 +551,7 @@ public:
     }
 
     // Insert the given object at the given index shifting all the elements up.
-    void    InsertAt(UPInt index, const ValueType& val = ValueType())
+    void    InsertAt(size_t index, const ValueType& val = ValueType())
     {
         OVR_ASSERT(index <= Data.Size);
 
@@ -563,7 +567,7 @@ public:
     }
 
     // Insert the given object at the given index shifting all the elements up.
-    void    InsertMultipleAt(UPInt index, UPInt num, const ValueType& val = ValueType())
+    void    InsertMultipleAt(size_t index, size_t num, const ValueType& val = ValueType())
     {
         OVR_ASSERT(index <= Data.Size);
 
@@ -575,7 +579,7 @@ public:
                 Data.Data + index,
                 Data.Size - num - index);
         }
-        for (UPInt i = 0; i < num; ++i)
+        for (size_t i = 0; i < num; ++i)
             AllocatorType::Construct(Data.Data + index + i, val);
     }
 
@@ -586,7 +590,7 @@ public:
     }
 
     // Append the given data to the array.
-    void    Append(const ValueType other[], UPInt count)
+    void    Append(const ValueType other[], size_t count)
     {
         Data.Append(other, count);
     }
@@ -594,11 +598,11 @@ public:
     class Iterator
     {
         SelfType*       pArray;
-        SPInt           CurIndex;
+        intptr_t        CurIndex;
 
     public:
         Iterator() : pArray(0), CurIndex(-1) {}
-        Iterator(SelfType* parr, SPInt idx = 0) : pArray(parr), CurIndex(idx) {}
+        Iterator(SelfType* parr, intptr_t idx = 0) : pArray(parr), CurIndex(idx) {}
 
         bool operator==(const Iterator& it) const { return pArray == it.pArray && CurIndex == it.CurIndex; }
         bool operator!=(const Iterator& it) const { return pArray != it.pArray || CurIndex != it.CurIndex; }
@@ -607,7 +611,7 @@ public:
         {
             if (pArray)
             {
-                if (CurIndex < (SPInt)pArray->GetSize())
+                if (CurIndex < (intptr_t)pArray->GetSize())
                     ++CurIndex;
             }
             return *this;
@@ -641,7 +645,7 @@ public:
         {
             return Iterator(pArray, CurIndex - delta);
         }
-        SPInt operator-(const Iterator& right) const
+        intptr_t operator-(const Iterator& right) const
         {
             OVR_ASSERT(pArray == right.pArray);
             return CurIndex - right.CurIndex;
@@ -658,21 +662,21 @@ public:
                 pArray->RemoveAt(CurIndex);
         }
 
-        SPInt GetIndex() const { return CurIndex; }
+        intptr_t GetIndex() const { return CurIndex; }
     };
 
     Iterator Begin() { return Iterator(this); }
-    Iterator End()   { return Iterator(this, (SPInt)GetSize()); }
-    Iterator Last()  { return Iterator(this, (SPInt)GetSize() - 1); }
+    Iterator End()   { return Iterator(this, (intptr_t)GetSize()); }
+    Iterator Last()  { return Iterator(this, (intptr_t)GetSize() - 1); }
 
     class ConstIterator
     {
         const SelfType* pArray;
-        SPInt           CurIndex;
+        intptr_t        CurIndex;
 
     public:
         ConstIterator() : pArray(0), CurIndex(-1) {}
-        ConstIterator(const SelfType* parr, SPInt idx = 0) : pArray(parr), CurIndex(idx) {}
+        ConstIterator(const SelfType* parr, intptr_t idx = 0) : pArray(parr), CurIndex(idx) {}
 
         bool operator==(const ConstIterator& it) const { return pArray == it.pArray && CurIndex == it.CurIndex; }
         bool operator!=(const ConstIterator& it) const { return pArray != it.pArray || CurIndex != it.CurIndex; }
@@ -715,7 +719,7 @@ public:
         {
             return ConstIterator(pArray, CurIndex - delta);
         }
-        SPInt operator-(const ConstIterator& right) const
+        intptr_t operator-(const ConstIterator& right) const
         {
             OVR_ASSERT(pArray == right.pArray);
             return CurIndex - right.CurIndex;
@@ -726,11 +730,11 @@ public:
 
         bool IsFinished() const { return !pArray || CurIndex < 0 || CurIndex >= (int)pArray->GetSize(); }
 
-        SPInt GetIndex()  const { return CurIndex; }
+        intptr_t GetIndex()  const { return CurIndex; }
     };
     ConstIterator Begin() const { return ConstIterator(this); }
-    ConstIterator End() const   { return ConstIterator(this, (SPInt)GetSize()); }
-    ConstIterator Last() const  { return ConstIterator(this, (SPInt)GetSize() - 1); }
+    ConstIterator End() const   { return ConstIterator(this, (intptr_t)GetSize()); }
+    ConstIterator Last() const  { return ConstIterator(this, (intptr_t)GetSize() - 1); }
 
 protected:
     ArrayData   Data;
@@ -754,7 +758,7 @@ public:
     typedef ArrayBase<ArrayData<T, ContainerAllocator<T>, SizePolicy> > BaseType;
 
     Array() : BaseType() {}
-    Array(UPInt size) : BaseType(size) {}
+    Array(size_t size) : BaseType(size) {}
     Array(const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
     Array(const SelfType& a) : BaseType(a) {}
     const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }
@@ -776,7 +780,7 @@ public:
     typedef ArrayBase<ArrayData<T, ContainerAllocator_POD<T>, SizePolicy> > BaseType;
 
     ArrayPOD() : BaseType() {}
-    ArrayPOD(UPInt size) : BaseType(size) {}
+    ArrayPOD(size_t size) : BaseType(size) {}
     ArrayPOD(const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
     ArrayPOD(const SelfType& a) : BaseType(a) {}
     const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }
@@ -798,7 +802,7 @@ public:
     typedef ArrayBase<ArrayData<T, ContainerAllocator_CPP<T>, SizePolicy> > BaseType;
 
     ArrayCPP() : BaseType() {}
-    ArrayCPP(UPInt size) : BaseType(size) {}
+    ArrayCPP(size_t size) : BaseType(size) {}
     ArrayCPP(const SizePolicyType& p) : BaseType() { SetSizePolicy(p); }
     ArrayCPP(const SelfType& a) : BaseType(a) {}
     const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }
@@ -822,7 +826,7 @@ public:
     typedef ArrayBase<ArrayDataCC<T, ContainerAllocator<T>, SizePolicy> >   BaseType;
 
     ArrayCC(const ValueType& defval) : BaseType(defval) {}
-    ArrayCC(const ValueType& defval, UPInt size) : BaseType(defval, size) {}
+    ArrayCC(const ValueType& defval, size_t size) : BaseType(defval, size) {}
     ArrayCC(const ValueType& defval, const SizePolicyType& p) : BaseType(defval) { SetSizePolicy(p); }
     ArrayCC(const SelfType& a) : BaseType(a) {}
     const SelfType& operator=(const SelfType& a) { BaseType::operator=(a); return *this; }