From e490c3c7f7bb5461cfa78a214827aa534fb43a3e Mon Sep 17 00:00:00 2001
From: Sven Gothel <sgothel@jausoft.com>
Date: Sat, 21 Mar 2015 21:19:34 +0100
Subject: Bump OculusVR RIFT SDK to 0.4.4
---
LibOVR/Src/Kernel/OVR_Array.h | 168 +++++++++++++++++++++---------------------
1 file changed, 86 insertions(+), 82 deletions(-)
(limited to 'LibOVR/Src/Kernel/OVR_Array.h')
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; }
--
cgit v1.2.3