documentation.HELP! NVIDIA PhysX Documentation

NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsArray.h Source File

NVIDIA PhysX

previous page next page

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsArray.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.

#ifndef PSFOUNDATION_PSARRAY_H
#define PSFOUNDATION_PSARRAY_H

#include "foundation/PxAssert.h"
#include "foundation/PxIntrinsics.h"
#include "PsAllocator.h"
#include "PsBasicTemplates.h"

#if PX_LINUX || PX_ANDROID || (PX_IOS && !PX_A64) || PX_OSX 
#include <tr1/type_traits>
#elif PX_WINRT || PX_XBOXONE || (PX_IOS && PX_A64) || PX_WIN64 || PX_WIN32 || PX_PS4
#include <type_traits>
#if PX_IOS && PX_A64
namespace std { namespace tr1 { using std::is_pod; } }
#endif
#else
#error "OS with no defined path to type_traits.h"
#endif

#if PX_VC == 9 || PX_VC == 10
#pragma warning(push)
#pragma warning(disable : 4347) // behavior change: 'function template' is called instead of 'function'
#endif

namespace physx
{
namespace shdfnd
{
template <class Serializer>
void exportArray(Serializer& stream, const void* data, uint32_t size, uint32_t sizeOfElement, uint32_t capacity);
char* importArray(char* address, void** data, uint32_t size, uint32_t sizeOfElement, uint32_t capacity);

template <class T, class Alloc = typename AllocatorTraits<T>::Type>
class Array : protected Alloc
{
  public:
        typedef T* Iterator;
        typedef const T* ConstIterator;

        explicit Array(const PxEMPTY v) : Alloc(v)
        {
                if(mData)
                        mCapacity |= PX_SIGN_BITMASK;
        }

        PX_INLINE explicit Array(const Alloc& alloc = Alloc()) : Alloc(alloc), mData(0), mSize(0), mCapacity(0)
        {
        }

        PX_INLINE explicit Array(uint32_t size, const T& a = T(), const Alloc& alloc = Alloc())
        : Alloc(alloc), mData(0), mSize(0), mCapacity(0)
        {
                resize(size, a);
        }

        template <class A>
        PX_INLINE explicit Array(const Array<T, A>& other, const Alloc& alloc = Alloc())
        : Alloc(alloc)
        {
                copy(other);
        }

        // This is necessary else the basic default copy constructor is used in the case of both arrays being of the same
        // template instance
        // The C++ standard clearly states that a template constructor is never a copy constructor [2]. In other words,
        // the presence of a template constructor does not suppress the implicit declaration of the copy constructor.
        // Also never make a copy constructor explicit, or copy-initialization* will no longer work. This is because
        // 'binding an rvalue to a const reference requires an accessible copy constructor' (http://gcc.gnu.org/bugs/)
        // *http://stackoverflow.com/questions/1051379/is-there-a-difference-in-c-between-copy-initialization-and-assignment-initializ
        PX_INLINE Array(const Array& other, const Alloc& alloc = Alloc()) : Alloc(alloc)
        {
                copy(other);
        }

        PX_INLINE explicit Array(const T* first, const T* last, const Alloc& alloc = Alloc())
        : Alloc(alloc), mSize(last < first ? 0 : uint32_t(last - first)), mCapacity(mSize)
        {
                mData = allocate(mSize);
                copy(mData, mData + mSize, first);
        }

        PX_INLINE ~Array()
        {
                destroy(mData, mData + mSize);

                if(capacity() && !isInUserMemory())
                        deallocate(mData);
        }

        template <class A>
        PX_INLINE Array& operator=(const Array<T, A>& rhs)
        {
                if(&rhs == this)
                        return *this;

                clear();
                reserve(rhs.mSize);
                copy(mData, mData + rhs.mSize, rhs.mData);

                mSize = rhs.mSize;
                return *this;
        }

        PX_INLINE Array& operator=(const Array& t) // Needs to be declared, see comment at copy-constructor
        {
                return operator=<Alloc>(t);
        }

        PX_FORCE_INLINE static bool isArrayOfPOD() 
        {
#if PX_VC>=14
                return std::is_trivially_copyable<T>::value;
#else
                return std::tr1::is_pod<T>::value;
#endif
        }

        PX_FORCE_INLINE const T& operator[](uint32_t i) const
        {
                PX_ASSERT(i < mSize);
                return mData[i];
        }

        PX_FORCE_INLINE T& operator[](uint32_t i)
        {
                PX_ASSERT(i < mSize);
                return mData[i];
        }

        PX_FORCE_INLINE ConstIterator begin() const
        {
                return mData;
        }

        PX_FORCE_INLINE Iterator begin()
        {
                return mData;
        }

        PX_FORCE_INLINE ConstIterator end() const
        {
                return mData + mSize;
        }

        PX_FORCE_INLINE Iterator end()
        {
                return mData + mSize;
        }

        PX_FORCE_INLINE const T& front() const
        {
                PX_ASSERT(mSize);
                return mData[0];
        }

        PX_FORCE_INLINE T& front()
        {
                PX_ASSERT(mSize);
                return mData[0];
        }

        PX_FORCE_INLINE const T& back() const
        {
                PX_ASSERT(mSize);
                return mData[mSize - 1];
        }

        PX_FORCE_INLINE T& back()
        {
                PX_ASSERT(mSize);
                return mData[mSize - 1];
        }

        PX_FORCE_INLINE uint32_t size() const
        {
                return mSize;
        }

        PX_INLINE void clear()
        {
                destroy(mData, mData + mSize);
                mSize = 0;
        }

        PX_FORCE_INLINE bool empty() const
        {
                return mSize == 0;
        }

        PX_INLINE Iterator find(const T& a)
        {
                uint32_t index;
                for(index = 0; index < mSize && mData[index] != a; index++)
                        ;
                return mData + index;
        }

        PX_INLINE ConstIterator find(const T& a) const
        {
                uint32_t index;
                for(index = 0; index < mSize && mData[index] != a; index++)
                        ;
                return mData + index;
        }




        PX_FORCE_INLINE T& pushBack(const T& a)
        {
                if(capacity() <= mSize)
                        return growAndPushBack(a);

                PX_PLACEMENT_NEW(reinterpret_cast<void*>(mData + mSize), T)(a);

                return mData[mSize++];
        }



        PX_INLINE T popBack()
        {
                PX_ASSERT(mSize);
                T t = mData[mSize - 1];
                
                if (!isArrayOfPOD())
                {
                        mData[--mSize].~T();
                } 
                else 
                {
                        --mSize;                
                }

                return t;
        }



        PX_INLINE T& insert()
        {
                if(capacity() <= mSize)
                        grow(capacityIncrement());

                T* ptr = mData + mSize++;
                new (ptr) T; // not 'T()' because PODs should not get default-initialized.
                return *ptr;
        }



        PX_INLINE void replaceWithLast(uint32_t i)
        {
                PX_ASSERT(i < mSize);
                mData[i] = mData[--mSize];

                if (!isArrayOfPOD())
                {
                        mData[mSize].~T();
                }
        }

        PX_INLINE void replaceWithLast(Iterator i)
        {
                replaceWithLast(static_cast<uint32_t>(i - mData));
        }




        PX_INLINE bool findAndReplaceWithLast(const T& a)
        {
                uint32_t index = 0;
                while(index < mSize && mData[index] != a)
                        ++index;
                if(index == mSize)
                        return false;
                replaceWithLast(index);
                return true;
        }



        PX_INLINE void remove(uint32_t i)
        {
                PX_ASSERT(i < mSize);
                
                if (isArrayOfPOD())
                {
                        if (i + 1 != mSize)
                        {
                                physx::intrinsics::memMove(mData + i, mData + i + 1, (mSize - i - 1) * sizeof(T));
                        }
                }
                else
                {
                        for(T* it = mData + i; it->~T(), ++i < mSize; ++it)
                                new (it) T(mData[i]);
                }

                --mSize;
        }



        PX_INLINE void removeRange(uint32_t begin, uint32_t count)
        {
                PX_ASSERT(begin < mSize);
                PX_ASSERT((begin + count) <= mSize);
                
                if (!isArrayOfPOD())
                {
                        for(uint32_t i = 0; i < count; i++)
                        {
                                mData[begin + i].~T(); // call the destructor on the ones being removed first.
                        }
                }

                T* dest = &mData[begin];                       // location we are copying the tail end objects to
                T* src = &mData[begin + count];                // start of tail objects
                uint32_t move_count = mSize - (begin + count); // compute remainder that needs to be copied down

                if (isArrayOfPOD())
                {
                        physx::intrinsics::memMove(dest, src, move_count * sizeof(T));
                }
                else
                {
                        for(uint32_t i = 0; i < move_count; i++)
                        {
                                new (dest) T(*src); // copy the old one to the new location
                                src->~T();          // call the destructor on the old location
                                dest++;
                                src++;
                        }
                }
                mSize -= count;
        }



        PX_NOINLINE void resize(const uint32_t size, const T& a = T());

        PX_NOINLINE void resizeUninitialized(const uint32_t size);



        PX_INLINE void shrink()
        {
                recreate(mSize);
        }



        PX_INLINE void reset()
        {
                resize(0);
                shrink();
        }



        PX_INLINE void reserve(const uint32_t capacity)
        {
                if(capacity > this->capacity())
                        grow(capacity);
        }



        PX_FORCE_INLINE uint32_t capacity() const
        {
                return mCapacity & ~PX_SIGN_BITMASK;
        }



        PX_FORCE_INLINE void forceSize_Unsafe(uint32_t size)
        {
                PX_ASSERT(size <= mCapacity);
                mSize = size;
        }



        PX_INLINE void swap(Array<T, Alloc>& other)
        {
                shdfnd::swap(mData, other.mData);
                shdfnd::swap(mSize, other.mSize);
                shdfnd::swap(mCapacity, other.mCapacity);
        }



        PX_INLINE void assign(const T* first, const T* last)
        {
                resizeUninitialized(uint32_t(last - first));
                copy(begin(), end(), first);
        }

        // We need one bit to mark arrays that have been deserialized from a user-provided memory block.
        // For alignment & memory saving purpose we store that bit in the rarely used capacity member.
        PX_FORCE_INLINE uint32_t isInUserMemory() const
        {
                return mCapacity & PX_SIGN_BITMASK;
        }

        PX_INLINE Alloc& getAllocator()
        {
                return *this;
        }

  protected:
        // constructor for where we don't own the memory
        Array(T* memory, uint32_t size, uint32_t capacity, const Alloc& alloc = Alloc())
        : Alloc(alloc), mData(memory), mSize(size), mCapacity(capacity | PX_SIGN_BITMASK)
        {
        }

        template <class A>
        PX_NOINLINE void copy(const Array<T, A>& other);

        PX_INLINE T* allocate(uint32_t size)
        {
                if(size > 0)
                {
                        T* p = reinterpret_cast<T*>(Alloc::allocate(sizeof(T) * size, __FILE__, __LINE__));
#if PX_CHECKED
                        if(p)
                        {
                                for(uint32_t i = 0; i < (sizeof(T) * size); ++i)
                                        reinterpret_cast<uint8_t*>(p)[i] = 0xcd;
                        }
#endif
                        return p;
                }
                return 0;
        }

        PX_INLINE void deallocate(void* mem)
        {
                Alloc::deallocate(mem);
        }

        static PX_INLINE bool isZeroInit(const T& object)
        {
                char ZeroBuffOnStack[sizeof(object)] = {};
                return memcmp(&object, ZeroBuffOnStack, sizeof(object)) == 0;
        }

        static PX_INLINE void create(T* first, T* last, const T& a)
        {
                if (isArrayOfPOD() && isZeroInit(a))
                {
                        if(last>first)
                                physx::intrinsics::memZero(first, uint32_t((last-first) * sizeof(T)));
                }
                else
                {
                        for(; first<last; ++first)
                                ::new(first)T(a);
                }
        }

        static PX_INLINE void copy(T* first, T* last, const T* src)
        {                       
                if (last <= first)
                        return;

                if (isArrayOfPOD())
                {
                        physx::intrinsics::memCopy(first, src, uint32_t((last-first) * sizeof(T)));
                }
                else
                {
                        for(; first<last; ++first, ++src)
                                ::new (first)T(*src);
                }
        }

        static PX_INLINE void destroy(T* first, T* last)
        {
                if (!isArrayOfPOD())
                {
                        for(; first < last; ++first)
                                first->~T();
                }
        }

        PX_NOINLINE T& growAndPushBack(const T& a);

        PX_INLINE void grow(uint32_t capacity)
        {
                PX_ASSERT(this->capacity() < capacity);
                recreate(capacity);
        }

        PX_NOINLINE void recreate(uint32_t capacity);

        // The idea here is to prevent accidental bugs with pushBack or insert. Unfortunately
        // it interacts badly with InlineArrays with smaller inline allocations.
        // TODO(dsequeira): policy template arg, this is exactly what they're for.
        PX_INLINE uint32_t capacityIncrement() const
        {
                const uint32_t capacity = this->capacity();
                return capacity == 0 ? 1 : capacity * 2;
        }

        T* mData;
        uint32_t mSize;
        uint32_t mCapacity;
};

template <class T, class Alloc>
PX_NOINLINE void Array<T, Alloc>::resize(const uint32_t size, const T& a)
{
        reserve(size);
        create(mData + mSize, mData + size, a);
        destroy(mData + size, mData + mSize);
        mSize = size;
}

template <class T, class Alloc>
template <class A>
PX_NOINLINE void Array<T, Alloc>::copy(const Array<T, A>& other)
{
        if(!other.empty())
        {
                mData = allocate(mSize = mCapacity = other.size());
                copy(mData, mData + mSize, other.begin());
        }
        else
        {
                mData = NULL;
                mSize = 0;
                mCapacity = 0;
        }

        // mData = allocate(other.mSize);
        // mSize = other.mSize;
        // mCapacity = other.mSize;
        // copy(mData, mData + mSize, other.mData);
}

template <class T, class Alloc>
PX_NOINLINE void Array<T, Alloc>::resizeUninitialized(const uint32_t size)
{
        reserve(size);
        mSize = size;
}

template <class T, class Alloc>
PX_NOINLINE T& Array<T, Alloc>::growAndPushBack(const T& a)
{
        uint32_t capacity = capacityIncrement();

        T* newData = allocate(capacity);
        PX_ASSERT((!capacity) || (newData && (newData != mData)));
        copy(newData, newData + mSize, mData);

        // inserting element before destroying old array
        // avoids referencing destroyed object when duplicating array element.
        PX_PLACEMENT_NEW(reinterpret_cast<void*>(newData + mSize), T)(a);

        destroy(mData, mData + mSize);
        if(!isInUserMemory())
                deallocate(mData);

        mData = newData;
        mCapacity = capacity;

        return mData[mSize++];
}

template <class T, class Alloc>
PX_NOINLINE void Array<T, Alloc>::recreate(uint32_t capacity)
{
        T* newData = allocate(capacity);
        PX_ASSERT((!capacity) || (newData && (newData != mData)));

        copy(newData, newData + mSize, mData);
        destroy(mData, mData + mSize);
        if(!isInUserMemory())
                deallocate(mData);

        mData = newData;
        mCapacity = capacity;
}

template <class T, class Alloc>
PX_INLINE void swap(Array<T, Alloc>& x, Array<T, Alloc>& y)
{
        x.swap(y);
}

} // namespace shdfnd
} // namespace physx

#if PX_VC == 9 || PX_VC == 10
#pragma warning(pop)
#endif

#endif // #ifndef PSFOUNDATION_PSARRAY_H

---

previous page start next page

Menu

• Homepage

Table of contents

• Modules
  • Foundation
    • Defines
      • PX_FOUNDATION_VERSION
      • PX_FOUNDATION_VERSION_BUGFIX
      • PX_FOUNDATION_VERSION_MAJOR
      • PX_FOUNDATION_VERSION_MINOR
      • PX_SORT_PARANOIA
    • Functions
      • empty
      • grow
      • partition
      • pop
      • push
      • smallSort
      • sort
      • sort
      • Stack
      • ~Stack
    • Namespaces
      • physx
    • Classes
      • physx::shdfnd::internal::Stack< Allocator >
• Class List
  • physx::shdfnd::AlignedAllocator< N, BaseAllocator >
  • Alloc
  • Allocator
  • physx::shdfnd::AllocatorTraits< T >
  • physx::shdfnd::Array< T, Alloc >
  • physx::shdfnd::AtomicLock
  • physx::shdfnd::AtomicLockCopy
  • physx::shdfnd::AtomicRwLock
  • physx::shdfnd::BufferedSocketImpl
  • physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
  • physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • physx::shdfnd::CounterFrequencyToTensOfNanos
  • physx::shdfnd::Cpu
  • physx::shdfnd::EnableIfPod< T, X >
  • physx::shdfnd::Equal< A >
  • physx::shdfnd::FPUGuard
  • physx::shdfnd::Greater< A >
  • physx::shdfnd::Hash< Key >
  • physx::shdfnd::Hash< const char * >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey
  • physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
  • physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • physx::shdfnd::InlineArray< T, N, Alloc >
  • physx::shdfnd::Less< A >
  • physx::shdfnd::LogTwo< A >
  • physx::shdfnd::LogTwo< 1 >
  • physx::shdfnd::MutexImpl
  • physx::shdfnd::MutexT< Alloc >
  • physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • physx::shdfnd::NonTrackingAllocator
  • physx::shdfnd::Pair< F, S >
  • physx::shdfnd::Pool< T, Alloc >
  • physx::shdfnd::Pool2< T, slabSize, Alloc >
  • physx::shdfnd::PoolBase< T, Alloc >
  • physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList
  • physx::shdfnd::RawAllocator
  • physx::shdfnd::ReadWriteLock
  • physx::shdfnd::ReadWriteLockImpl
  • physx::shdfnd::ReflectionAllocator< T >
  • physx::shdfnd::Runnable
  • physx::shdfnd::ScopedAtomicLock
  • physx::shdfnd::ScopedPointer< T, Alloc >
  • physx::shdfnd::ScopedReadLock
  • physx::shdfnd::ScopedWriteLock
  • physx::shdfnd::SIMDGuard
  • physx::shdfnd::SListImpl
  • physx::shdfnd::SListT< Alloc >
  • physx::shdfnd::Socket
  • physx::shdfnd::SocketImpl
  • physx::shdfnd::internal::Stack< Allocator >
  • physx::shdfnd::SyncImpl
  • physx::shdfnd::SyncT< Alloc >
  • physx::shdfnd::TempAllocator
  • physx::shdfnd::TempAllocatorChunk
  • physx::shdfnd::ThreadImpl
  • physx::shdfnd::ThreadPriority
  • physx::shdfnd::ThreadT< Alloc >
  • physx::shdfnd::Time
  • physx::shdfnd::UnConst< T >
  • physx::shdfnd::UnConst< const T >
  • physx::shdfnd::UserAllocated
• Class Hierarchy
  • physx::shdfnd::AlignedAllocator< N, BaseAllocator >
  • Alloc
    • physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc >
      • physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > >
        • physx::shdfnd::InlineArray< T, N, Alloc >
    • physx::shdfnd::InlineAllocator< N *sizeof(void *), Alloc >
      • physx::shdfnd::Array< void *, InlineAllocator< N *sizeof(void *), Alloc > >
        • physx::shdfnd::InlineArray< void *, 64, Alloc >
    • physx::shdfnd::Array< T, Alloc >
    • physx::shdfnd::MutexT< Alloc >
    • physx::shdfnd::PoolBase< T, Alloc >
    • physx::shdfnd::ScopedPointer< T, Alloc >
    • physx::shdfnd::SListT< Alloc >
    • physx::shdfnd::SyncT< Alloc >
    • physx::shdfnd::ThreadT< Alloc >
    • physx::shdfnd::PoolBase< T, Alloc >
      • physx::shdfnd::Pool< T, Alloc >
      • physx::shdfnd::Pool2< T, slabSize, Alloc >
  • Allocator
    • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, true >
    • physx::shdfnd::internal::HashBase< Key, Key, HashFn, GetKey, Allocator, Coalesced >
  • physx::shdfnd::AllocatorTraits< T >
  • physx::shdfnd::AtomicLock
  • physx::shdfnd::AtomicLockCopy
  • physx::shdfnd::AtomicRwLock
  • physx::shdfnd::CounterFrequencyToTensOfNanos
  • physx::shdfnd::Cpu
  • physx::shdfnd::EnableIfPod< T, X >
  • physx::shdfnd::Equal< A >
  • physx::shdfnd::FPUGuard
  • physx::shdfnd::Greater< A >
  • physx::shdfnd::Hash< Key >
  • physx::shdfnd::Hash< const char * >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey
  • physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
    • physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
    • physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false >
    • physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true >
    • physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • physx::shdfnd::Less< A >
  • physx::shdfnd::LogTwo< A >
  • physx::shdfnd::LogTwo< 1 >
  • physx::shdfnd::MutexImpl
  • physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • physx::shdfnd::NonTrackingAllocator
  • physx::shdfnd::Pair< F, S >
  • physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList
  • physx::shdfnd::RawAllocator
  • physx::shdfnd::ReadWriteLock
  • physx::shdfnd::ReadWriteLockImpl
  • physx::shdfnd::ReflectionAllocator< T >
  • physx::shdfnd::Runnable
    • physx::shdfnd::ThreadT< Alloc >
  • physx::shdfnd::ScopedAtomicLock
  • physx::shdfnd::ScopedReadLock
  • physx::shdfnd::ScopedWriteLock
  • physx::shdfnd::SIMDGuard
  • physx::shdfnd::SListImpl
  • physx::shdfnd::SocketImpl
    • physx::shdfnd::BufferedSocketImpl
  • physx::shdfnd::internal::Stack< Allocator >
  • physx::shdfnd::SyncImpl
  • physx::shdfnd::TempAllocator
  • physx::shdfnd::TempAllocatorChunk
  • physx::shdfnd::ThreadImpl
  • physx::shdfnd::ThreadPriority
  • physx::shdfnd::Time
  • physx::shdfnd::UnConst< T >
  • physx::shdfnd::UnConst< const T >
  • physx::shdfnd::UserAllocated
    • physx::shdfnd::PoolBase< T, Alloc >
    • physx::shdfnd::Socket
    • physx::shdfnd::ThreadT< Alloc >
    • physx::shdfnd::PoolBase< T, Alloc >
  • Key
• Class Members
• Namespace List
  • physx
  • physx::shdfnd
  • physx::shdfnd::internal
• Namespace Members
• File List
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/Ps.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlignedMalloc.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlloca.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsArray.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAtomic.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBitUtils.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsCpu.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsFPU.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsGlobals.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHash.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashMap.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashSet.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineArray.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsIntrinsics.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSList.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSocket.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSort.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSortInternals.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsString.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSync.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTempAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTime.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsUserAllocated.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsVersionNumber.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsFPU.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsInclude.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsIntrinsics.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAllocator.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAssert.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsGlobals.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsHeaderTest.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsString.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsTempAllocator.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsAtomic.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsCpu.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsFPU.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsPrintString.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSList.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSync.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsThread.cpp
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsTime.cpp
• File Members

Get in touch

Submit feedback about this site to:

• [email protected]

© documentation.help. Design: rehmann.co.