NVIDIA(R) PsFoundation Reference: Module Index

  • Main Page
  • Modules
  • Namespaces
  • Classes
  • Files

Modules

Here is a list of all modules:
  • Foundation
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Foundation

  • Classes
  • Files

Foundation

Classes

class | physx::shdfnd::internal::Stack< Allocator >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.

Defines

#define | PX_SORT_PARANOIA PX_DEBUG
#define | PX_FOUNDATION_VERSION_MAJOR 3
#define | PX_FOUNDATION_VERSION_MINOR 4
#define | PX_FOUNDATION_VERSION_BUGFIX 0
#define | PX_FOUNDATION_VERSION ((PX_FOUNDATION_VERSION_MAJOR << 24) + (PX_FOUNDATION_VERSION_MINOR << 16) + (PX_FOUNDATION_VERSION_BUGFIX << 8) + 0)

Functions

template<class T , class Predicate >
void | physx::shdfnd::sort (T *elements, uint32_t count, const Predicate &compare)
template<class T >
void | physx::shdfnd::sort (T *elements, uint32_t count)
template<class T , class Predicate >
PX_INLINE int32_t | physx::shdfnd::internal::partition (T *elements, int32_t first, int32_t last, Predicate &compare)
template<class T , class Predicate >
PX_INLINE void | physx::shdfnd::internal::smallSort (T *elements, int32_t first, int32_t last, Predicate &compare)
physx::shdfnd::internal::Stack::Stack (int32_t *memory, uint32_t capacity, const Allocator &inAllocator)
physx::shdfnd::internal::Stack::~Stack ()
void | physx::shdfnd::internal::Stack::grow ()
PX_INLINE void | physx::shdfnd::internal::Stack::push (int32_t start, int32_t end)
PX_INLINE void | physx::shdfnd::internal::Stack::pop (int32_t &start, int32_t &end)
PX_INLINE bool | physx::shdfnd::internal::Stack::empty ()

Define Documentation

#define PX_FOUNDATION_VERSION ((PX_FOUNDATION_VERSION_MAJOR << 24) + (PX_FOUNDATION_VERSION_MINOR << 16) + (PX_FOUNDATION_VERSION_BUGFIX << 8) + 0)

The constant PX_FOUNDATION_VERSION is used when creating certain PhysX module objects. This is to ensure that the application is using the same header version as the library was built with.

#define PX_FOUNDATION_VERSION_BUGFIX 0

#define PX_FOUNDATION_VERSION_MAJOR 3

#define PX_FOUNDATION_VERSION_MINOR 4

#define PX_SORT_PARANOIA PX_DEBUG

Function Documentation

template<class Allocator>
PX_INLINE bool physx::shdfnd::internal::Stack< Allocator >::empty ( ) [inline, inherited]

template<class Allocator>
void physx::shdfnd::internal::Stack< Allocator >::grow ( ) [inline, inherited]

template<class T , class Predicate >
PX_INLINE int32_t physx::shdfnd::internal::partition | ( | T * | elements,
 |  | int32_t | first,
 |  | int32_t | last,
 |  | Predicate & | compare |
 | ) |  |  | [inline]

template<class Allocator>
PX_INLINE void physx::shdfnd::internal::Stack< Allocator >::pop | ( | int32_t & | start,
 |  | int32_t & | end |
 | ) |  |  | [inline, inherited]

template<class Allocator>
PX_INLINE void physx::shdfnd::internal::Stack< Allocator >::push | ( | int32_t | start,
 |  | int32_t | end |
 | ) |  |  | [inline, inherited]

template<class T , class Predicate >
PX_INLINE void physx::shdfnd::internal::smallSort | ( | T * | elements,
 |  | int32_t | first,
 |  | int32_t | last,
 |  | Predicate & | compare |
 | ) |  |  | [inline]

template<class T >
void physx::shdfnd::sort | ( | T * | elements,
 |  | uint32_t | count |
 | ) |  |  | [inline]

template<class T , class Predicate >
void physx::shdfnd::sort | ( | T * | elements,
 |  | uint32_t | count,
 |  | const Predicate & | compare |
 | ) |  |  | [inline]

template<class Allocator>
physx::shdfnd::internal::Stack< Allocator >::Stack | ( | int32_t * | memory,
 |  | uint32_t | capacity,
 |  | const Allocator & | inAllocator |
 | ) |  |  | [inline, inherited]

template<class Allocator>
physx::shdfnd::internal::Stack< Allocator >::~Stack ( ) [inline, inherited]

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx Namespace Reference

  • Namespace List
  • Namespace Members

physx Namespace Reference
[Foundation]

Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:. More...

Namespaces

namespace | shdfnd

Functions

PxAssertHandler & | PxGetAssertHandler ()
void | PxSetAssertHandler (PxAssertHandler &handler)

Detailed Description

Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.

Allocate aligned memory. Alignment must be a power of 2! -- should be templated by a base allocator

Central definition of hash functions

See also:
Less, Greater

Function Documentation

PxAssertHandler& physx::PxGetAssertHandler ( )

void physx::PxSetAssertHandler ( PxAssertHandler & handler )

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::Stack< Allocator > Class Template Reference

  • Class List
  • Class Hierarchy
  • Class Members
physx::shdfnd::internal::Stack

physx::shdfnd::internal::Stack< Allocator > Class Template Reference
[Foundation]

#include <PsSortInternals.h>

List of all members.

Public Member Functions

Stack (int32_t *memory, uint32_t capacity, const Allocator &inAllocator)
~Stack ()
void | grow ()
PX_INLINE void | push (int32_t start, int32_t end)
PX_INLINE void | pop (int32_t &start, int32_t &end)
PX_INLINE bool | empty ()

template<class Allocator>
class physx::shdfnd::internal::Stack< Allocator >

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSortInternals.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class List

  • Class Hierarchy
  • Class Members

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
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
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::AlignedAllocator< N, BaseAllocator > Class Template Reference

physx::shdfnd::AlignedAllocator

physx::shdfnd::AlignedAllocator< N, BaseAllocator > Class Template Reference

#include <PsAlignedMalloc.h>

List of all members.

Public Member Functions

AlignedAllocator (const BaseAllocator &base=BaseAllocator())
void * | allocate (size_t size, const char *file, int line)
void | deallocate (void *ptr)

Detailed Description

template<uint32_t N, typename BaseAllocator = NonTrackingAllocator>
class physx::shdfnd::AlignedAllocator< N, BaseAllocator >

Allocator, which is used to access the global PxAllocatorCallback instance (used for dynamic data types template instantiation), which can align memory

Constructor & Destructor Documentation

template<uint32_t N, typename BaseAllocator = NonTrackingAllocator>
physx::shdfnd::AlignedAllocator< N, BaseAllocator >::AlignedAllocator ( const BaseAllocator & base = BaseAllocator() ) [inline]

Member Function Documentation

template<uint32_t N, typename BaseAllocator = NonTrackingAllocator>
void* physx::shdfnd::AlignedAllocator< N, BaseAllocator >::allocate | ( | size_t | size,
 |  | const char * | file,
 |  | int | line |
 | ) |  |  | [inline]

template<uint32_t N, typename BaseAllocator = NonTrackingAllocator>
void physx::shdfnd::AlignedAllocator< N, BaseAllocator >::deallocate ( void * ptr ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlignedMalloc.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Alloc Class Reference

Alloc Class Reference

Inheritance diagram for Alloc:

physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > physx::shdfnd::InlineAllocator< N *sizeof(void *), 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 >
The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Allocator Class Reference

Allocator Class Reference

Inheritance diagram for Allocator:

physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, true > physx::shdfnd::internal::HashBase< Key, Key, HashFn, GetKey, Allocator, Coalesced >
The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::AllocatorTraits< T > Struct Template Reference

physx::shdfnd::AllocatorTraits

physx::shdfnd::AllocatorTraits< T > Struct Template Reference

#include <PsAllocator.h>

List of all members.

Public Types

typedef ReflectionAllocator< T > Type

template<typename T>
struct physx::shdfnd::AllocatorTraits< T >

Member Typedef Documentation

template<typename T >
typedef ReflectionAllocator<T> physx::shdfnd::AllocatorTraits< T >::Type

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Array< T, Alloc > Class Template Reference

physx::shdfnd::Array

physx::shdfnd::Array< T, Alloc > Class Template Reference

#include <PsArray.h>

Inheritance diagram for physx::shdfnd::Array< T, Alloc >:

Alloc

List of all members.

Public Types

typedef T * | Iterator
typedef const T * | ConstIterator

Public Member Functions

Array (const PxEMPTY v)
PX_INLINE | Array (const Alloc &alloc=Alloc())
PX_INLINE | Array (uint32_t size, const T &a=T(), const Alloc &alloc=Alloc())
template<class A >
PX_INLINE | Array (const Array< T, A > &other, const Alloc &alloc=Alloc())
PX_INLINE | Array (const Array &other, const Alloc &alloc=Alloc())
PX_INLINE | Array (const T *first, const T *last, const Alloc &alloc=Alloc())
PX_INLINE | ~Array ()
template<class A >
PX_INLINE Array & | operator= (const Array< T, A > &rhs)
PX_INLINE Array & | operator= (const Array &t)
PX_FORCE_INLINE const T & | operator[] (uint32_t i) const
PX_FORCE_INLINE T & | operator[] (uint32_t i)
PX_FORCE_INLINE ConstIterator | begin () const
PX_FORCE_INLINE Iterator | begin ()
PX_FORCE_INLINE ConstIterator | end () const
PX_FORCE_INLINE Iterator | end ()
PX_FORCE_INLINE const T & | front () const
PX_FORCE_INLINE T & | front ()
PX_FORCE_INLINE const T & | back () const
PX_FORCE_INLINE T & | back ()
PX_FORCE_INLINE uint32_t | size () const
PX_INLINE void | clear ()
PX_FORCE_INLINE bool | empty () const
PX_INLINE Iterator | find (const T &a)
PX_INLINE ConstIterator | find (const T &a) const
PX_FORCE_INLINE T & | pushBack (const T &a)
PX_INLINE T | popBack ()
PX_INLINE T & | insert ()
PX_INLINE void | replaceWithLast (uint32_t i)
PX_INLINE void | replaceWithLast (Iterator i)
PX_INLINE bool | findAndReplaceWithLast (const T &a)
PX_INLINE void | remove (uint32_t i)
PX_INLINE void | removeRange (uint32_t begin, uint32_t 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 ()
PX_INLINE void | reset ()
PX_INLINE void | reserve (const uint32_t capacity)
PX_FORCE_INLINE uint32_t | capacity () const
PX_FORCE_INLINE void | forceSize_Unsafe (uint32_t size)
PX_INLINE void | swap (Array< T, Alloc > &other)
PX_INLINE void | assign (const T *first, const T *last)
PX_FORCE_INLINE uint32_t | isInUserMemory () const
PX_INLINE Alloc & | getAllocator ()
return reference to allocator

Static Public Member Functions

static PX_FORCE_INLINE bool | isArrayOfPOD ()

Protected Member Functions

Array (T *memory, uint32_t size, uint32_t capacity, const Alloc &alloc=Alloc())
template<class A >
PX_NOINLINE void | copy (const Array< T, A > &other)
PX_INLINE T * | allocate (uint32_t size)
PX_INLINE void | deallocate (void *mem)
PX_NOINLINE T & | growAndPushBack (const T &a)
PX_INLINE void | grow (uint32_t capacity)
PX_NOINLINE void | recreate (uint32_t capacity)
PX_INLINE uint32_t | capacityIncrement () const

Static Protected Member Functions

static PX_INLINE bool | isZeroInit (const T &object)
static PX_INLINE void | create (T *first, T *last, const T &a)
static PX_INLINE void | copy (T *first, T *last, const T *src)
static PX_INLINE void | destroy (T *first, T *last)

Protected Attributes

T * | mData
uint32_t | mSize
uint32_t | mCapacity

Detailed Description

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
class physx::shdfnd::Array< T, Alloc >

An array is a sequential container.

Implementation note entries between 0 and size are valid objects we use inheritance to build this because the array is included inline in a lot of objects and we want the allocator to take no space if it's not stateful, which aggregation doesn't allow. Also, we want the metadata at the front for the inline case where the allocator contains some inline storage space

Member Typedef Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
typedef const T* physx::shdfnd::Array< T, Alloc >::ConstIterator

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
typedef T* physx::shdfnd::Array< T, Alloc >::Iterator

Constructor & Destructor Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::Array< T, Alloc >::Array ( const PxEMPTY v ) [inline, explicit]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE physx::shdfnd::Array< T, Alloc >::Array ( const Alloc & alloc = Alloc() ) [inline, explicit]

Default array constructor. Initialize an empty array

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE physx::shdfnd::Array< T, Alloc >::Array | ( | uint32_t | size,
 |  | const T & | a = T(),
 |  | const Alloc & | alloc = Alloc() |
 | ) |  |  | [inline, explicit]

Initialize array with given capacity

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A >
PX_INLINE physx::shdfnd::Array< T, Alloc >::Array | ( | const Array< T, A > & | other,
 |  | const Alloc & | alloc = Alloc() |
 | ) |  |  | [inline, explicit]

Copy-constructor. Copy all entries from other array

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE physx::shdfnd::Array< T, Alloc >::Array | ( | const Array< T, Alloc > & | other,
 |  | const Alloc & | alloc = Alloc() |
 | ) |  |  | [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE physx::shdfnd::Array< T, Alloc >::Array | ( | const T * | first,
 |  | const T * | last,
 |  | const Alloc & | alloc = Alloc() |
 | ) |  |  | [inline, explicit]

Initialize array with given length

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE physx::shdfnd::Array< T, Alloc >::~Array ( ) [inline]

Destructor

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::Array< T, Alloc >::Array | ( | T * | memory,
 |  | uint32_t | size,
 |  | uint32_t | capacity,
 |  | const Alloc & | alloc = Alloc() |
 | ) |  |  | [inline, protected]

Member Function Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE T* physx::shdfnd::Array< T, Alloc >::allocate ( uint32_t size ) [inline, protected]

Mark a specified amount of memory with 0xcd pattern. This is used to check that the meta data definition for serialized classes is complete in checked builds.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::assign | ( | const T * | first,
 |  | const T * | last |
 | ) |  |  | [inline]

Assign a range of values to this vector (resizes to length of range)

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE T& physx::shdfnd::Array< T, Alloc >::back ( ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE const T& physx::shdfnd::Array< T, Alloc >::back ( ) const [inline]

Returns a reference to the last element of the array. Undefined if the array is empty

Returns:
a reference to the last element of the array

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE Iterator physx::shdfnd::Array< T, Alloc >::begin ( ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE ConstIterator physx::shdfnd::Array< T, Alloc >::begin ( ) const [inline]

Returns a pointer to the initial element of the array.

Returns:
a pointer to the initial element of the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE uint32_t physx::shdfnd::Array< T, Alloc >::capacity ( ) const [inline]

Query the capacity(allocated mem) for the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE uint32_t physx::shdfnd::Array< T, Alloc >::capacityIncrement ( ) const [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::clear ( ) [inline]

Clears the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
static PX_INLINE void physx::shdfnd::Array< T, Alloc >::copy | ( | T * | first,
 |  | T * | last,
 |  | const T * | src |
 | ) |  |  | [inline, static, protected]

template<class T, class Alloc >
template<class A >
PX_NOINLINE void physx::shdfnd::Array< T, Alloc >::copy ( const Array< T, A > & other ) [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
static PX_INLINE void physx::shdfnd::Array< T, Alloc >::create | ( | T * | first,
 |  | T * | last,
 |  | const T & | a |
 | ) |  |  | [inline, static, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::deallocate ( void * mem ) [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
static PX_INLINE void physx::shdfnd::Array< T, Alloc >::destroy | ( | T * | first,
 |  | T * | last |
 | ) |  |  | [inline, static, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE bool physx::shdfnd::Array< T, Alloc >::empty ( ) const [inline]

Returns whether the array is empty (i.e. whether its size is 0).

Returns:
true if the array is empty

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE Iterator physx::shdfnd::Array< T, Alloc >::end ( ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE ConstIterator physx::shdfnd::Array< T, Alloc >::end ( ) const [inline]

Returns an iterator beyond the last element of the array. Do not dereference.

Returns:
a pointer to the element beyond the last element of the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE ConstIterator physx::shdfnd::Array< T, Alloc >::find ( const T & a ) const [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE Iterator physx::shdfnd::Array< T, Alloc >::find ( const T & a ) [inline]

Finds the first occurrence of an element in the array.

Parameters:
a The element to find.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE bool physx::shdfnd::Array< T, Alloc >::findAndReplaceWithLast ( const T & a ) [inline]

Replaces the first occurrence of the element a with the last element Operation is O(n)

Parameters:
a The position of the element that will be subtracted from this array.
Returns:
true if the element has been removed.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE void physx::shdfnd::Array< T, Alloc >::forceSize_Unsafe ( uint32_t size ) [inline]

Unsafe function to force the size of the array

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE T& physx::shdfnd::Array< T, Alloc >::front ( ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE const T& physx::shdfnd::Array< T, Alloc >::front ( ) const [inline]

Returns a reference to the first element of the array. Undefined if the array is empty.

Returns:
a reference to the first element of the array

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE Alloc& physx::shdfnd::Array< T, Alloc >::getAllocator ( ) [inline]

return reference to allocator

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::grow ( uint32_t capacity ) [inline, protected]

Resizes the available memory for the array.

Parameters:
capacity The number of entries that the set should be able to hold.

template<class T, class Alloc >
PX_NOINLINE T & physx::shdfnd::Array< T, Alloc >::growAndPushBack ( const T & a ) [inline, protected]

Called when pushBack() needs to grow the array.

Parameters:
a The element that will be added to this array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE T& physx::shdfnd::Array< T, Alloc >::insert ( ) [inline]

Construct one element at the end of the array. Operation is O(1).

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
static PX_FORCE_INLINE bool physx::shdfnd::Array< T, Alloc >::isArrayOfPOD ( ) [inline, static]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE uint32_t physx::shdfnd::Array< T, Alloc >::isInUserMemory ( ) const [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
static PX_INLINE bool physx::shdfnd::Array< T, Alloc >::isZeroInit ( const T & object ) [inline, static, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE Array& physx::shdfnd::Array< T, Alloc >::operator= ( const Array< T, Alloc > & t ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A >
PX_INLINE Array& physx::shdfnd::Array< T, Alloc >::operator= ( const Array< T, A > & rhs ) [inline]

Assignment operator. Copy content (deep-copy)

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE T& physx::shdfnd::Array< T, Alloc >::operator[] ( uint32_t i ) [inline]

Array indexing operator.

Parameters:
i The index of the element that will be returned.
Returns:
The element i in the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE const T& physx::shdfnd::Array< T, Alloc >::operator[] ( uint32_t i ) const [inline]

Array indexing operator.

Parameters:
i The index of the element that will be returned.
Returns:
The element i in the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE T physx::shdfnd::Array< T, Alloc >::popBack ( ) [inline]

Returns the element at the end of the array. Only legal if the array is non-empty.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE T& physx::shdfnd::Array< T, Alloc >::pushBack ( const T & a ) [inline]

Adds one element to the end of the array. Operation is O(1).

Parameters:
a The element that will be added to this array.

template<class T , class Alloc >
PX_NOINLINE void physx::shdfnd::Array< T, Alloc >::recreate ( uint32_t capacity ) [inline, protected]

Creates a new memory block, copies all entries to the new block and destroys old entries.

Parameters:
capacity The number of entries that the set should be able to hold.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::remove ( uint32_t i ) [inline]

Subtracts the element on position i from the array. Shift the entire array one step. Operation is O(n)

Parameters:
i The position of the element that will be subtracted from this array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::removeRange | ( | uint32_t | begin,
 |  | uint32_t | count |
 | ) |  |  | [inline]

Removes a range from the array. Shifts the array so order is maintained. Operation is O(n)

Parameters:
begin | The starting position of the element that will be subtracted from this array.
count | The number of elments that will be subtracted from this array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::replaceWithLast ( Iterator i ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::replaceWithLast ( uint32_t i ) [inline]

Subtracts the element on position i from the array and replace it with the last element. Operation is O(1)

Parameters:
i The position of the element that will be subtracted from this array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::reserve ( const uint32_t capacity ) [inline]

Ensure that the array has at least size capacity.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::reset ( ) [inline]

Deletes all array elements and frees memory.

template<class T, class Alloc >
PX_NOINLINE void physx::shdfnd::Array< T, Alloc >::resize | ( | const uint32_t | size,
 |  | const T & | a = T() |
 | ) |  |  | [inline]

Resize array

template<class T , class Alloc >
PX_NOINLINE void physx::shdfnd::Array< T, Alloc >::resizeUninitialized ( const uint32_t size ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::shrink ( ) [inline]

Resize array such that only as much memory is allocated to hold the existing elements

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_FORCE_INLINE uint32_t physx::shdfnd::Array< T, Alloc >::size ( ) const [inline]

Returns the number of entries in the array. This can, and probably will, differ from the array capacity.

Returns:
The number of of entries in the array.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::Array< T, Alloc >::swap ( Array< T, Alloc > & other ) [inline]

Swap contents of an array without allocating temporary storage

Member Data Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
uint32_t physx::shdfnd::Array< T, Alloc >::mCapacity [protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
T* physx::shdfnd::Array< T, Alloc >::mData [protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
uint32_t physx::shdfnd::Array< T, Alloc >::mSize [protected]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsArray.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::AtomicLock Class Reference

physx::shdfnd::AtomicLock

physx::shdfnd::AtomicLock Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

AtomicLock ()
bool | lock ()
bool | trylock ()
bool | unlock ()

Constructor & Destructor Documentation

physx::shdfnd::AtomicLock::AtomicLock ( ) [inline]

Member Function Documentation

bool physx::shdfnd::AtomicLock::lock ( ) [inline]

bool physx::shdfnd::AtomicLock::trylock ( ) [inline]

bool physx::shdfnd::AtomicLock::unlock ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::AtomicLockCopy Class Reference

physx::shdfnd::AtomicLockCopy

physx::shdfnd::AtomicLockCopy Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

AtomicLockCopy ()
AtomicLockCopy & | operator= (AtomicLock &lock)
bool | lock ()
bool | trylock ()
bool | unlock ()

Constructor & Destructor Documentation

physx::shdfnd::AtomicLockCopy::AtomicLockCopy ( ) [inline]

Member Function Documentation

bool physx::shdfnd::AtomicLockCopy::lock ( ) [inline]

AtomicLockCopy& physx::shdfnd::AtomicLockCopy::operator= ( AtomicLock & lock ) [inline]

bool physx::shdfnd::AtomicLockCopy::trylock ( ) [inline]

bool physx::shdfnd::AtomicLockCopy::unlock ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::AtomicRwLock Class Reference

physx::shdfnd::AtomicRwLock

physx::shdfnd::AtomicRwLock Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

AtomicRwLock ()
void | lockReader ()
void | lockWriter ()
bool | tryLockReader ()
void | unlockReader ()
void | unlockWriter ()

Constructor & Destructor Documentation

physx::shdfnd::AtomicRwLock::AtomicRwLock ( ) [inline]

Member Function Documentation

void physx::shdfnd::AtomicRwLock::lockReader ( ) [inline]

void physx::shdfnd::AtomicRwLock::lockWriter ( ) [inline]

bool physx::shdfnd::AtomicRwLock::tryLockReader ( ) [inline]

void physx::shdfnd::AtomicRwLock::unlockReader ( ) [inline]

void physx::shdfnd::AtomicRwLock::unlockWriter ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::BufferedSocketImpl Class Reference

physx::shdfnd::BufferedSocketImpl

physx::shdfnd::BufferedSocketImpl Class Reference

Inheritance diagram for physx::shdfnd::BufferedSocketImpl:

physx::shdfnd::SocketImpl

List of all members.

Public Member Functions

BufferedSocketImpl (bool isBlocking)
virtual | ~BufferedSocketImpl ()
bool | flush ()
uint32_t | write (const uint8_t *data, uint32_t length)

Constructor & Destructor Documentation

physx::shdfnd::BufferedSocketImpl::BufferedSocketImpl ( bool isBlocking ) [inline]

virtual physx::shdfnd::BufferedSocketImpl::~BufferedSocketImpl ( ) [inline, virtual]

Member Function Documentation

bool physx::shdfnd::BufferedSocketImpl::flush ( ) [virtual]

Reimplemented from physx::shdfnd::SocketImpl.

uint32_t physx::shdfnd::BufferedSocketImpl::write | ( | const uint8_t * | data,
 |  | uint32_t | length |
 | ) |  |  | [virtual]

Reimplemented from physx::shdfnd::SocketImpl.

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > Class Template Reference

physx::shdfnd::CoalescedHashMap

physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > Class Template Reference

#include <PsHashMap.h>

Inheritance diagram for physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >:

physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >

List of all members.

Package Functions

CoalescedHashMap (uint32_t initialTableSize=64, float loadFactor=0.75f)
const Pair< const Key, Value > * getEntries () const

Package Attributes

__pad0__:HashMapBase<Key
Value
HashFn
Allocator HashMapBase

template<class Key, class Value, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
class physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >

Constructor & Destructor Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >::CoalescedHashMap | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline, package]

Member Function Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
const Pair<const Key, Value>* physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >::getEntries ( ) const [inline, package]

Member Data Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >::__pad0__ [package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >::HashFn [package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
Allocator physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >::HashMapBase [package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >::Value [package]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashMap.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > Class Template Reference

physx::shdfnd::CoalescedHashSet

physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > Class Template Reference

#include <PsHashSet.h>

Inheritance diagram for physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >:

physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true >

List of all members.

Public Types

typedef internal::HashSetBase
< Key, HashFn, Allocator, true > 		HashSetBase

Public Member Functions

CoalescedHashSet (uint32_t initialTableSize=64, float loadFactor=0.75f)
CoalescedHashSet (uint32_t initialTableSize, float loadFactor, const Allocator &alloc)
CoalescedHashSet (const Allocator &alloc)
const Key * getEntries () const

template<class Key, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
class physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >

Member Typedef Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
typedef internal::HashSetBase<Key, HashFn, Allocator, true> physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >::HashSetBase

Constructor & Destructor Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >::CoalescedHashSet | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >::CoalescedHashSet | ( | uint32_t | initialTableSize,
 |  | float | loadFactor,
 |  | const Allocator & | alloc |
 | ) |  |  | [inline]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >::CoalescedHashSet ( const Allocator & alloc ) [inline]

Member Function Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
const Key* physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >::getEntries ( ) const [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashSet.h
Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::CounterFrequencyToTensOfNanos Struct Reference

physx::shdfnd::CounterFrequencyToTensOfNanos

physx::shdfnd::CounterFrequencyToTensOfNanos Struct Reference

#include <PsTime.h>

List of all members.

Public Member Functions

CounterFrequencyToTensOfNanos (uint64_t inNum, uint64_t inDenom)
uint64_t | toTensOfNanos (uint64_t inCounter) const

Public Attributes

uint64_t | mNumerator
uint64_t | mDenominator

Constructor & Destructor Documentation

physx::shdfnd::CounterFrequencyToTensOfNanos::CounterFrequencyToTensOfNanos | ( | uint64_t | inNum,
 |  | uint64_t | inDenom |
 | ) |  |  | [inline]

Member Function Documentation

uint64_t physx::shdfnd::CounterFrequencyToTensOfNanos::toTensOfNanos ( uint64_t inCounter ) const [inline]

Member Data Documentation

uint64_t physx::shdfnd::CounterFrequencyToTensOfNanos::mDenominator

uint64_t physx::shdfnd::CounterFrequencyToTensOfNanos::mNumerator

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTime.h
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Cpu Class Reference

physx::shdfnd::Cpu

physx::shdfnd::Cpu Class Reference

#include <PsCpu.h>

List of all members.

Static Public Member Functions

static uint8_t getCpuId ()

Member Function Documentation

uint8_t physx::shdfnd::Cpu::getCpuId ( ) [static]

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsCpu.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsCpu.cpp
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::EnableIfPod< T, X > Union Template Reference

physx::shdfnd::EnableIfPod

physx::shdfnd::EnableIfPod< T, X > Union Template Reference

#include <PsAllocator.h>

List of all members.

Public Types

typedef X | Type

Public Attributes

int | i
T | t

template<typename T, typename X>
union physx::shdfnd::EnableIfPod< T, X >

Member Typedef Documentation

template<typename T, typename X>
typedef X physx::shdfnd::EnableIfPod< T, X >::Type

Member Data Documentation

template<typename T, typename X>
int physx::shdfnd::EnableIfPod< T, X >::i

template<typename T, typename X>
T physx::shdfnd::EnableIfPod< T, X >::t

The documentation for this union was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Equal< A > Struct Template Reference

physx::shdfnd::Equal

physx::shdfnd::Equal< A > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Public Member Functions

bool operator() (const A &a, const A &b) const

template<typename A>
struct physx::shdfnd::Equal< A >

Member Function Documentation

template<typename A >
bool physx::shdfnd::Equal< A >::operator() | ( | const A & | a,
 |  | const A & | b |
 | ) |  |  | const [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::FPUGuard Class Reference

physx::shdfnd::FPUGuard

physx::shdfnd::FPUGuard Class Reference

#include <PsFPU.h>

List of all members.

Public Member Functions

FPUGuard ()
~FPUGuard ()

Constructor & Destructor Documentation

physx::shdfnd::FPUGuard::FPUGuard ( )

physx::shdfnd::FPUGuard::~FPUGuard ( )

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsFPU.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsFPU.cpp
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Greater< A > Struct Template Reference

physx::shdfnd::Greater

physx::shdfnd::Greater< A > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Public Member Functions

bool operator() (const A &a, const A &b) const

template<typename A>
struct physx::shdfnd::Greater< A >

Member Function Documentation

template<typename A >
bool physx::shdfnd::Greater< A >::operator() | ( | const A & | a,
 |  | const A & | b |
 | ) |  |  | const [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Hash< Key > Struct Template Reference

physx::shdfnd::Hash

physx::shdfnd::Hash< Key > Struct Template Reference

#include <PsHash.h>

List of all members.

Public Member Functions

uint32_t | operator() (const Key &k) const
bool | equal (const Key &k0, const Key &k1) const

template<class Key>
struct physx::shdfnd::Hash< Key >

Member Function Documentation

template<class Key >
bool physx::shdfnd::Hash< Key >::equal | ( | const Key & | k0,
 |  | const Key & | k1 |
 | ) |  |  | const [inline]

template<class Key >
uint32_t physx::shdfnd::Hash< Key >::operator() ( const Key & k ) const [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHash.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Hash< const char * > Struct Template Reference

physx::shdfnd::Hash< const char * >

physx::shdfnd::Hash< const char * > Struct Template Reference

#include <PsHash.h>

List of all members.

Public Member Functions

uint32_t | operator() (const char *_string) const
bool | equal (const char *string0, const char *string1) const

template<>
struct physx::shdfnd::Hash< const char * >

Member Function Documentation

bool physx::shdfnd::Hash< const char * >::equal | ( | const char * | string0,
 |  | const char * | string1 |
 | ) |  |  | const [inline]

uint32_t physx::shdfnd::Hash< const char * >::operator() ( const char * _string ) const [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHash.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > Class Template Reference

physx::shdfnd::internal::HashBase

physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > Class Template Reference

#include <PsHashInternals.h>

List of all members.

Classes

class | Iter

Public Types

typedef Entry | EntryType

Public Member Functions

HashBase (uint32_t initialTableSize=64, float loadFactor=0.75f)
HashBase (uint32_t initialTableSize, float loadFactor, const Allocator &alloc)
HashBase (const Allocator &alloc)
~HashBase ()
PX_INLINE Entry * | create (const Key &k, bool &exists)
PX_INLINE const Entry * | find (const Key &k) const
PX_INLINE bool | erase (const Key &k)
PX_INLINE uint32_t | size () const
PX_INLINE uint32_t | capacity () const
void | clear ()
void | reserve (uint32_t size)
PX_INLINE const Entry * | getEntries () const
PX_INLINE Entry * | insertUnique (const Key &k)

Static Public Attributes

static const uint32_t | EOL = 0xffffffff

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
class physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >

Member Typedef Documentation

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
typedef Entry physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::EntryType

Constructor & Destructor Documentation

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase | ( | uint32_t | initialTableSize,
 |  | float | loadFactor,
 |  | const Allocator & | alloc |
 | ) |  |  | [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase ( const Allocator & alloc ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::~HashBase ( ) [inline]

Member Function Documentation

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE uint32_t physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::capacity ( ) const [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
void physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::clear ( ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE Entry* physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::create | ( | const Key & | k,
 |  | bool & | exists |
 | ) |  |  | [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE bool physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::erase ( const Key & k ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE const Entry* physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::find ( const Key & k ) const [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE const Entry* physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::getEntries ( ) const [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE Entry* physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::insertUnique ( const Key & k ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
void physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::reserve ( uint32_t size ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE uint32_t physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::size ( ) const [inline]

Member Data Documentation

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
const uint32_t physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::EOL = 0xffffffff [static]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter Class Reference

physx::shdfnd::internal::HashBase::Iter

physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter Class Reference

#include <PsHashInternals.h>

List of all members.

Public Member Functions

PX_INLINE | Iter (HashBase &b)
PX_INLINE void | check () const
PX_INLINE Entry | operator* () const
PX_INLINE Entry * | operator-> () const
PX_INLINE Iter | operator++ ()
PX_INLINE Iter | operator++ (int)
PX_INLINE bool | done () const

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
class physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::Iter

Constructor & Destructor Documentation

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::Iter ( HashBase & b ) [inline]

Member Function Documentation

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE void physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::check ( ) const [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE bool physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::done ( ) const [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE Entry physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::operator* ( ) const [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE Iter physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::operator++ ( int ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE Iter physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::operator++ ( ) [inline]

template<class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
PX_INLINE Entry* physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter::operator-> ( ) const [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > Class Template Reference

physx::shdfnd::HashMap

physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > Class Template Reference

#include <PsHashMap.h>

Inheritance diagram for physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >:

physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >

List of all members.

Package Types

typedef HashMapBase::Iterator Iterator

Package Functions

HashMap (uint32_t initialTableSize=64, float loadFactor=0.75f)
HashMap (uint32_t initialTableSize, float loadFactor, const Allocator &alloc)
HashMap (const Allocator &alloc)
Iterator getIterator ()

Package Attributes

__pad0__:HashMapBase<Key
Value
HashFn
Allocator HashMapBase

template<class Key, class Value, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
class physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >

Member Typedef Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
typedef HashMapBase::Iterator physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::Iterator [package]

Reimplemented from physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >.

Constructor & Destructor Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::HashMap | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline, package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::HashMap | ( | uint32_t | initialTableSize,
 |  | float | loadFactor,
 |  | const Allocator & | alloc |
 | ) |  |  | [inline, package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::HashMap ( const Allocator & alloc ) [inline, package]

Member Function Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
Iterator physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::getIterator ( ) [inline, package]

Reimplemented from physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >.

Member Data Documentation

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::__pad0__ [package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::HashFn [package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
Allocator physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::HashMapBase [package]

template<class Key , class Value , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >::Value [package]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashMap.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > Class Template Reference

physx::shdfnd::internal::HashMapBase

physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > Class Template Reference

#include <PsHashInternals.h>

List of all members.

Classes

struct | GetKey

Public Types

typedef Pair< const Key, Value > | Entry
typedef HashBase< Entry, Key,
HashFn, GetKey, Allocator,
true > 		BaseMap
typedef BaseMap::Iter | Iterator

Public Member Functions

HashMapBase (uint32_t initialTableSize, float loadFactor, const Allocator &alloc)
HashMapBase (const Allocator &alloc)
HashMapBase (uint32_t initialTableSize=64, float loadFactor=0.75f)
bool | insert (const Keyk, const Valuev)
Value & | operator[] (const Key &k)
PX_INLINE const Entry * | find (const Key &k) const
PX_INLINE bool | erase (const Key &k)
PX_INLINE uint32_t | size () const
PX_INLINE uint32_t | capacity () const
PX_INLINE Iterator | getIterator ()
PX_INLINE void | reserve (uint32_t size)
PX_INLINE void | clear ()

Protected Attributes

BaseMap mBase

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
class physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >

Member Typedef Documentation

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
typedef HashBase<Entry, Key, HashFn, GetKey, Allocator, true> physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::BaseMap

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
typedef Pair<const Key, Value> physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::Entry

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
typedef BaseMap::Iter physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::Iterator

Reimplemented in physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >.

Constructor & Destructor Documentation

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase | ( | uint32_t | initialTableSize,
 |  | float | loadFactor,
 |  | const Allocator & | alloc |
 | ) |  |  | [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase ( const Allocator & alloc ) [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline]

Member Function Documentation

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE uint32_t physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::capacity ( ) const [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE void physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::clear ( ) [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE bool physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::erase ( const Key & k ) [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE const Entry* physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::find ( const Key & k ) const [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE Iterator physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::getIterator ( ) [inline]

Reimplemented in physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >.

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
bool physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::insert | ( | const Key | k,
 |  | const Value | v |
 | ) |  |  | [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
Value& physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::operator[] ( const Key & k ) [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE void physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::reserve ( uint32_t size ) [inline]

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE uint32_t physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::size ( ) const [inline]

Member Data Documentation

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
BaseMap physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::mBase [protected]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey Struct Reference

physx::shdfnd::internal::HashMapBase::GetKey

physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey Struct Reference

#include <PsHashInternals.h>

List of all members.

Public Member Functions

PX_INLINE const Key & operator() (const Entry &e)

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
struct physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::GetKey

Member Function Documentation

template<class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
PX_INLINE const Key& physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey::operator() ( const Entry & e ) [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::HashSet< Key, HashFn, Allocator > Class Template Reference

physx::shdfnd::HashSet

physx::shdfnd::HashSet< Key, HashFn, Allocator > Class Template Reference

#include <PsHashSet.h>

Inheritance diagram for physx::shdfnd::HashSet< Key, HashFn, Allocator >:

physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false >

List of all members.

Package Types

typedef HashSetBase::Iterator | Iterator

Package Functions

HashSet (uint32_t initialTableSize=64, float loadFactor=0.75f)
HashSet (uint32_t initialTableSize, float loadFactor, const Allocator &alloc)
HashSet (const Allocator &alloc)
Iterator getIterator ()

Package Attributes

__pad0__:HashSetBase<Key
HashFn
Allocator
false | HashSetBase

template<class Key, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
class physx::shdfnd::HashSet< Key, HashFn, Allocator >

Member Typedef Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
typedef HashSetBase::Iterator physx::shdfnd::HashSet< Key, HashFn, Allocator >::Iterator [package]

Reimplemented from physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false >.

Constructor & Destructor Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashSet< Key, HashFn, Allocator >::HashSet | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline, package]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashSet< Key, HashFn, Allocator >::HashSet | ( | uint32_t | initialTableSize,
 |  | float | loadFactor,
 |  | const Allocator & | alloc |
 | ) |  |  | [inline, package]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashSet< Key, HashFn, Allocator >::HashSet ( const Allocator & alloc ) [inline, package]

Member Function Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
Iterator physx::shdfnd::HashSet< Key, HashFn, Allocator >::getIterator ( ) [inline, package]

Member Data Documentation

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashSet< Key, HashFn, Allocator >::__pad0__ [package]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashSet< Key, HashFn, Allocator >::Allocator [package]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
physx::shdfnd::HashSet< Key, HashFn, Allocator >::HashFn [package]

template<class Key , class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
false physx::shdfnd::HashSet< Key, HashFn, Allocator >::HashSetBase [package]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashSet.h
Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > Class Template Reference

physx::shdfnd::internal::HashSetBase

physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > Class Template Reference

#include <PsHashInternals.h>

List of all members.

Classes

struct | GetKey

Public Types

typedef HashBase< Key, Key,
HashFn, GetKey, Allocator,
Coalesced > 		BaseMap
typedef BaseMap::Iter | Iterator

Public Member Functions

HashSetBase (uint32_t initialTableSize, float loadFactor, const Allocator &alloc)
HashSetBase (const Allocator &alloc)
HashSetBase (uint32_t initialTableSize=64, float loadFactor=0.75f)
bool | insert (const Key &k)
PX_INLINE bool | contains (const Key &k) const
PX_INLINE bool | erase (const Key &k)
PX_INLINE uint32_t | size () const
PX_INLINE uint32_t | capacity () const
PX_INLINE void | reserve (uint32_t size)
PX_INLINE void | clear ()

Protected Attributes

BaseMap mBase

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
class physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >

Member Typedef Documentation

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
typedef HashBase<Key, Key, HashFn, GetKey, Allocator, Coalesced> physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::BaseMap

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
typedef BaseMap::Iter physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::Iterator

Reimplemented in physx::shdfnd::HashSet< Key, HashFn, Allocator >.

Constructor & Destructor Documentation

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase | ( | uint32_t | initialTableSize,
 |  | float | loadFactor,
 |  | const Allocator & | alloc |
 | ) |  |  | [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase ( const Allocator & alloc ) [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase | ( | uint32_t | initialTableSize = 64,
 |  | float | loadFactor = 0.75f |
 | ) |  |  | [inline]

Member Function Documentation

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE uint32_t physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::capacity ( ) const [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE void physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::clear ( ) [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE bool physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::contains ( const Key & k ) const [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE bool physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::erase ( const Key & k ) [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
bool physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::insert ( const Key & k ) [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE void physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::reserve ( uint32_t size ) [inline]

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE uint32_t physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::size ( ) const [inline]

Member Data Documentation

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
BaseMap physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::mBase [protected]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey Struct Reference

physx::shdfnd::internal::HashSetBase::GetKey

physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey Struct Reference

#include <PsHashInternals.h>

List of all members.

Public Member Functions

PX_INLINE const Key & operator() (const Key &e)

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
struct physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::GetKey

Member Function Documentation

template<class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
PX_INLINE const Key& physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey::operator() ( const Key & e ) [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::InlineAllocator< N, BaseAllocator > Class Template Reference

physx::shdfnd::InlineAllocator

physx::shdfnd::InlineAllocator< N, BaseAllocator > Class Template Reference

#include <PsInlineAllocator.h>

List of all members.

Public Member Functions

InlineAllocator (const PxEMPTY v)
InlineAllocator (const BaseAllocator &alloc=BaseAllocator())
InlineAllocator (const InlineAllocator &aloc)
void * | allocate (uint32_t size, const char *filename, int line)
void | deallocate (void *ptr)
PX_FORCE_INLINE uint8_t * | getInlineBuffer ()
PX_FORCE_INLINE bool | isBufferUsed () const

Protected Attributes

uint8_t | mBuffer [N]
bool | mBufferUsed

template<uint32_t N, typename BaseAllocator>
class physx::shdfnd::InlineAllocator< N, BaseAllocator >

Constructor & Destructor Documentation

template<uint32_t N, typename BaseAllocator>
physx::shdfnd::InlineAllocator< N, BaseAllocator >::InlineAllocator ( const PxEMPTY v ) [inline]

template<uint32_t N, typename BaseAllocator>
physx::shdfnd::InlineAllocator< N, BaseAllocator >::InlineAllocator ( const BaseAllocator & alloc = BaseAllocator() ) [inline]

template<uint32_t N, typename BaseAllocator>
physx::shdfnd::InlineAllocator< N, BaseAllocator >::InlineAllocator ( const InlineAllocator< N, BaseAllocator > & aloc ) [inline]

Member Function Documentation

template<uint32_t N, typename BaseAllocator>
void* physx::shdfnd::InlineAllocator< N, BaseAllocator >::allocate | ( | uint32_t | size,
 |  | const char * | filename,
 |  | int | line |
 | ) |  |  | [inline]

template<uint32_t N, typename BaseAllocator>
void physx::shdfnd::InlineAllocator< N, BaseAllocator >::deallocate ( void * ptr ) [inline]

Reimplemented in physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > >, and physx::shdfnd::Array< void *, InlineAllocator< N *sizeof(void *), Alloc > >.

template<uint32_t N, typename BaseAllocator>
PX_FORCE_INLINE uint8_t* physx::shdfnd::InlineAllocator< N, BaseAllocator >::getInlineBuffer ( ) [inline]

template<uint32_t N, typename BaseAllocator>
PX_FORCE_INLINE bool physx::shdfnd::InlineAllocator< N, BaseAllocator >::isBufferUsed ( ) const [inline]

Member Data Documentation

template<uint32_t N, typename BaseAllocator>
uint8_t physx::shdfnd::InlineAllocator< N, BaseAllocator >::mBuffer[N] [protected]

template<uint32_t N, typename BaseAllocator>
bool physx::shdfnd::InlineAllocator< N, BaseAllocator >::mBufferUsed [protected]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineAllocator.h
Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::InlineArray< T, N, Alloc > Class Template Reference

physx::shdfnd::InlineArray

physx::shdfnd::InlineArray< T, N, Alloc > Class Template Reference

#include <PsInlineArray.h>

Inheritance diagram for physx::shdfnd::InlineArray< T, N, Alloc >:

physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > Alloc

List of all members.

Public Member Functions

InlineArray (const PxEMPTY v)
PX_INLINE bool | isInlined () const
PX_INLINE | InlineArray (const Alloc &alloc=Alloc())

template<typename T, uint32_t N, typename Alloc = typename AllocatorTraits<T>::Type>
class physx::shdfnd::InlineArray< T, N, Alloc >

Constructor & Destructor Documentation

template<typename T, uint32_t N, typename Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::InlineArray< T, N, Alloc >::InlineArray ( const PxEMPTY v ) [inline]

template<typename T, uint32_t N, typename Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE physx::shdfnd::InlineArray< T, N, Alloc >::InlineArray ( const Alloc & alloc = Alloc() ) [inline, explicit]

Member Function Documentation

template<typename T, uint32_t N, typename Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE bool physx::shdfnd::InlineArray< T, N, Alloc >::isInlined ( ) const [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineArray.h
Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Less< A > Struct Template Reference

physx::shdfnd::Less

physx::shdfnd::Less< A > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Public Member Functions

bool operator() (const A &a, const A &b) const

template<typename A>
struct physx::shdfnd::Less< A >

Member Function Documentation

template<typename A >
bool physx::shdfnd::Less< A >::operator() | ( | const A & | a,
 |  | const A & | b |
 | ) |  |  | const [inline]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::LogTwo< A > Struct Template Reference

physx::shdfnd::LogTwo

physx::shdfnd::LogTwo< A > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Static Public Attributes

static const unsigned int value = LogTwo<(A >> 1)>::value + 1

template<unsigned int A>
struct physx::shdfnd::LogTwo< A >

Member Data Documentation

template<unsigned int A>
const unsigned int physx::shdfnd::LogTwo< A >::value = LogTwo<(A >> 1)>::value + 1 [static]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::LogTwo< 1 > Struct Template Reference

physx::shdfnd::LogTwo< 1 >

physx::shdfnd::LogTwo< 1 > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Static Public Attributes

static const unsigned int value = 0

template<>
struct physx::shdfnd::LogTwo< 1 >

Member Data Documentation

const unsigned int physx::shdfnd::LogTwo< 1 >::value = 0 [static]

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::MutexImpl Class Reference

physx::shdfnd::MutexImpl

physx::shdfnd::MutexImpl Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

MutexImpl ()
~MutexImpl ()
void | lock ()
bool | trylock ()
void | unlock ()

Static Public Member Functions

static const uint32_t & | getSize ()

Constructor & Destructor Documentation

physx::shdfnd::MutexImpl::MutexImpl ( )

The constructor for Mutex creates a mutex. It is initially unlocked.

physx::shdfnd::MutexImpl::~MutexImpl ( )

The destructor for Mutex deletes the mutex.

Member Function Documentation

const uint32_t & physx::shdfnd::MutexImpl::getSize ( ) [static]

Size of this class.

void physx::shdfnd::MutexImpl::lock ( )

Acquire (lock) the mutex. If the mutex is already locked by another thread, this method blocks until the mutex is unlocked.

bool physx::shdfnd::MutexImpl::trylock ( )

Acquire (lock) the mutex. If the mutex is already locked by another thread, this method returns false without blocking.

void physx::shdfnd::MutexImpl::unlock ( )

Release (unlock) the mutex.

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp
Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::MutexT< Alloc > Class Template Reference

physx::shdfnd::MutexT

physx::shdfnd::MutexT< Alloc > Class Template Reference

#include <PsMutex.h>

Inheritance diagram for physx::shdfnd::MutexT< Alloc >:

Alloc

List of all members.

Classes

class | ScopedLock

Public Member Functions

MutexT (const Alloc &alloc=Alloc())
~MutexT ()
void | lock () const
bool | trylock () const
void | unlock () const

template<typename Alloc = ReflectionAllocator<MutexImpl>>
class physx::shdfnd::MutexT< Alloc >

Constructor & Destructor Documentation

template<typename Alloc = ReflectionAllocator<MutexImpl>>
physx::shdfnd::MutexT< Alloc >::MutexT ( const Alloc & alloc = Alloc() ) [inline]

The constructor for Mutex creates a mutex. It is initially unlocked.

template<typename Alloc = ReflectionAllocator<MutexImpl>>
physx::shdfnd::MutexT< Alloc >::~MutexT ( ) [inline]

The destructor for Mutex deletes the mutex.

Member Function Documentation

template<typename Alloc = ReflectionAllocator<MutexImpl>>
void physx::shdfnd::MutexT< Alloc >::lock ( ) const [inline]

Acquire (lock) the mutex. If the mutex is already locked by another thread, this method blocks until the mutex is unlocked.

template<typename Alloc = ReflectionAllocator<MutexImpl>>
bool physx::shdfnd::MutexT< Alloc >::trylock ( ) const [inline]

Acquire (lock) the mutex. If the mutex is already locked by another thread, this method returns false without blocking, returns true if lock is successfully acquired

template<typename Alloc = ReflectionAllocator<MutexImpl>>
void physx::shdfnd::MutexT< Alloc >::unlock ( ) const [inline]

Release (unlock) the mutex, the calling thread must have previously called lock() or method will error

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock Class Reference

physx::shdfnd::MutexT::ScopedLock

physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

PX_INLINE | ScopedLock (MutexT< Alloc > &mutex)
PX_INLINE | ~ScopedLock ()

template<typename Alloc = ReflectionAllocator<MutexImpl>>
class physx::shdfnd::MutexT< Alloc >::ScopedLock

Constructor & Destructor Documentation

template<typename Alloc = ReflectionAllocator<MutexImpl>>
PX_INLINE physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock::ScopedLock ( MutexT< Alloc > & mutex ) [inline]

template<typename Alloc = ReflectionAllocator<MutexImpl>>
PX_INLINE physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock::~ScopedLock ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::NonTrackingAllocator Class Reference

physx::shdfnd::NonTrackingAllocator

physx::shdfnd::NonTrackingAllocator Class Reference

#include <PsAllocator.h>

List of all members.

Public Member Functions

PX_FORCE_INLINE | NonTrackingAllocator (const char *=0)
PX_FORCE_INLINE void * | allocate (size_t size, const char *file, int line)
PX_FORCE_INLINE void | deallocate (void *ptr)

Constructor & Destructor Documentation

PX_FORCE_INLINE physx::shdfnd::NonTrackingAllocator::NonTrackingAllocator ( const char * = 0 ) [inline]

Member Function Documentation

PX_FORCE_INLINE void* physx::shdfnd::NonTrackingAllocator::allocate | ( | size_t | size,
 |  | const char * | file,
 |  | int | line |
 | ) |  |  | [inline]

PX_FORCE_INLINE void physx::shdfnd::NonTrackingAllocator::deallocate ( void * ptr ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Pair< F, S > Class Template Reference

physx::shdfnd::Pair

physx::shdfnd::Pair< F, S > Class Template Reference

#include <PsBasicTemplates.h>

List of all members.

Public Member Functions

Pair ()
Pair (const F &f, const S &s)
Pair (const Pair &p)
Pair & | operator= (const Pair &p)
bool | operator== (const Pair &p) const
bool | operator< (const Pair &p) const

Public Attributes

F | first
S | second

template<class F, class S>
class physx::shdfnd::Pair< F, S >

Constructor & Destructor Documentation

template<class F, class S>
physx::shdfnd::Pair< F, S >::Pair ( ) [inline]

template<class F, class S>
physx::shdfnd::Pair< F, S >::Pair | ( | const F & | f,
 |  | const S & | s |
 | ) |  |  | [inline]

template<class F, class S>
physx::shdfnd::Pair< F, S >::Pair ( const Pair< F, S > & p ) [inline]

Member Function Documentation

template<class F, class S>
bool physx::shdfnd::Pair< F, S >::operator< ( const Pair< F, S > & p ) const [inline]

template<class F, class S>
Pair& physx::shdfnd::Pair< F, S >::operator= ( const Pair< F, S > & p ) [inline]

template<class F, class S>
bool physx::shdfnd::Pair< F, S >::operator== ( const Pair< F, S > & p ) const [inline]

Member Data Documentation

template<class F, class S>
F physx::shdfnd::Pair< F, S >::first

template<class F, class S>
S physx::shdfnd::Pair< F, S >::second

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Pool< T, Alloc > Class Template Reference

physx::shdfnd::Pool

physx::shdfnd::Pool< T, Alloc > Class Template Reference

#include <PsPool.h>

Inheritance diagram for physx::shdfnd::Pool< T, Alloc >:

physx::shdfnd::PoolBase< T, Alloc > physx::shdfnd::UserAllocated Alloc

List of all members.

Public Member Functions

Pool (const Alloc &alloc=Alloc(), uint32_t elementsPerSlab=32)

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
class physx::shdfnd::Pool< T, Alloc >

Constructor & Destructor Documentation

template<class T , class Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::Pool< T, Alloc >::Pool | ( | const Alloc & | alloc = Alloc(),
 |  | uint32_t | elementsPerSlab = 32 |
 | ) |  |  | [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Pool2< T, slabSize, Alloc > Class Template Reference

physx::shdfnd::Pool2

physx::shdfnd::Pool2< T, slabSize, Alloc > Class Template Reference

#include <PsPool.h>

Inheritance diagram for physx::shdfnd::Pool2< T, slabSize, Alloc >:

physx::shdfnd::PoolBase< T, Alloc > physx::shdfnd::UserAllocated Alloc

List of all members.

Public Member Functions

Pool2 (const Alloc &alloc=Alloc())

template<class T, uint32_t slabSize, class Alloc = typename AllocatorTraits<T>::Type>
class physx::shdfnd::Pool2< T, slabSize, Alloc >

Constructor & Destructor Documentation

template<class T , uint32_t slabSize, class Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::Pool2< T, slabSize, Alloc >::Pool2 ( const Alloc & alloc = Alloc() ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::PoolBase< T, Alloc > Class Template Reference

physx::shdfnd::PoolBase

physx::shdfnd::PoolBase< T, Alloc > Class Template Reference

#include <PsPool.h>

Inheritance diagram for physx::shdfnd::PoolBase< T, Alloc >:

physx::shdfnd::UserAllocated Alloc

List of all members.

Classes

struct | FreeList

Public Member Functions

~PoolBase ()
PX_INLINE T * | allocate ()
PX_INLINE void | deallocate (T *p)
PX_INLINE T * | construct ()
template<class A1 >
PX_INLINE T * | construct (A1 &a)
template<class A1 , class A2 >
PX_INLINE T * | construct (A1 &a, A2 &b)
template<class A1 , class A2 , class A3 >
PX_INLINE T * | construct (A1 &a, A2 &b, A3 &c)
template<class A1 , class A2 , class A3 >
PX_INLINE T * | construct (A1 *a, A2 &b, A3 &c)
template<class A1 , class A2 , class A3 , class A4 >
PX_INLINE T * | construct (A1 &a, A2 &b, A3 &c, A4 &d)
template<class A1 , class A2 , class A3 , class A4 , class A5 >
PX_INLINE T * | construct (A1 &a, A2 &b, A3 &c, A4 &d, A5 &e)
PX_INLINE void | destroy (T *const p)

Protected Member Functions

PoolBase (const Alloc &alloc, uint32_t elementsPerSlab, uint32_t slabSize)
void | push (FreeList *p)
void | allocateSlab ()
void | disposeElements ()
void | releaseEmptySlabs ()

Protected Attributes

InlineArray< void *, 64, Alloc > | mSlabs
uint32_t | mElementsPerSlab
uint32_t | mUsed
uint32_t | mSlabSize
FreeList * mFreeElement

Detailed Description

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
class physx::shdfnd::PoolBase< T, Alloc >

Simple allocation pool

Constructor & Destructor Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::PoolBase< T, Alloc >::PoolBase | ( | const Alloc & | alloc,
 |  | uint32_t | elementsPerSlab,
 |  | uint32_t | slabSize |
 | ) |  |  | [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
physx::shdfnd::PoolBase< T, Alloc >::~PoolBase ( ) [inline]

Member Function Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::allocate ( ) [inline]

Mark a specified amount of memory with 0xcd pattern. This is used to check that the meta data definition for serialized classes is complete in checked builds.

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
void physx::shdfnd::PoolBase< T, Alloc >::allocateSlab ( ) [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A1 , class A2 , class A3 , class A4 , class A5 >
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct | ( | A1 & | a,
 |  | A2 & | b,
 |  | A3 & | c,
 |  | A4 & | d,
 |  | A5 & | e |
 | ) |  |  | [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A1 , class A2 , class A3 , class A4 >
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct | ( | A1 & | a,
 |  | A2 & | b,
 |  | A3 & | c,
 |  | A4 & | d |
 | ) |  |  | [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A1 , class A2 , class A3 >
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct | ( | A1 * | a,
 |  | A2 & | b,
 |  | A3 & | c |
 | ) |  |  | [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A1 , class A2 , class A3 >
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct | ( | A1 & | a,
 |  | A2 & | b,
 |  | A3 & | c |
 | ) |  |  | [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A1 , class A2 >
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct | ( | A1 & | a,
 |  | A2 & | b |
 | ) |  |  | [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
template<class A1 >
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct ( A1 & a ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE T* physx::shdfnd::PoolBase< T, Alloc >::construct ( ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::PoolBase< T, Alloc >::deallocate ( T * p ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
PX_INLINE void physx::shdfnd::PoolBase< T, Alloc >::destroy ( T *const p ) [inline]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
void physx::shdfnd::PoolBase< T, Alloc >::disposeElements ( ) [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
void physx::shdfnd::PoolBase< T, Alloc >::push ( FreeList * p ) [inline, protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
void physx::shdfnd::PoolBase< T, Alloc >::releaseEmptySlabs ( ) [inline, protected]

Member Data Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
uint32_t physx::shdfnd::PoolBase< T, Alloc >::mElementsPerSlab [protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
FreeList* physx::shdfnd::PoolBase< T, Alloc >::mFreeElement [protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
InlineArray<void*, 64, Alloc> physx::shdfnd::PoolBase< T, Alloc >::mSlabs [protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
uint32_t physx::shdfnd::PoolBase< T, Alloc >::mSlabSize [protected]

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
uint32_t physx::shdfnd::PoolBase< T, Alloc >::mUsed [protected]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList Struct Reference

physx::shdfnd::PoolBase::FreeList

physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList Struct Reference

#include <PsPool.h>

List of all members.

Public Attributes

FreeList * mNext

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
struct physx::shdfnd::PoolBase< T, Alloc >::FreeList

Member Data Documentation

template<class T, class Alloc = typename AllocatorTraits<T>::Type>
FreeList* physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList::mNext

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::RawAllocator Class Reference

physx::shdfnd::RawAllocator

physx::shdfnd::RawAllocator Class Reference

#include <PsAllocator.h>

List of all members.

Public Member Functions

RawAllocator (const char *=0)
void * | allocate (size_t size, const char *, int)
void | deallocate (void *ptr)

Constructor & Destructor Documentation

physx::shdfnd::RawAllocator::RawAllocator ( const char * = 0 ) [inline]

Member Function Documentation

void* physx::shdfnd::RawAllocator::allocate | ( | size_t | size,
 |  | const char * | ,
 |  | int |  |
 | ) |  |  | [inline]

void physx::shdfnd::RawAllocator::deallocate ( void * ptr ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ReadWriteLock Class Reference

physx::shdfnd::ReadWriteLock

physx::shdfnd::ReadWriteLock Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

ReadWriteLock ()
~ReadWriteLock ()
void | lockReader ()
void | lockWriter ()
void | unlockReader ()
void | unlockWriter ()

Constructor & Destructor Documentation

physx::shdfnd::ReadWriteLock::ReadWriteLock ( )

physx::shdfnd::ReadWriteLock::~ReadWriteLock ( )

Member Function Documentation

void physx::shdfnd::ReadWriteLock::lockReader ( )

void physx::shdfnd::ReadWriteLock::lockWriter ( )

void physx::shdfnd::ReadWriteLock::unlockReader ( )

void physx::shdfnd::ReadWriteLock::unlockWriter ( )

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ReadWriteLockImpl Class Reference

physx::shdfnd::ReadWriteLockImpl

physx::shdfnd::ReadWriteLockImpl Class Reference

List of all members.

Public Member Functions

ReadWriteLockImpl ()

Public Attributes

Mutex mutex
volatile LONG readerCount

Constructor & Destructor Documentation

physx::shdfnd::ReadWriteLockImpl::ReadWriteLockImpl ( ) [inline]

Member Data Documentation

Mutex physx::shdfnd::ReadWriteLockImpl::mutex

volatile LONG physx::shdfnd::ReadWriteLockImpl::readerCount

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ReflectionAllocator< T > Class Template Reference

physx::shdfnd::ReflectionAllocator

physx::shdfnd::ReflectionAllocator< T > Class Template Reference

#include <PsAllocator.h>

List of all members.

Public Member Functions

ReflectionAllocator (const PxEMPTY)
ReflectionAllocator (const char *=0)
ReflectionAllocator (const ReflectionAllocator &)
void * | allocate (size_t size, const char *filename, int line)
void | deallocate (void *ptr)

Detailed Description

template<typename T>
class physx::shdfnd::ReflectionAllocator< T >

Allocator used to access the global PxAllocatorCallback instance using a static name derived from T.

Constructor & Destructor Documentation

template<typename T>
physx::shdfnd::ReflectionAllocator< T >::ReflectionAllocator ( const PxEMPTY ) [inline]

template<typename T>
physx::shdfnd::ReflectionAllocator< T >::ReflectionAllocator ( const char * = 0 ) [inline]

template<typename T>
physx::shdfnd::ReflectionAllocator< T >::ReflectionAllocator ( const ReflectionAllocator< T > & ) [inline]

Member Function Documentation

template<typename T>
void* physx::shdfnd::ReflectionAllocator< T >::allocate | ( | size_t | size,
 |  | const char * | filename,
 |  | int | line |
 | ) |  |  | [inline]

template<typename T>
void physx::shdfnd::ReflectionAllocator< T >::deallocate ( void * ptr ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Runnable Class Reference

physx::shdfnd::Runnable

physx::shdfnd::Runnable Class Reference

#include <PsThread.h>

Inheritance diagram for physx::shdfnd::Runnable:

physx::shdfnd::ThreadT< Alloc >

List of all members.

Public Member Functions

Runnable ()
virtual | ~Runnable ()
virtual void | execute (void)

Constructor & Destructor Documentation

physx::shdfnd::Runnable::Runnable ( ) [inline]

virtual physx::shdfnd::Runnable::~Runnable ( ) [inline, virtual]

Member Function Documentation

virtual void physx::shdfnd::Runnable::execute ( void ) [inline, virtual]

Reimplemented in physx::shdfnd::ThreadT< Alloc >.

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ScopedAtomicLock Class Reference

physx::shdfnd::ScopedAtomicLock

physx::shdfnd::ScopedAtomicLock Class Reference

#include <PsMutex.h>

List of all members.

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ScopedPointer< T, Alloc > Class Template Reference

physx::shdfnd::ScopedPointer

physx::shdfnd::ScopedPointer< T, Alloc > Class Template Reference

#include <PsAlloca.h>

Inheritance diagram for physx::shdfnd::ScopedPointer< T, Alloc >:

Alloc

List of all members.

Public Member Functions

~ScopedPointer ()
operator T * () const

Public Attributes

T * | mPointer
bool | mOwned

template<typename T, typename Alloc = TempAllocator>
class physx::shdfnd::ScopedPointer< T, Alloc >

Constructor & Destructor Documentation

template<typename T, typename Alloc = TempAllocator>
physx::shdfnd::ScopedPointer< T, Alloc >::~ScopedPointer ( ) [inline]

Member Function Documentation

template<typename T, typename Alloc = TempAllocator>
physx::shdfnd::ScopedPointer< T, Alloc >::operator T * ( ) const [inline]

Member Data Documentation

template<typename T, typename Alloc = TempAllocator>
bool physx::shdfnd::ScopedPointer< T, Alloc >::mOwned

template<typename T, typename Alloc = TempAllocator>
T* physx::shdfnd::ScopedPointer< T, Alloc >::mPointer

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlloca.h
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ScopedReadLock Class Reference

physx::shdfnd::ScopedReadLock

physx::shdfnd::ScopedReadLock Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

PX_INLINE | ScopedReadLock (ReadWriteLock &lock)
PX_INLINE | ~ScopedReadLock ()

Constructor & Destructor Documentation

PX_INLINE physx::shdfnd::ScopedReadLock::ScopedReadLock ( ReadWriteLock & lock ) [inline]

PX_INLINE physx::shdfnd::ScopedReadLock::~ScopedReadLock ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ScopedWriteLock Class Reference

physx::shdfnd::ScopedWriteLock

physx::shdfnd::ScopedWriteLock Class Reference

#include <PsMutex.h>

List of all members.

Public Member Functions

PX_INLINE | ScopedWriteLock (ReadWriteLock &lock)
PX_INLINE | ~ScopedWriteLock ()

Constructor & Destructor Documentation

PX_INLINE physx::shdfnd::ScopedWriteLock::ScopedWriteLock ( ReadWriteLock & lock ) [inline]

PX_INLINE physx::shdfnd::ScopedWriteLock::~ScopedWriteLock ( ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h
Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::SIMDGuard Class Reference

physx::shdfnd::SIMDGuard

physx::shdfnd::SIMDGuard Class Reference

#include <PsFPU.h>

List of all members.

Public Member Functions

PX_INLINE | SIMDGuard ()
PX_INLINE | ~SIMDGuard ()

Constructor & Destructor Documentation

PX_INLINE physx::shdfnd::SIMDGuard::SIMDGuard ( )

PX_INLINE physx::shdfnd::SIMDGuard::~SIMDGuard ( )

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsFPU.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsFPU.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::SListImpl Struct Reference

physx::shdfnd::SListImpl

physx::shdfnd::SListImpl Struct Reference

#include <PsSList.h>

List of all members.

Public Member Functions

SListImpl ()
~SListImpl ()
void | push (SListEntry *entry)
SListEntry * | pop ()
SListEntry * | flush ()

Static Public Member Functions

static const uint32_t & | getSize ()

Constructor & Destructor Documentation

physx::shdfnd::SListImpl::SListImpl ( )

physx::shdfnd::SListImpl::~SListImpl ( )

Member Function Documentation

SListEntry * physx::shdfnd::SListImpl::flush ( )

const uint32_t & physx::shdfnd::SListImpl::getSize ( ) [static]

SListEntry * physx::shdfnd::SListImpl::pop ( )

void physx::shdfnd::SListImpl::push ( SListEntry * entry )

The documentation for this struct was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSList.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSList.cpp
Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::SListT< Alloc > Class Template Reference

physx::shdfnd::SListT

physx::shdfnd::SListT< Alloc > Class Template Reference

#include <PsSList.h>

Inheritance diagram for physx::shdfnd::SListT< Alloc >:

Alloc

List of all members.

Public Member Functions

SListT (const Alloc &alloc=Alloc())
~SListT ()
void | push (SListEntry &entry)
SListEntry * | pop ()
SListEntry * | flush ()

template<typename Alloc = ReflectionAllocator<SListImpl>>
class physx::shdfnd::SListT< Alloc >

Constructor & Destructor Documentation

template<typename Alloc = ReflectionAllocator<SListImpl>>
physx::shdfnd::SListT< Alloc >::SListT ( const Alloc & alloc = Alloc() ) [inline]

template<typename Alloc = ReflectionAllocator<SListImpl>>
physx::shdfnd::SListT< Alloc >::~SListT ( ) [inline]

Member Function Documentation

template<typename Alloc = ReflectionAllocator<SListImpl>>
SListEntry* physx::shdfnd::SListT< Alloc >::flush ( ) [inline]

template<typename Alloc = ReflectionAllocator<SListImpl>>
SListEntry* physx::shdfnd::SListT< Alloc >::pop ( ) [inline]

template<typename Alloc = ReflectionAllocator<SListImpl>>
void physx::shdfnd::SListT< Alloc >::push ( SListEntry & entry ) [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSList.h
Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Socket Class Reference

physx::shdfnd::Socket

physx::shdfnd::Socket Class Reference

#include <PsSocket.h>

Inheritance diagram for physx::shdfnd::Socket:

physx::shdfnd::UserAllocated

List of all members.

Public Member Functions

Socket (bool inEnableBuffering=true, bool blocking=true)
virtual | ~Socket ()
bool | connect (const char *host, uint16_t port, uint32_t timeout=1000)
bool | listen (uint16_t port)
bool | accept (bool block)
void | disconnect ()
bool | isConnected () const
const char * | getHost () const
uint16_t | getPort () const
bool | flush ()
uint32_t | write (const uint8_t *data, uint32_t length)
uint32_t | read (uint8_t *data, uint32_t length)
void | setBlocking (bool blocking)
bool | isBlocking () const

Static Public Attributes

static const uint32_t | DEFAULT_BUFFER_SIZE = 32768

Detailed Description

Socket abstraction API

Constructor & Destructor Documentation

physx::shdfnd::Socket::Socket | ( | bool | inEnableBuffering = true,
 |  | bool | blocking = true
 | ) |  |

physx::shdfnd::Socket::~Socket ( ) [virtual]

Member Function Documentation

bool physx::shdfnd::Socket::accept ( bool block )

Accept a connection on a socket that is in listening mode

Note:
This method only supports a single connection client. Additional clients that connect to the listening port will overwrite the existing socket handle.

This method is not implemented on Windows Modern.

Parameters:
block whether or not the call should block
Returns:
whether a connection was established

bool physx::shdfnd::Socket::connect | ( | const char * | host,
 |  | uint16_t | port,
 |  | uint32_t | timeout = 1000
 | ) |  |

Opens a network socket for input and/or output

Parameters:
host | Name of the host to connect to. This can be an IP, URL, etc
port | The port to connect to on the remote host
timeout | Timeout in ms until the connection must be established.
Returns:
True if the connection was successful, false otherwise

void physx::shdfnd::Socket::disconnect ( )

Disconnects an open socket

bool physx::shdfnd::Socket::flush ( )

Flushes the output stream. Until the stream is flushed, there is no guarantee that the written data has actually reached the destination storage. Flush forces all buffered data to be sent to the output.

Note:
flush always blocks. If the socket is in non-blocking mode, this will result the thread spinning.
Returns:
True if the flush was successful, false otherwise

const char * physx::shdfnd::Socket::getHost ( ) const

Returns the name of the connected host. This is the same as the string that was supplied to the connect call.

Returns:
The name of the connected host

uint16_t physx::shdfnd::Socket::getPort ( ) const

Returns the port of the connected host. This is the same as the port that was supplied to the connect call.

Returns:
The port of the connected host

bool physx::shdfnd::Socket::isBlocking ( ) const

Returns whether read/write/flush calls to the socket are blocking.

Returns:
True if the socket is blocking.

bool physx::shdfnd::Socket::isConnected ( ) const

Returns whether the socket is currently open (connected) or not.

Returns:
True if the socket is connected, false otherwise

bool physx::shdfnd::Socket::listen ( uint16_t port )

Opens a network socket for input and/or output as a server. Put the connection in listening mode

Parameters:
port The port on which the socket listens
Note:
This method is not implemented on Windows Modern.

uint32_t physx::shdfnd::Socket::read | ( | uint8_t * | data,
 |  | uint32_t | length
 | ) |  |

Reads data from the output stream.

Parameters:
data | Pointer to a buffer where the read data will be stored.
length | Amount of data to read, in bytes.
Returns:
Number of bytes actually read. This could be lower than length if the stream end is encountered or the socket is non-blocking.

void physx::shdfnd::Socket::setBlocking ( bool blocking )

Sets blocking mode of the socket. Socket must be connected, otherwise calling this method won't take any effect.

uint32_t physx::shdfnd::Socket::write | ( | const uint8_t * | data,
 |  | uint32_t | length
 | ) |  |

Writes data to the output stream.

Parameters:
data | Pointer to a block of data to write to the stream
length | Amount of data to write, in bytes
Returns:
Number of bytes actually written. This could be lower than length if the socket is non-blocking.

Member Data Documentation

const uint32_t physx::shdfnd::Socket::DEFAULT_BUFFER_SIZE = 32768 [static]

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSocket.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp
Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::SocketImpl Class Reference

physx::shdfnd::SocketImpl

physx::shdfnd::SocketImpl Class Reference

Inheritance diagram for physx::shdfnd::SocketImpl:

physx::shdfnd::BufferedSocketImpl

List of all members.

Public Member Functions

SocketImpl (bool isBlocking)
virtual | ~SocketImpl ()
bool | connect (const char *host, uint16_t port, uint32_t timeout)
bool | listen (uint16_t port)
bool | accept (bool block)
void | disconnect ()
void | setBlocking (bool blocking)
virtual uint32_t | write (const uint8_t *data, uint32_t length)
virtual bool | flush ()
uint32_t | read (uint8_t *data, uint32_t length)
PX_FORCE_INLINE bool | isBlocking () const
PX_FORCE_INLINE bool | isConnected () const
PX_FORCE_INLINE const char * | getHost () const
PX_FORCE_INLINE uint16_t | getPort () const

Protected Member Functions

bool | nonBlockingTimeout () const
void | setBlockingInternal (SOCKET socket, bool blocking)

Protected Attributes

SOCKET | mSocket
SOCKET | mListenSocket
const char * | mHost
uint16_t | mPort
bool | mIsConnected
bool | mIsBlocking
bool | mListenMode
bool | mSocketLayerIntialized

Constructor & Destructor Documentation

physx::shdfnd::SocketImpl::SocketImpl ( bool isBlocking )

physx::shdfnd::SocketImpl::~SocketImpl ( ) [virtual]

Member Function Documentation

bool physx::shdfnd::SocketImpl::accept ( bool block )

bool physx::shdfnd::SocketImpl::connect | ( | const char * | host,
 |  | uint16_t | port,
 |  | uint32_t | timeout
 | ) |  |

void physx::shdfnd::SocketImpl::disconnect ( )

bool physx::shdfnd::SocketImpl::flush ( ) [virtual]

Reimplemented in physx::shdfnd::BufferedSocketImpl.

PX_FORCE_INLINE const char* physx::shdfnd::SocketImpl::getHost ( ) const [inline]

PX_FORCE_INLINE uint16_t physx::shdfnd::SocketImpl::getPort ( ) const [inline]

PX_FORCE_INLINE bool physx::shdfnd::SocketImpl::isBlocking ( ) const [inline]

PX_FORCE_INLINE bool physx::shdfnd::SocketImpl::isConnected ( ) const [inline]

bool physx::shdfnd::SocketImpl::listen ( uint16_t port )

bool physx::shdfnd::SocketImpl::nonBlockingTimeout ( ) const [protected]

uint32_t physx::shdfnd::SocketImpl::read | ( | uint8_t * | data,
 |  | uint32_t | length
 | ) |  |

void physx::shdfnd::SocketImpl::setBlocking ( bool blocking )

void physx::shdfnd::SocketImpl::setBlockingInternal | ( | SOCKET | socket,
 |  | bool | blocking |
 | ) |  |  | [protected]

uint32_t physx::shdfnd::SocketImpl::write | ( | const uint8_t * | data,
 |  | uint32_t | length |
 | ) |  |  | [virtual]

Reimplemented in physx::shdfnd::BufferedSocketImpl.

Member Data Documentation

const char* physx::shdfnd::SocketImpl::mHost [protected]

bool physx::shdfnd::SocketImpl::mIsBlocking [protected]

bool physx::shdfnd::SocketImpl::mIsConnected [mutable, protected]

bool physx::shdfnd::SocketImpl::mListenMode [protected]

SOCKET physx::shdfnd::SocketImpl::mListenSocket [protected]

uint16_t physx::shdfnd::SocketImpl::mPort [protected]

SOCKET physx::shdfnd::SocketImpl::mSocket [mutable, protected]

bool physx::shdfnd::SocketImpl::mSocketLayerIntialized [protected]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::SyncImpl Class Reference

physx::shdfnd::SyncImpl

physx::shdfnd::SyncImpl Class Reference

#include <PsSync.h>

List of all members.

Public Member Functions

SyncImpl ()
~SyncImpl ()
bool | wait (uint32_t milliseconds=waitForever)
void | set ()
void | reset ()

Static Public Member Functions

static const uint32_t & | getSize ()

Static Public Attributes

static const uint32_t | waitForever = 0xffffffff

Detailed Description

Implementation notes:
  • Calling set() on an already signaled Sync does not change its state.
  • Calling reset() on an already reset Sync does not change its state.
  • Calling set() on a reset Sync wakes all waiting threads (potential for thread contention).
  • Calling wait() on an already signaled Sync will return true immediately.
  • NOTE: be careful when pulsing an event with set() followed by reset(), because a thread that is not waiting on the event will miss the signal.

Constructor & Destructor Documentation

physx::shdfnd::SyncImpl::SyncImpl ( )

physx::shdfnd::SyncImpl::~SyncImpl ( )

Member Function Documentation

const uint32_t & physx::shdfnd::SyncImpl::getSize ( ) [static]

Size of this class.

void physx::shdfnd::SyncImpl::reset ( )

Reset the synchronization object

void physx::shdfnd::SyncImpl::set ( )

Signal the synchronization object, waking all threads waiting on it

bool physx::shdfnd::SyncImpl::wait ( uint32_t milliseconds = waitForever )

Wait on the object for at most the given number of ms. Returns true if the object is signaled. Sync::waitForever will block forever or until the object is signaled.

Member Data Documentation

const uint32_t physx::shdfnd::SyncImpl::waitForever = 0xffffffff [static]

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSync.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSync.cpp
Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::SyncT< Alloc > Class Template Reference

physx::shdfnd::SyncT

physx::shdfnd::SyncT< Alloc > Class Template Reference

#include <PsSync.h>

Inheritance diagram for physx::shdfnd::SyncT< Alloc >:

Alloc

List of all members.

Public Member Functions

SyncT (const Alloc &alloc=Alloc())
~SyncT ()
bool | wait (uint32_t milliseconds=SyncImpl::waitForever)
void | set ()
void | reset ()

Static Public Attributes

static const uint32_t | waitForever = SyncImpl::waitForever

Detailed Description

template<typename Alloc = ReflectionAllocator<SyncImpl>>
class physx::shdfnd::SyncT< Alloc >

Implementation notes:
  • Calling set() on an already signaled Sync does not change its state.
  • Calling reset() on an already reset Sync does not change its state.
  • Calling set() on a reset Sync wakes all waiting threads (potential for thread contention).
  • Calling wait() on an already signaled Sync will return true immediately.
  • NOTE: be careful when pulsing an event with set() followed by reset(), because a thread that is not waiting on the event will miss the signal.

Constructor & Destructor Documentation

template<typename Alloc = ReflectionAllocator<SyncImpl>>
physx::shdfnd::SyncT< Alloc >::SyncT ( const Alloc & alloc = Alloc() ) [inline]

template<typename Alloc = ReflectionAllocator<SyncImpl>>
physx::shdfnd::SyncT< Alloc >::~SyncT ( ) [inline]

Member Function Documentation

template<typename Alloc = ReflectionAllocator<SyncImpl>>
void physx::shdfnd::SyncT< Alloc >::reset ( ) [inline]

Reset the synchronization object

template<typename Alloc = ReflectionAllocator<SyncImpl>>
void physx::shdfnd::SyncT< Alloc >::set ( ) [inline]

Signal the synchronization object, waking all threads waiting on it

template<typename Alloc = ReflectionAllocator<SyncImpl>>
bool physx::shdfnd::SyncT< Alloc >::wait ( uint32_t milliseconds = SyncImpl::waitForever ) [inline]

Wait on the object for at most the given number of ms. Returns true if the object is signaled. Sync::waitForever will block forever or until the object is signaled.

Member Data Documentation

template<typename Alloc = ReflectionAllocator<SyncImpl>>
const uint32_t physx::shdfnd::SyncT< Alloc >::waitForever = SyncImpl::waitForever [static]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSync.h
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::TempAllocator Class Reference

physx::shdfnd::TempAllocator

physx::shdfnd::TempAllocator Class Reference

#include <PsTempAllocator.h>

List of all members.

Public Member Functions

PX_FORCE_INLINE | TempAllocator (const char *=0)
PX_FOUNDATION_API void * | allocate (size_t size, const char *file, int line)
PX_FOUNDATION_API void | deallocate (void *ptr)

Constructor & Destructor Documentation

PX_FORCE_INLINE physx::shdfnd::TempAllocator::TempAllocator ( const char * = 0 ) [inline]

Member Function Documentation

void * physx::shdfnd::TempAllocator::allocate | ( | size_t | size,
 |  | const char * | file,
 |  | int | line
 | ) |  |

void physx::shdfnd::TempAllocator::deallocate ( void * ptr )

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTempAllocator.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsTempAllocator.cpp
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::TempAllocatorChunk Union Reference

physx::shdfnd::TempAllocatorChunk

physx::shdfnd::TempAllocatorChunk Union Reference

#include <PsTempAllocator.h>

List of all members.

Public Member Functions

TempAllocatorChunk ()

Public Attributes

TempAllocatorChunk * mNext
uint32_t | mIndex
uint8_t | mPad [16]

Constructor & Destructor Documentation

physx::shdfnd::TempAllocatorChunk::TempAllocatorChunk ( ) [inline]

Member Data Documentation

uint32_t physx::shdfnd::TempAllocatorChunk::mIndex

TempAllocatorChunk* physx::shdfnd::TempAllocatorChunk::mNext

uint8_t physx::shdfnd::TempAllocatorChunk::mPad[16]

The documentation for this union was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTempAllocator.h
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ThreadImpl Class Reference

physx::shdfnd::ThreadImpl

physx::shdfnd::ThreadImpl Class Reference

#include <PsThread.h>

List of all members.

Public Types

typedef size_t | Id
typedef void *(* | ExecuteFn )(void *)

Public Member Functions

ThreadImpl ()
ThreadImpl (ExecuteFn fn, void *arg)
~ThreadImpl ()
void | start (uint32_t stackSize, Runnable *r)
void | kill ()
void | signalQuit ()
bool | waitForQuit ()
bool | quitIsSignalled ()
void | quit ()
uint32_t | setAffinityMask (uint32_t mask)
void | setPriority (ThreadPriority::Enum prio)
void | setName (const char *name)

Static Public Member Functions

static uint32_t | getDefaultStackSize ()
static Id | getId ()
static ThreadPriority::Enum | getPriority (Id threadId)
static void | sleep (uint32_t ms)
static void | yield ()
static uint32_t | getNbPhysicalCores ()
static const uint32_t & | getSize ()

Member Typedef Documentation

typedef void*(* physx::shdfnd::ThreadImpl::ExecuteFn)(void *)

typedef size_t physx::shdfnd::ThreadImpl::Id

Constructor & Destructor Documentation

physx::shdfnd::ThreadImpl::ThreadImpl ( )

Construct (but do not start) the thread object. The OS thread object will not be created until start() is called. Executes in the context of the spawning thread.

physx::shdfnd::ThreadImpl::ThreadImpl | ( | ExecuteFn | fn,
 |  | void * | arg
 | ) |  |

Construct and start the the thread, passing the given arg to the given fn. (pthread style)

physx::shdfnd::ThreadImpl::~ThreadImpl ( )

Deallocate all resources associated with the thread. Should be called in the context of the spawning thread.

Member Function Documentation

uint32_t physx::shdfnd::ThreadImpl::getDefaultStackSize ( ) [static]

ThreadImpl::Id physx::shdfnd::ThreadImpl::getId ( ) [static]

uint32_t physx::shdfnd::ThreadImpl::getNbPhysicalCores ( ) [static]

Return the number of physical cores (does not include hyper-threaded cores), returns 0 on failure

ThreadPriority::Enum physx::shdfnd::ThreadImpl::getPriority ( Id threadId ) [static]

const uint32_t & physx::shdfnd::ThreadImpl::getSize ( ) [static]

Size of this class.

void physx::shdfnd::ThreadImpl::kill ( )

Violently kill the current thread. Blunt instrument, not recommended since it can leave all kinds of things unreleased (stack, memory, mutexes...) Should be called in the context of the spawning thread.

void physx::shdfnd::ThreadImpl::quit ( )

Cleanly shut down this thread. Called in the context of the spawned thread.

bool physx::shdfnd::ThreadImpl::quitIsSignalled ( )

check whether the thread is signalled to quit. Called in the context of the spawned thread.

uint32_t physx::shdfnd::ThreadImpl::setAffinityMask ( uint32_t mask )

Change the affinity mask for this thread. The mask is a platform specific value.

On Windows, Linux, PS4 and XboxOne platforms, each set mask bit represents the index of a logical processor that the OS may schedule thread execution on. Bits outside the range of valid logical processors may be ignored or cause the function to return an error.

On Apple platforms, this function has no effect.

If the thread has not yet been started then the mask is stored and applied when the thread is started.

If the thread has already been started then this method returns the previous affinity mask on success, otherwise it returns zero.

void physx::shdfnd::ThreadImpl::setName ( const char * name )

set the thread's name

void physx::shdfnd::ThreadImpl::setPriority ( ThreadPriority::Enum prio )

Set thread priority.

void physx::shdfnd::ThreadImpl::signalQuit ( )

Stop the thread. Signals the spawned thread that it should stop, so the thread should check regularly

void physx::shdfnd::ThreadImpl::sleep ( uint32_t ms ) [static]

Put the current thread to sleep for the given number of milliseconds

void physx::shdfnd::ThreadImpl::start | ( | uint32_t | stackSize,
 |  | Runnable * | r
 | ) |  |

Create the OS thread and start it running. Called in the context of the spawning thread. If an affinity mask has previously been set then it will be applied after the thread has been created.

bool physx::shdfnd::ThreadImpl::waitForQuit ( )

Wait for a thread to stop. Should be called in the context of the spawning thread. Returns false if the thread has not been started.

void physx::shdfnd::ThreadImpl::yield ( ) [static]

Yield the current thread's slot on the CPU

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsThread.cpp
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ThreadPriority Struct Reference

physx::shdfnd::ThreadPriority

physx::shdfnd::ThreadPriority Struct Reference

#include <PsThread.h>

List of all members.

Public Types

enum Enum {
eHIGH = 0, eABOVE_NORMAL = 1, eNORMAL = 2, eBELOW_NORMAL = 3,
eLOW = 4, eFORCE_DWORD = 0xffFFffFF
}

Member Enumeration Documentation

enum physx::shdfnd::ThreadPriority::Enum

Enumerator:
eHIGH | High priority.
eABOVE_NORMAL | Above Normal priority.
eNORMAL | Normal/default priority.
eBELOW_NORMAL | Below Normal priority.
eLOW | Low priority.
eFORCE_DWORD

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::ThreadT< Alloc > Class Template Reference

physx::shdfnd::ThreadT

physx::shdfnd::ThreadT< Alloc > Class Template Reference

#include <PsThread.h>

Inheritance diagram for physx::shdfnd::ThreadT< Alloc >:

Alloc physx::shdfnd::UserAllocated physx::shdfnd::Runnable

List of all members.

Public Types

typedef ThreadImpl::Id | Id

Public Member Functions

ThreadT (const Alloc &alloc=Alloc())
ThreadT (ThreadImpl::ExecuteFn fn, void *arg, const Alloc &alloc=Alloc())
virtual | ~ThreadT ()
void | start (uint32_t stackSize=ThreadImpl::getDefaultStackSize())
void | kill ()
virtual void | execute (void)
void | signalQuit ()
bool | waitForQuit ()
bool | quitIsSignalled ()
void | quit ()
uint32_t | setAffinityMask (uint32_t mask)
void | setPriority (ThreadPriority::Enum prio)
void | setName (const char *name)

Static Public Member Functions

static ThreadPriority::Enum | getPriority (ThreadImpl::Id threadId)
static void | sleep (uint32_t ms)
static void | yield ()
static uint32_t | getDefaultStackSize ()
static ThreadImpl::Id | getId ()
static uint32_t | getNbPhysicalCores ()

Detailed Description

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
class physx::shdfnd::ThreadT< Alloc >

Thread abstraction API

Member Typedef Documentation

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
typedef ThreadImpl::Id physx::shdfnd::ThreadT< Alloc >::Id

Constructor & Destructor Documentation

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
physx::shdfnd::ThreadT< Alloc >::ThreadT ( const Alloc & alloc = Alloc() ) [inline]

Construct (but do not start) the thread object. Executes in the context of the spawning thread

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
physx::shdfnd::ThreadT< Alloc >::ThreadT | ( | ThreadImpl::ExecuteFn | fn,
 |  | void * | arg,
 |  | const Alloc & | alloc = Alloc() |
 | ) |  |  | [inline]

Construct and start the the thread, passing the given arg to the given fn. (pthread style)

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
virtual physx::shdfnd::ThreadT< Alloc >::~ThreadT ( ) [inline, virtual]

Deallocate all resources associated with the thread. Should be called in the context of the spawning thread.

Member Function Documentation

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
virtual void physx::shdfnd::ThreadT< Alloc >::execute ( void ) [inline, virtual]

The virtual execute() method is the user defined function that will run in the new thread. Called in the context of the spawned thread.

Reimplemented from physx::shdfnd::Runnable.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
static uint32_t physx::shdfnd::ThreadT< Alloc >::getDefaultStackSize ( ) [inline, static]

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
static ThreadImpl::Id physx::shdfnd::ThreadT< Alloc >::getId ( ) [inline, static]

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
static uint32_t physx::shdfnd::ThreadT< Alloc >::getNbPhysicalCores ( ) [inline, static]

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
static ThreadPriority::Enum physx::shdfnd::ThreadT< Alloc >::getPriority ( ThreadImpl::Id threadId ) [inline, static]

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
void physx::shdfnd::ThreadT< Alloc >::kill ( ) [inline]

Violently kill the current thread. Blunt instrument, not recommended since it can leave all kinds of things unreleased (stack, memory, mutexes...) Should be called in the context of the spawning thread.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
void physx::shdfnd::ThreadT< Alloc >::quit ( ) [inline]

Cleanly shut down this thread. Called in the context of the spawned thread.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
bool physx::shdfnd::ThreadT< Alloc >::quitIsSignalled ( ) [inline]

check whether the thread is signalled to quit. Called in the context of the spawned thread.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
uint32_t physx::shdfnd::ThreadT< Alloc >::setAffinityMask ( uint32_t mask ) [inline]

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
void physx::shdfnd::ThreadT< Alloc >::setName ( const char * name ) [inline]

set the thread's name

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
void physx::shdfnd::ThreadT< Alloc >::setPriority ( ThreadPriority::Enum prio ) [inline]

Set thread priority.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
void physx::shdfnd::ThreadT< Alloc >::signalQuit ( ) [inline]

stop the thread. Signals the spawned thread that it should stop, so the thread should check regularly

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
static void physx::shdfnd::ThreadT< Alloc >::sleep ( uint32_t ms ) [inline, static]

Put the current thread to sleep for the given number of milliseconds

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
void physx::shdfnd::ThreadT< Alloc >::start ( uint32_t stackSize = ThreadImpl::getDefaultStackSize() ) [inline]

start the thread running. Called in the context of the spawning thread.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
bool physx::shdfnd::ThreadT< Alloc >::waitForQuit ( ) [inline]

Wait for a thread to stop. Should be called in the context of the spawning thread. Returns false if the thread has not been started.

template<typename Alloc = ReflectionAllocator<ThreadImpl>>
static void physx::shdfnd::ThreadT< Alloc >::yield ( ) [inline, static]

Yield the current thread's slot on the CPU

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::Time Class Reference

physx::shdfnd::Time

physx::shdfnd::Time Class Reference

#include <PsTime.h>

List of all members.

Public Types

typedef double | Second

Public Member Functions

Time ()
Second getElapsedSeconds ()
Second peekElapsedSeconds ()
Second | getLastTime () const

Static Public Member Functions

static const
CounterFrequencyToTensOfNanos & 		getBootCounterFrequency ()
static
CounterFrequencyToTensOfNanos 		getCounterFrequency ()
static uint64_t | getCurrentCounterValue ()
static uint64_t | getCurrentTimeInTensOfNanoSeconds ()

Static Public Attributes

static const uint64_t | sNumTensOfNanoSecondsInASecond = 100000000

Member Typedef Documentation

typedef double physx::shdfnd::Time::Second

Constructor & Destructor Documentation

physx::shdfnd::Time::Time ( )

Member Function Documentation

const CounterFrequencyToTensOfNanos & physx::shdfnd::Time::getBootCounterFrequency ( ) [static]

CounterFrequencyToTensOfNanos physx::shdfnd::Time::getCounterFrequency ( ) [static]

uint64_t physx::shdfnd::Time::getCurrentCounterValue ( ) [static]

static uint64_t physx::shdfnd::Time::getCurrentTimeInTensOfNanoSeconds ( ) [inline, static]

Time::Second physx::shdfnd::Time::getElapsedSeconds ( )

Time::Second physx::shdfnd::Time::getLastTime ( ) const

Time::Second physx::shdfnd::Time::peekElapsedSeconds ( )

Member Data Documentation

const uint64_t physx::shdfnd::Time::sNumTensOfNanoSecondsInASecond = 100000000 [static]

The documentation for this class was generated from the following files:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTime.h
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsTime.cpp
Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::UnConst< T > Struct Template Reference

physx::shdfnd::UnConst

physx::shdfnd::UnConst< T > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Public Types

typedef T Type

template<typename T>
struct physx::shdfnd::UnConst< T >

Member Typedef Documentation

template<typename T >
typedef T physx::shdfnd::UnConst< T >::Type

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::UnConst< const T > Struct Template Reference

physx::shdfnd::UnConst< const T >

physx::shdfnd::UnConst< const T > Struct Template Reference

#include <PsBasicTemplates.h>

List of all members.

Public Types

typedef T Type

template<typename T>
struct physx::shdfnd::UnConst< const T >

Member Typedef Documentation

template<typename T >
typedef T physx::shdfnd::UnConst< const T >::Type

The documentation for this struct was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h
Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::UserAllocated Class Reference

physx::shdfnd::UserAllocated

physx::shdfnd::UserAllocated Class Reference

#include <PsUserAllocated.h>

Inheritance diagram for physx::shdfnd::UserAllocated:

physx::shdfnd::PoolBase< T, Alloc > physx::shdfnd::Socket physx::shdfnd::ThreadT< Alloc > physx::shdfnd::PoolBase< T, Alloc > physx::shdfnd::Pool< T, Alloc > physx::shdfnd::Pool2< T, slabSize, Alloc >

List of all members.

Public Member Functions

PX_INLINE void * | operator new (size_t, void *address)
PX_INLINE void | operator delete (void *, void *)
template<typename Alloc >
PX_INLINE void * | operator new (size_t size, Alloc alloc, const char *fileName, int line)
template<typename Alloc >
PX_INLINE void * | operator new[] (size_t size, Alloc alloc, const char *fileName, int line)
template<typename Alloc >
PX_INLINE void | operator delete (void *ptr, Alloc alloc, const char *fileName, int line)
template<typename Alloc >
PX_INLINE void | operator delete[] (void *ptr, Alloc alloc, const char *fileName, int line)
PX_INLINE void | operator delete (void *ptr)
PX_INLINE void | operator delete[] (void *ptr)

Detailed Description

Provides new and delete using a UserAllocator. Guarantees that 'delete x;' uses the UserAllocator too.

Member Function Documentation

PX_INLINE void physx::shdfnd::UserAllocated::operator delete ( void * ptr ) [inline]

template<typename Alloc >
PX_INLINE void physx::shdfnd::UserAllocated::operator delete | ( | void * | ptr,
 |  | Alloc | alloc,
 |  | const char * | fileName,
 |  | int | line |
 | ) |  |  | [inline]

PX_INLINE void physx::shdfnd::UserAllocated::operator delete | ( | void * | ,
 |  | void * |  |
 | ) |  |  | [inline]

PX_INLINE void physx::shdfnd::UserAllocated::operator delete[] ( void * ptr ) [inline]

template<typename Alloc >
PX_INLINE void physx::shdfnd::UserAllocated::operator delete[] | ( | void * | ptr,
 |  | Alloc | alloc,
 |  | const char * | fileName,
 |  | int | line |
 | ) |  |  | [inline]

template<typename Alloc >
PX_INLINE void* physx::shdfnd::UserAllocated::operator new | ( | size_t | size,
 |  | Alloc | alloc,
 |  | const char * | fileName,
 |  | int | line |
 | ) |  |  | [inline]

PX_INLINE void* physx::shdfnd::UserAllocated::operator new | ( | size_t | ,
 |  | void * | address |
 | ) |  |  | [inline]

template<typename Alloc >
PX_INLINE void* physx::shdfnd::UserAllocated::operator new[] | ( | size_t | size,
 |  | Alloc | alloc,
 |  | const char * | fileName,
 |  | int | line |
 | ) |  |  | [inline]

The documentation for this class was generated from the following file:
  • E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsUserAllocated.h
Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Hierarchical Index

Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
  • 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
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Key Class Reference

Key Class Reference

The documentation for this class was generated from the following files:
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- _ -

  • __pad0__ : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Namespace Index

  • Namespace List
  • Namespace Members

Namespace List

Here is a list of all namespaces with brief descriptions:
physx | Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:
physx::shdfnd |
physx::shdfnd::internal |
Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd Namespace Reference

  • Namespace List
  • Namespace Members
physx::shdfnd

physx::shdfnd Namespace Reference

Namespaces

namespace | internal

Classes

class | AlignedAllocator
class | ScopedPointer
class | RawAllocator
class | NonTrackingAllocator
class | ReflectionAllocator
struct | AllocatorTraits
union | EnableIfPod
class | Array
struct | Equal
struct | Less
struct | Greater
class | Pair
struct | LogTwo
struct | LogTwo< 1 >
struct | UnConst
struct | UnConst< const T >
class | Cpu
class | FPUGuard
class | SIMDGuard
struct | Hash
struct | Hash< const char * >
class | HashMap
class | CoalescedHashMap
class | HashSet
class | CoalescedHashSet
class | InlineAllocator
class | InlineArray
class | MutexImpl
class | MutexT
class | ReadWriteLock
class | ScopedReadLock
class | ScopedWriteLock
class | AtomicLock
class | AtomicLockCopy
class | AtomicRwLock
class | ScopedAtomicLock
class | PoolBase
class | Pool
class | Pool2
struct | SListImpl
class | SListT
class | Socket
class | SyncImpl
class | SyncT
union | TempAllocatorChunk
class | TempAllocator
struct | ThreadPriority
class | Runnable
class | ThreadImpl
class | ThreadT
struct | CounterFrequencyToTensOfNanos
class | Time
class | UserAllocated
class | ReadWriteLockImpl
class | SocketImpl
class | BufferedSocketImpl

Typedefs

typedef int | IntBool
typedef MutexT | Mutex
typedef SListT | SList
typedef SyncT | Sync
typedef ThreadT | Thread
typedef BOOL(WINAPI * | LPFN_GLPI )(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD)

Functions

void | initializeNamedAllocatorGlobals ()
void | terminateNamedAllocatorGlobals ()
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 >
PX_INLINE void | swap (Array< T, Alloc > &x, Array< T, Alloc > &y)
PX_FOUNDATION_API int32_t | atomicExchange (volatile int32_t *dest, int32_t val)
PX_FOUNDATION_API int32_t | atomicCompareExchange (volatile int32_t *dest, int32_t exch, int32_t comp)
PX_FOUNDATION_API void * | atomicCompareExchangePointer (volatile void **dest, void *exch, void *comp)
PX_FOUNDATION_API int32_t | atomicIncrement (volatile int32_t *val)
PX_FOUNDATION_API int32_t | atomicDecrement (volatile int32_t *val)
PX_FOUNDATION_API int32_t | atomicAdd (volatile int32_t *val, int32_t delta)
PX_FOUNDATION_API int32_t | atomicMax (volatile int32_t *val, int32_t val2)
template<typename T >
T | pointerOffset (void *p, ptrdiff_t offset)
template<typename T >
T | pointerOffset (const void *p, ptrdiff_t offset)
template<class T >
PX_CUDA_CALLABLE PX_INLINE void | swap (T &x, T &y)
PX_INLINE uint32_t | bitCount (uint32_t v)
PX_INLINE bool | isPowerOfTwo (uint32_t x)
PX_INLINE uint32_t | nextPowerOfTwo (uint32_t x)
PX_INLINE uint32_t | lowestSetBit (uint32_t x)
PX_INLINE uint32_t | highestSetBit (uint32_t x)
PX_INLINE uint32_t | ilog2 (uint32_t num)
PX_FOUNDATION_API void | enableFPExceptions ()
Enables floating point exceptions for the scalar and SIMD unit.
PX_FOUNDATION_API void | disableFPExceptions ()
Disables floating point exceptions for the scalar and SIMD unit.
PX_FOUNDATION_API void | initializeSharedFoundation (uint32_t version, PxAllocatorCallback &, PxErrorCallback &)
PX_FOUNDATION_API bool | sharedFoundationIsInitialized ()
PX_FOUNDATION_API void | terminateSharedFoundation ()
PX_FOUNDATION_API uint32_t | getInitializationCount ()
PX_FOUNDATION_API
PxAllocatorCallback & 		getAllocator ()
PX_FOUNDATION_API PxErrorCallback & | getErrorCallback ()
PX_FOUNDATION_API void | setReflectionAllocatorReportsNames (bool val)
PX_FOUNDATION_API bool | getReflectionAllocatorReportsNames ()
PX_FOUNDATION_API
PxProfilerCallback * 		getProfilerCallback ()
PX_FOUNDATION_API void | setProfilerCallback (PxProfilerCallback *profiler)
PX_FORCE_INLINE uint32_t | hash (const uint32_t key)
PX_FORCE_INLINE uint32_t | hash (const int32_t key)
PX_FORCE_INLINE uint32_t | hash (const uint64_t key)
PX_INLINE uint32_t | hash (const void *ptr)
template<typename F , typename S >
PX_INLINE uint32_t | hash (const Pair< F, S > &p)
__declspec (align(8)) class SListEntry
template<class T , class Predicate , class Allocator >
void | sort (T *elements, uint32_t count, const Predicate &compare, const Allocator &inAllocator, const uint32_t initialStackSize=32)
template<class T , class Predicate >
void | sort (T *elements, uint32_t count, const Predicate &compare)
template<class T >
void | sort (T *elements, uint32_t count)
PX_FOUNDATION_API int32_t | sscanf (const char *buffer, const char *format,...)
PX_FOUNDATION_API int32_t | strcmp (const char *str1, const char *str2)
PX_FOUNDATION_API int32_t | strncmp (const char *str1, const char *str2, size_t count)
PX_FOUNDATION_API int32_t | snprintf (char *dst, size_t dstSize, const char *format,...)
PX_FOUNDATION_API int32_t | vsnprintf (char *dst, size_t dstSize, const char *src, va_list arg)
PX_FOUNDATION_API size_t | strlcat (char *dst, size_t dstSize, const char *src)
PX_FOUNDATION_API size_t | strlcpy (char *dst, size_t dstSize, const char *src)
PX_FOUNDATION_API int32_t | stricmp (const char *str1, const char *str2)
PX_FOUNDATION_API int32_t | strnicmp (const char *str1, const char *str2, size_t count)
PX_FOUNDATION_API void | strlwr (char *str)
PX_FOUNDATION_API void | strupr (char *str)
PX_FOUNDATION_API void | printFormatted (const char *,...)
Prints the formatted data, trying to make sure it's visible to the app programmer.
PX_FOUNDATION_API void | printString (const char *)
Prints the string literally (does not consume % specifier), trying to make sure it's visible to the app programmer.
void | initializeTempAllocatorGlobals ()
void | terminateTempAllocatorGlobals ()
PX_FOUNDATION_API uint32_t | TlsAlloc ()
PX_FOUNDATION_API void | TlsFree (uint32_t index)
PX_FOUNDATION_API void * | TlsGet (uint32_t index)
PX_FOUNDATION_API uint32_t | TlsSet (uint32_t index, void *value)
PX_FORCE_INLINE void | memoryBarrier ()
PX_FORCE_INLINE uint32_t | highestSetBitUnsafe (uint32_t v)
PX_FORCE_INLINE uint32_t | lowestSetBitUnsafe (uint32_t v)
PX_FORCE_INLINE uint32_t | countLeadingZeros (uint32_t v)
PX_FORCE_INLINE void | prefetchLine (const void *ptr, uint32_t offset=0)
PX_FORCE_INLINE void | prefetch (const void *ptr, uint32_t count=1)
PX_CUDA_CALLABLE
PX_FORCE_INLINE float 		recipFast (float a)
platform-specific reciprocal
PX_CUDA_CALLABLE
PX_FORCE_INLINE float 		recipSqrtFast (float a)
platform-specific fast reciprocal square root
PX_CUDA_CALLABLE
PX_FORCE_INLINE float 		floatFloor (float x)
platform-specific floor

Variables

PxProfilerCallback * | gProfilerCallback = NULL
PxAllocatorCallback * | gAllocatorCallback = NULL
PxErrorCallback * | gErrorCallback = NULL
uint32_t | gInitializationCount = 0

Typedef Documentation

typedef int physx::shdfnd::IntBool

typedef BOOL(WINAPI* physx::shdfnd::LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD)

typedef MutexT physx::shdfnd::Mutex

typedef SListT physx::shdfnd::SList

typedef SyncT physx::shdfnd::Sync

typedef ThreadT physx::shdfnd::Thread

Function Documentation

physx::shdfnd::__declspec ( align(8) )

int32_t physx::shdfnd::atomicAdd | ( | volatile int32_t * | val,
 |  | int32_t | delta
 | ) |  |

int32_t physx::shdfnd::atomicCompareExchange | ( | volatile int32_t * | dest,
 |  | int32_t | exch,
 |  | int32_t | comp
 | ) |  |

void * physx::shdfnd::atomicCompareExchangePointer | ( | volatile void ** | dest,
 |  | void * | exch,
 |  | void * | comp
 | ) |  |

int32_t physx::shdfnd::atomicDecrement ( volatile int32_t * val )

int32_t physx::shdfnd::atomicExchange | ( | volatile int32_t * | dest,
 |  | int32_t | val
 | ) |  |

int32_t physx::shdfnd::atomicIncrement ( volatile int32_t * val )

int32_t physx::shdfnd::atomicMax | ( | volatile int32_t * | val,
 |  | int32_t | val2
 | ) |  |

PX_INLINE uint32_t physx::shdfnd::bitCount ( uint32_t v )

PX_FORCE_INLINE uint32_t physx::shdfnd::countLeadingZeros ( uint32_t v )

Returns the number of leading zeros in v. Returns 32 for v=0.

void physx::shdfnd::disableFPExceptions ( )

Disables floating point exceptions for the scalar and SIMD unit.

void physx::shdfnd::enableFPExceptions ( )

Enables floating point exceptions for the scalar and SIMD unit.

template<class Serializer >
void physx::shdfnd::exportArray | ( | Serializer & | stream,
 |  | const void * | data,
 |  | uint32_t | size,
 |  | uint32_t | sizeOfElement,
 |  | uint32_t | capacity |
 | ) |  |  | [inline]

PX_CUDA_CALLABLE PX_FORCE_INLINE float physx::shdfnd::floatFloor ( float x )

platform-specific floor

PxAllocatorCallback & physx::shdfnd::getAllocator ( )

PxErrorCallback & physx::shdfnd::getErrorCallback ( )

uint32_t physx::shdfnd::getInitializationCount ( )

PxProfilerCallback * physx::shdfnd::getProfilerCallback ( void )

bool physx::shdfnd::getReflectionAllocatorReportsNames ( )

template<typename F , typename S >
PX_INLINE uint32_t physx::shdfnd::hash ( const Pair< F, S > & p ) [inline]

PX_INLINE uint32_t physx::shdfnd::hash ( const void * ptr )

PX_FORCE_INLINE uint32_t physx::shdfnd::hash ( const uint64_t key )

PX_FORCE_INLINE uint32_t physx::shdfnd::hash ( const int32_t key )

PX_FORCE_INLINE uint32_t physx::shdfnd::hash ( const uint32_t key )

PX_INLINE uint32_t physx::shdfnd::highestSetBit ( uint32_t x )

Return the index of the highest set bit. Not valid for zero arg.

PX_FORCE_INLINE uint32_t physx::shdfnd::highestSetBitUnsafe ( uint32_t v )

Returns the index of the highest set bit. Not valid for zero arg.

PX_INLINE uint32_t physx::shdfnd::ilog2 ( uint32_t num )

char* physx::shdfnd::importArray | ( | char * | address,
 |  | void ** | data,
 |  | uint32_t | size,
 |  | uint32_t | sizeOfElement,
 |  | uint32_t | capacity
 | ) |  |

void physx::shdfnd::initializeNamedAllocatorGlobals ( )

Allocator used to access the global PxAllocatorCallback instance using a dynamic name.

void physx::shdfnd::initializeSharedFoundation | ( | uint32_t | version,
 |  | PxAllocatorCallback & | allocator,
 |  | PxErrorCallback & | err
 | ) |  |

void physx::shdfnd::initializeTempAllocatorGlobals ( )

PX_INLINE bool physx::shdfnd::isPowerOfTwo ( uint32_t x )

PX_INLINE uint32_t physx::shdfnd::lowestSetBit ( uint32_t x )

Return the index of the highest set bit. Not valid for zero arg.

PX_FORCE_INLINE uint32_t physx::shdfnd::lowestSetBitUnsafe ( uint32_t v )

Returns the index of the highest set bit. Undefined for zero arg.

PX_FORCE_INLINE void physx::shdfnd::memoryBarrier ( )

PX_INLINE uint32_t physx::shdfnd::nextPowerOfTwo ( uint32_t x )

template<typename T >
T physx::shdfnd::pointerOffset | ( | const void * | p,
 |  | ptrdiff_t | offset |
 | ) |  |  | [inline]

template<typename T >
T physx::shdfnd::pointerOffset | ( | void * | p,
 |  | ptrdiff_t | offset |
 | ) |  |  | [inline]

PX_FORCE_INLINE void physx::shdfnd::prefetch | ( | const void * | ptr,
 |  | uint32_t | count = 1
 | ) |  |

Prefetch count bytes starting at ptr.

PX_FORCE_INLINE void physx::shdfnd::prefetchLine | ( | const void * | ptr,
 |  | uint32_t | offset = 0
 | ) |  |

Prefetch aligned cache size around ptr+offset.

void physx::shdfnd::printFormatted | ( | const char * | format,
 |  |  | ...
 | ) |  |

Prints the formatted data, trying to make sure it's visible to the app programmer.

See also:
NS_MAX_PRINTFORMATTED_LENGTH

void physx::shdfnd::printString ( const char * str )

Prints the string literally (does not consume % specifier), trying to make sure it's visible to the app programmer.

PX_CUDA_CALLABLE PX_FORCE_INLINE float physx::shdfnd::recipFast ( float a )

platform-specific reciprocal

PX_CUDA_CALLABLE PX_FORCE_INLINE float physx::shdfnd::recipSqrtFast ( float a )

platform-specific fast reciprocal square root

void physx::shdfnd::setProfilerCallback ( PxProfilerCallback * profiler )

void physx::shdfnd::setReflectionAllocatorReportsNames ( bool val )

bool physx::shdfnd::sharedFoundationIsInitialized ( )

int32_t physx::shdfnd::snprintf | ( | char * | dst,
 |  | size_t | dstSize,
 |  | const char * | format,
 |  |  | ...
 | ) |  |

template<class T , class Predicate , class Allocator >
void physx::shdfnd::sort | ( | T * | elements,
 |  | uint32_t | count,
 |  | const Predicate & | compare,
 |  | const Allocator & | inAllocator,
 |  | const uint32_t | initialStackSize = 32 |
 | ) |  |  | [inline]

int32_t physx::shdfnd::sscanf | ( | const char * | buffer,
 |  | const char * | format,
 |  |  | ...
 | ) |  |

int32_t physx::shdfnd::strcmp | ( | const char * | str1,
 |  | const char * | str2
 | ) |  |

int32_t physx::shdfnd::stricmp | ( | const char * | str1,
 |  | const char * | str2
 | ) |  |

size_t physx::shdfnd::strlcat | ( | char * | dst,
 |  | size_t | dstSize,
 |  | const char * | src
 | ) |  |

size_t physx::shdfnd::strlcpy | ( | char * | dst,
 |  | size_t | dstSize,
 |  | const char * | src
 | ) |  |

void physx::shdfnd::strlwr ( char * str )

int32_t physx::shdfnd::strncmp | ( | const char * | str1,
 |  | const char * | str2,
 |  | size_t | count
 | ) |  |

int32_t physx::shdfnd::strnicmp | ( | const char * | str1,
 |  | const char * | str2,
 |  | size_t | count
 | ) |  |

void physx::shdfnd::strupr ( char * str )

template<class T >
PX_CUDA_CALLABLE PX_INLINE void physx::shdfnd::swap | ( | T & | x,
 |  | T & | y |
 | ) |  |  | [inline]

template<class T , class Alloc >
PX_INLINE void physx::shdfnd::swap | ( | Array< T, Alloc > & | x,
 |  | Array< T, Alloc > & | y |
 | ) |  |  | [inline]

void physx::shdfnd::terminateNamedAllocatorGlobals ( )

void physx::shdfnd::terminateSharedFoundation ( )

void physx::shdfnd::terminateTempAllocatorGlobals ( )

uint32_t physx::shdfnd::TlsAlloc ( )

void physx::shdfnd::TlsFree ( uint32_t index )

void * physx::shdfnd::TlsGet ( uint32_t index )

uint32_t physx::shdfnd::TlsSet | ( | uint32_t | index,
 |  | void * | value
 | ) |  |

int32_t physx::shdfnd::vsnprintf | ( | char * | dst,
 |  | size_t | dstSize,
 |  | const char * | src,
 |  | va_list | arg
 | ) |  |

Variable Documentation

PxAllocatorCallback* physx::shdfnd::gAllocatorCallback = NULL

PxErrorCallback* physx::shdfnd::gErrorCallback = NULL

uint32_t physx::shdfnd::gInitializationCount = 0

PxProfilerCallback* physx::shdfnd::gProfilerCallback = NULL

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: physx::shdfnd::internal Namespace Reference

  • Namespace List
  • Namespace Members
physx::shdfnd::internal

physx::shdfnd::internal Namespace Reference

Classes

class | HashBase
class | HashSetBase
class | HashMapBase
class | Stack

Functions

template<class T , class Predicate >
PX_INLINE void | median3 (T *elements, int32_t first, int32_t last, Predicate &compare)
template<class T , class Predicate >
PX_INLINE int32_t | partition (T *elements, int32_t first, int32_t last, Predicate &compare)
template<class T , class Predicate >
PX_INLINE void | smallSort (T *elements, int32_t first, int32_t last, Predicate &compare)

Function Documentation

template<class T , class Predicate >
PX_INLINE void physx::shdfnd::internal::median3 | ( | T * | elements,
 |  | int32_t | first,
 |  | int32_t | last,
 |  | Predicate & | compare |
 | ) |  |  | [inline]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • v
Here is a list of all namespace members with links to the namespace documentation for each member:

- _ -

  • __declspec() : physx::shdfnd

- a -

  • atomicAdd() : physx::shdfnd
  • atomicCompareExchange() : physx::shdfnd
  • atomicCompareExchangePointer() : physx::shdfnd
  • atomicDecrement() : physx::shdfnd
  • atomicExchange() : physx::shdfnd
  • atomicIncrement() : physx::shdfnd
  • atomicMax() : physx::shdfnd

- b -

  • bitCount() : physx::shdfnd

- c -

  • countLeadingZeros() : physx::shdfnd

- d -

  • disableFPExceptions() : physx::shdfnd

- e -

  • enableFPExceptions() : physx::shdfnd
  • exportArray() : physx::shdfnd

- f -

  • floatFloor() : physx::shdfnd

- g -

  • gAllocatorCallback : physx::shdfnd
  • gErrorCallback : physx::shdfnd
  • getAllocator() : physx::shdfnd
  • getErrorCallback() : physx::shdfnd
  • getInitializationCount() : physx::shdfnd
  • getProfilerCallback() : physx::shdfnd
  • getReflectionAllocatorReportsNames() : physx::shdfnd
  • gInitializationCount : physx::shdfnd
  • gProfilerCallback : physx::shdfnd

- h -

  • hash() : physx::shdfnd
  • highestSetBit() : physx::shdfnd
  • highestSetBitUnsafe() : physx::shdfnd

- i -

  • ilog2() : physx::shdfnd
  • importArray() : physx::shdfnd
  • initializeNamedAllocatorGlobals() : physx::shdfnd
  • initializeSharedFoundation() : physx::shdfnd
  • initializeTempAllocatorGlobals() : physx::shdfnd
  • IntBool : physx::shdfnd
  • isPowerOfTwo() : physx::shdfnd

- l -

  • lowestSetBit() : physx::shdfnd
  • lowestSetBitUnsafe() : physx::shdfnd
  • LPFN_GLPI : physx::shdfnd

- m -

  • median3() : physx::shdfnd::internal
  • memoryBarrier() : physx::shdfnd
  • Mutex : physx::shdfnd

- n -

  • nextPowerOfTwo() : physx::shdfnd

- p -

  • partition() : physx::shdfnd::internal
  • pointerOffset() : physx::shdfnd
  • prefetch() : physx::shdfnd
  • prefetchLine() : physx::shdfnd
  • printFormatted() : physx::shdfnd
  • printString() : physx::shdfnd
  • PxGetAssertHandler() : physx
  • PxSetAssertHandler() : physx

- r -

  • recipFast() : physx::shdfnd
  • recipSqrtFast() : physx::shdfnd

- s -

  • setProfilerCallback() : physx::shdfnd
  • setReflectionAllocatorReportsNames() : physx::shdfnd
  • sharedFoundationIsInitialized() : physx::shdfnd
  • SList : physx::shdfnd
  • smallSort() : physx::shdfnd::internal
  • snprintf() : physx::shdfnd
  • sort() : physx::shdfnd
  • sscanf() : physx::shdfnd
  • strcmp() : physx::shdfnd
  • stricmp() : physx::shdfnd
  • strlcat() : physx::shdfnd
  • strlcpy() : physx::shdfnd
  • strlwr() : physx::shdfnd
  • strncmp() : physx::shdfnd
  • strnicmp() : physx::shdfnd
  • strupr() : physx::shdfnd
  • swap() : physx::shdfnd
  • Sync : physx::shdfnd

- t -

  • terminateNamedAllocatorGlobals() : physx::shdfnd
  • terminateSharedFoundation() : physx::shdfnd
  • terminateTempAllocatorGlobals() : physx::shdfnd
  • Thread : physx::shdfnd
  • TlsAlloc() : physx::shdfnd
  • TlsFree() : physx::shdfnd
  • TlsGet() : physx::shdfnd
  • TlsSet() : physx::shdfnd

- v -

  • vsnprintf() : physx::shdfnd
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: File Index

  • File List
  • File Members

File List

Here is a list of all files with brief descriptions:
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/Ps.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlignedMalloc.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlloca.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsArray.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAtomic.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBitUtils.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsCpu.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsFPU.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsGlobals.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHash.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashMap.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashSet.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineAllocator.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineArray.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsIntrinsics.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSList.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSocket.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSort.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSortInternals.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsString.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSync.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTempAllocator.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTime.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsUserAllocated.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsVersionNumber.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsFPU.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsInclude.h [code]
E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsIntrinsics.h [code]
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
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/Ps.h File Reference

#include "foundation/Px.h"

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | PX_DEBUG_EXP(x)
#define | PX_SIGN_BITMASK 0x80000000

Typedefs

typedef int | physx::shdfnd::IntBool

Define Documentation

#define PX_DEBUG_EXP ( x )

Platform specific defines

#define PX_SIGN_BITMASK 0x80000000

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlignedMalloc.h File Reference

#include "PsUserAllocated.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::AlignedAllocator< N, BaseAllocator >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAlloca.h File Reference

#include "PsTempAllocator.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::ScopedPointer< T, Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | PX_ALLOCA(var, type, count)

Define Documentation

#define PX_ALLOCA | ( | var,
 |  | type,
 |  | count | )

Value:

physx::shdfnd::ScopedPointer<type> var;                                                                           \
        {                                                                                                                  \
                uint32_t size = sizeof(type) * (count);                                                                        \
                var.mOwned = size > 1024;                                                                                      \
                if(var.mOwned)                                                                                                 \
                        var.mPointer = reinterpret_cast<type*>(physx::shdfnd::TempAllocator().allocate(size, __FILE__, __LINE__));\
                else                                                                                                           \
                        var.mPointer = reinterpret_cast<type*>(PxAlloca(size));                                                    \
        }
Stack allocation for count instances of type. Falling back to temp allocator if using more than 1kB.

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAllocator.h File Reference

#include "foundation/PxAllocatorCallback.h"
#include "Ps.h"
#include "PsGlobals.h"
#include <new>

Go to the source code of this file.

Classes

class | physx::shdfnd::RawAllocator
class | physx::shdfnd::NonTrackingAllocator
class | physx::shdfnd::ReflectionAllocator< T >
struct | physx::shdfnd::AllocatorTraits< T >
union | physx::shdfnd::EnableIfPod< T, X >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | PX_ALLOC(n, name) physx::shdfnd::NonTrackingAllocator().allocate(n, __FILE__, __LINE__)
#define | PX_ALLOC_TEMP(n, name) PX_ALLOC(n, name)
#define | PX_FREE(x) physx::shdfnd::NonTrackingAllocator().deallocate(x)
#define | PX_FREE_AND_RESET(x)
#define | PX_NEW(T) new (physx::shdfnd::ReflectionAllocator<T>(), __FILE__, __LINE__) T
#define | PX_NEW_TEMP(T) PX_NEW(T)
#define | PX_DELETE(x) delete x
#define | PX_DELETE_AND_RESET(x)
#define | PX_DELETE_POD(x)
#define | PX_DELETE_ARRAY(x)
#define | PX_ALIGNED16_ALLOC(n) physx::shdfnd::AlignedAllocator<16>().allocate(n, __FILE__, __LINE__)
#define | PX_ALIGNED16_FREE(x) physx::shdfnd::AlignedAllocator<16>().deallocate(x)
#define | PX_PLACEMENT_NEW(p, T) new (p) T
placement new macro to make it easy to spot bad use of 'new'
#define | PX_USE_NAMED_ALLOCATOR 0
#define | PxAllocaAligned(x, alignment) ((size_t(PxAlloca(x + alignment)) + (alignment - 1)) & ~size_t(alignment - 1))

Functions

void | physx::shdfnd::initializeNamedAllocatorGlobals ()
void | physx::shdfnd::terminateNamedAllocatorGlobals ()
template<typename T >
PX_INLINE void * | operator new (size_t size, physx::shdfnd::ReflectionAllocator< T > alloc, const char *fileName, typename physx::shdfnd::EnableIfPod< T, int >::Type line)
template<typename T >
PX_INLINE void * | operator new[] (size_t size, physx::shdfnd::ReflectionAllocator< T > alloc, const char *fileName, typename physx::shdfnd::EnableIfPod< T, int >::Type line)
template<typename T >
PX_INLINE void | operator delete (void *ptr, physx::shdfnd::ReflectionAllocator< T > alloc, const char *fileName, typename physx::shdfnd::EnableIfPod< T, int >::Type line)
template<typename T >
PX_INLINE void | operator delete[] (void *ptr, physx::shdfnd::ReflectionAllocator< T > alloc, const char *fileName, typename physx::shdfnd::EnableIfPod< T, int >::Type line)

Define Documentation

#define PX_ALIGNED16_ALLOC ( n ) physx::shdfnd::AlignedAllocator<16>().allocate(n, __FILE__, __LINE__)

#define PX_ALIGNED16_FREE ( x ) physx::shdfnd::AlignedAllocator<16>().deallocate(x)

#define PX_ALLOC | ( | n,
 |  | name | ) | physx::shdfnd::NonTrackingAllocator().allocate(n, __FILE__, __LINE__)

#define PX_ALLOC_TEMP | ( | n,
 |  | name | ) | PX_ALLOC(n, name)

#define PX_DELETE ( x ) delete x

#define PX_DELETE_AND_RESET ( x )

Value:

{                                                                                                                  \
                PX_DELETE(x);                                                                                                  \
                x = 0;                                                                                                         \
        }

#define PX_DELETE_ARRAY ( x )

Value:

{                                                                                                                  \
                PX_DELETE([] x);                                                                                               \
                x = 0;                                                                                                         \
        }

#define PX_DELETE_POD ( x )

Value:

{                                                                                                                  \
                PX_FREE(x);                                                                                                    \
                x = 0;                                                                                                         \
        }

#define PX_FREE ( x ) physx::shdfnd::NonTrackingAllocator().deallocate(x)

#define PX_FREE_AND_RESET ( x )

Value:

{                                                                                                                  \
                PX_FREE(x);                                                                                                    \
                x = 0;                                                                                                         \
        }

#define PX_NEW ( T ) new (physx::shdfnd::ReflectionAllocator<T>(), __FILE__, __LINE__) T

#define PX_NEW_TEMP ( T ) PX_NEW(T)

#define PX_PLACEMENT_NEW | ( | p,
 |  | T | ) | new (p) T

placement new macro to make it easy to spot bad use of 'new'

#define PX_USE_NAMED_ALLOCATOR 0

#define PxAllocaAligned | ( | x,
 |  | alignment | ) | ((size_t(PxAlloca(x + alignment)) + (alignment - 1)) & ~size_t(alignment - 1))

Function Documentation

template<typename T >
PX_INLINE void operator delete | ( | void * | ptr,
 |  | physx::shdfnd::ReflectionAllocator< T > | alloc,
 |  | const char * | fileName,
 |  | typename physx::shdfnd::EnableIfPod< T, int >::Type | line |
 | ) |  |  | [inline]

template<typename T >
PX_INLINE void operator delete[] | ( | void * | ptr,
 |  | physx::shdfnd::ReflectionAllocator< T > | alloc,
 |  | const char * | fileName,
 |  | typename physx::shdfnd::EnableIfPod< T, int >::Type | line |
 | ) |  |  | [inline]

template<typename T >
PX_INLINE void* operator new | ( | size_t | size,
 |  | physx::shdfnd::ReflectionAllocator< T > | alloc,
 |  | const char * | fileName,
 |  | typename physx::shdfnd::EnableIfPod< T, int >::Type | line |
 | ) |  |  | [inline]

template<typename T >
PX_INLINE void* operator new[] | ( | size_t | size,
 |  | physx::shdfnd::ReflectionAllocator< T > | alloc,
 |  | const char * | fileName,
 |  | typename physx::shdfnd::EnableIfPod< T, int >::Type | line |
 | ) |  |  | [inline]

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

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

Go to the source code of this file.

Classes

class | physx::shdfnd::Array< T, Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

template<class Serializer >
void | physx::shdfnd::exportArray (Serializer &stream, const void *data, uint32_t size, uint32_t sizeOfElement, uint32_t capacity)
char * | physx::shdfnd::importArray (char *address, void **data, uint32_t size, uint32_t sizeOfElement, uint32_t capacity)
template<class T , class Alloc >
PX_INLINE void | physx::shdfnd::swap (Array< T, Alloc > &x, Array< T, Alloc > &y)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsAtomic.h File Reference

#include "Ps.h"

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API int32_t | physx::shdfnd::atomicExchange (volatile int32_t *dest, int32_t val)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicCompareExchange (volatile int32_t *dest, int32_t exch, int32_t comp)
PX_FOUNDATION_API void * | physx::shdfnd::atomicCompareExchangePointer (volatile void **dest, void *exch, void *comp)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicIncrement (volatile int32_t *val)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicDecrement (volatile int32_t *val)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicAdd (volatile int32_t *val, int32_t delta)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicMax (volatile int32_t *val, int32_t val2)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBasicTemplates.h File Reference

#include "Ps.h"

Go to the source code of this file.

Classes

struct | physx::shdfnd::Equal< A >
struct | physx::shdfnd::Less< A >
struct | physx::shdfnd::Greater< A >
class | physx::shdfnd::Pair< F, S >
struct | physx::shdfnd::LogTwo< A >
struct | physx::shdfnd::LogTwo< 1 >
struct | physx::shdfnd::UnConst< T >
struct | physx::shdfnd::UnConst< const T >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

template<typename T >
T | physx::shdfnd::pointerOffset (void *p, ptrdiff_t offset)
template<typename T >
T | physx::shdfnd::pointerOffset (const void *p, ptrdiff_t offset)
template<class T >
PX_CUDA_CALLABLE PX_INLINE void | physx::shdfnd::swap (T &x, T &y)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsBitUtils.h File Reference

#include "foundation/PxIntrinsics.h"
#include "foundation/PxAssert.h"
#include "PsIntrinsics.h"
#include "Ps.h"

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_INLINE uint32_t | physx::shdfnd::bitCount (uint32_t v)
PX_INLINE bool | physx::shdfnd::isPowerOfTwo (uint32_t x)
PX_INLINE uint32_t | physx::shdfnd::nextPowerOfTwo (uint32_t x)
PX_INLINE uint32_t | physx::shdfnd::lowestSetBit (uint32_t x)
PX_INLINE uint32_t | physx::shdfnd::highestSetBit (uint32_t x)
PX_INLINE uint32_t | physx::shdfnd::ilog2 (uint32_t num)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsCpu.h File Reference

#include "Ps.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::Cpu

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsFPU.h File Reference

#include "Ps.h"
#include "PsIntrinsics.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::FPUGuard
class | physx::shdfnd::SIMDGuard

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | PX_IR(x) ((uint32_t&)(x))
#define | PX_SIR(x) ((int32_t&)(x))
#define | PX_FR(x) ((float&)(x))
#define | PX_SIGN_BITMASK 0x80000000
#define | PX_FPU_GUARD shdfnd::FPUGuard scopedFpGuard;
#define | PX_SIMD_GUARD shdfnd::SIMDGuard scopedFpGuard;
#define | PX_SUPPORT_GUARDS (PX_WINDOWS_FAMILY || PX_XBOXONE || PX_LINUX || PX_PS4 || PX_OSX)

Functions

PX_FOUNDATION_API void | physx::shdfnd::enableFPExceptions ()
Enables floating point exceptions for the scalar and SIMD unit.
PX_FOUNDATION_API void | physx::shdfnd::disableFPExceptions ()
Disables floating point exceptions for the scalar and SIMD unit.

Define Documentation

#define PX_FPU_GUARD shdfnd::FPUGuard scopedFpGuard;

#define PX_FR ( x ) ((float&)(x))

#define PX_IR ( x ) ((uint32_t&)(x))

#define PX_SIGN_BITMASK 0x80000000

#define PX_SIMD_GUARD shdfnd::SIMDGuard scopedFpGuard;

#define PX_SIR ( x ) ((int32_t&)(x))

#define PX_SUPPORT_GUARDS (PX_WINDOWS_FAMILY || PX_XBOXONE || PX_LINUX || PX_PS4 || PX_OSX)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsGlobals.h File Reference

#include "foundation/PxErrors.h"

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API void | physx::shdfnd::initializeSharedFoundation (uint32_t version, PxAllocatorCallback &, PxErrorCallback &)
PX_FOUNDATION_API bool | physx::shdfnd::sharedFoundationIsInitialized ()
PX_FOUNDATION_API void | physx::shdfnd::terminateSharedFoundation ()
PX_FOUNDATION_API uint32_t | physx::shdfnd::getInitializationCount ()
PX_FOUNDATION_API
PxAllocatorCallback & 		physx::shdfnd::getAllocator ()
PX_FOUNDATION_API PxErrorCallback & | physx::shdfnd::getErrorCallback ()
PX_FOUNDATION_API void | physx::shdfnd::setReflectionAllocatorReportsNames (bool val)
PX_FOUNDATION_API bool | physx::shdfnd::getReflectionAllocatorReportsNames ()
PX_FOUNDATION_API
PxProfilerCallback * 		physx::shdfnd::getProfilerCallback ()
PX_FOUNDATION_API void | physx::shdfnd::setProfilerCallback (PxProfilerCallback *profiler)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHash.h File Reference

#include "Ps.h"
#include "PsBasicTemplates.h"

Go to the source code of this file.

Classes

struct | physx::shdfnd::Hash< Key >
struct | physx::shdfnd::Hash< const char * >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FORCE_INLINE uint32_t | physx::shdfnd::hash (const uint32_t key)
PX_FORCE_INLINE uint32_t | physx::shdfnd::hash (const int32_t key)
PX_FORCE_INLINE uint32_t | physx::shdfnd::hash (const uint64_t key)
PX_INLINE uint32_t | physx::shdfnd::hash (const void *ptr)
template<typename F , typename S >
PX_INLINE uint32_t | physx::shdfnd::hash (const Pair< F, S > &p)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashInternals.h File Reference

#include "PsBasicTemplates.h"
#include "PsArray.h"
#include "PsBitUtils.h"
#include "PsHash.h"
#include "foundation/PxIntrinsics.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
class | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
class | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
struct | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
class | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
struct | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
namespace | physx::shdfnd::internal

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashMap.h File Reference

#include "PsHashInternals.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
class | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsHashSet.h File Reference

#include "PsHashInternals.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::HashSet< Key, HashFn, Allocator >
class | physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineAllocator.h File Reference

#include "PsUserAllocated.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::InlineAllocator< N, BaseAllocator >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsInlineArray.h File Reference

#include "PsArray.h"
#include "PsInlineAllocator.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::InlineArray< T, N, Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsIntrinsics.h File Reference

#include "foundation/PxPreprocessor.h"

Go to the source code of this file.

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsMutex.h File Reference

#include "PsAllocator.h"
#include <new>

Go to the source code of this file.

Classes

class | physx::shdfnd::MutexImpl
class | physx::shdfnd::MutexT< Alloc >
class | physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
class | physx::shdfnd::ReadWriteLock
class | physx::shdfnd::ScopedReadLock
class | physx::shdfnd::ScopedWriteLock
class | physx::shdfnd::AtomicLock
class | physx::shdfnd::AtomicLockCopy
class | physx::shdfnd::AtomicRwLock
class | physx::shdfnd::ScopedAtomicLock

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Typedefs

typedef MutexT | physx::shdfnd::Mutex

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsPool.h File Reference

#include "PsArray.h"
#include "PsSort.h"
#include "PsBasicTemplates.h"
#include "PsInlineArray.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::PoolBase< T, Alloc >
struct | physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList
class | physx::shdfnd::Pool< T, Alloc >
class | physx::shdfnd::Pool2< T, slabSize, Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSList.h File Reference

#include "foundation/Px.h"
#include "foundation/PxAssert.h"
#include "PsAlignedMalloc.h"

Go to the source code of this file.

Classes

struct | physx::shdfnd::SListImpl
class | physx::shdfnd::SListT< Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | PX_SLIST_ALIGNMENT 8

Typedefs

typedef SListT | physx::shdfnd::SList

Functions

physx::shdfnd::__declspec (align(8)) class SListEntry

Define Documentation

#define PX_SLIST_ALIGNMENT 8

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSocket.h File Reference

#include "PsUserAllocated.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::Socket

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSort.h File Reference

#include "PsSortInternals.h"
#include "PsAlloca.h"

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | PX_SORT_PARANOIA PX_DEBUG

Functions

template<class T , class Predicate , class Allocator >
void | physx::shdfnd::sort (T *elements, uint32_t count, const Predicate &compare, const Allocator &inAllocator, const uint32_t initialStackSize=32)
template<class T , class Predicate >
void | physx::shdfnd::sort (T *elements, uint32_t count, const Predicate &compare)
template<class T >
void | physx::shdfnd::sort (T *elements, uint32_t count)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSortInternals.h File Reference

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

Go to the source code of this file.

Classes

class | physx::shdfnd::internal::Stack< Allocator >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
namespace | physx::shdfnd::internal

Functions

template<class T , class Predicate >
PX_INLINE void | physx::shdfnd::internal::median3 (T *elements, int32_t first, int32_t last, Predicate &compare)
template<class T , class Predicate >
PX_INLINE int32_t | physx::shdfnd::internal::partition (T *elements, int32_t first, int32_t last, Predicate &compare)
template<class T , class Predicate >
PX_INLINE void | physx::shdfnd::internal::smallSort (T *elements, int32_t first, int32_t last, Predicate &compare)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsString.h File Reference

#include "foundation/PxPreprocessor.h"
#include "foundation/PxSimpleTypes.h"
#include <stdarg.h>

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API int32_t | physx::shdfnd::sscanf (const char *buffer, const char *format,...)
PX_FOUNDATION_API int32_t | physx::shdfnd::strcmp (const char *str1, const char *str2)
PX_FOUNDATION_API int32_t | physx::shdfnd::strncmp (const char *str1, const char *str2, size_t count)
PX_FOUNDATION_API int32_t | physx::shdfnd::snprintf (char *dst, size_t dstSize, const char *format,...)
PX_FOUNDATION_API int32_t | physx::shdfnd::vsnprintf (char *dst, size_t dstSize, const char *src, va_list arg)
PX_FOUNDATION_API size_t | physx::shdfnd::strlcat (char *dst, size_t dstSize, const char *src)
PX_FOUNDATION_API size_t | physx::shdfnd::strlcpy (char *dst, size_t dstSize, const char *src)
PX_FOUNDATION_API int32_t | physx::shdfnd::stricmp (const char *str1, const char *str2)
PX_FOUNDATION_API int32_t | physx::shdfnd::strnicmp (const char *str1, const char *str2, size_t count)
PX_FOUNDATION_API void | physx::shdfnd::strlwr (char *str)
PX_FOUNDATION_API void | physx::shdfnd::strupr (char *str)
PX_FOUNDATION_API void | physx::shdfnd::printFormatted (const char *,...)
Prints the formatted data, trying to make sure it's visible to the app programmer.
PX_FOUNDATION_API void | physx::shdfnd::printString (const char *)
Prints the string literally (does not consume % specifier), trying to make sure it's visible to the app programmer.

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsSync.h File Reference

#include "PsAllocator.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::SyncImpl
class | physx::shdfnd::SyncT< Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Typedefs

typedef SyncT | physx::shdfnd::Sync

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTempAllocator.h File Reference

#include "PsAllocator.h"

Go to the source code of this file.

Classes

union | physx::shdfnd::TempAllocatorChunk
class | physx::shdfnd::TempAllocator

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

void | physx::shdfnd::initializeTempAllocatorGlobals ()
void | physx::shdfnd::terminateTempAllocatorGlobals ()

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsThread.h File Reference

#include "PsUserAllocated.h"

Go to the source code of this file.

Classes

struct | physx::shdfnd::ThreadPriority
class | physx::shdfnd::Runnable
class | physx::shdfnd::ThreadImpl
class | physx::shdfnd::ThreadT< Alloc >

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Typedefs

typedef ThreadT | physx::shdfnd::Thread

Functions

PX_FOUNDATION_API uint32_t | physx::shdfnd::TlsAlloc ()
PX_FOUNDATION_API void | physx::shdfnd::TlsFree (uint32_t index)
PX_FOUNDATION_API void * | physx::shdfnd::TlsGet (uint32_t index)
PX_FOUNDATION_API uint32_t | physx::shdfnd::TlsSet (uint32_t index, void *value)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsTime.h File Reference

#include "Ps.h"

Go to the source code of this file.

Classes

struct | physx::shdfnd::CounterFrequencyToTensOfNanos
class | physx::shdfnd::Time

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsUserAllocated.h File Reference

#include "PsAllocator.h"

Go to the source code of this file.

Classes

class | physx::shdfnd::UserAllocated

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/PsVersionNumber.h File Reference

Go to the source code of this file.

Defines

#define | PX_FOUNDATION_VERSION_MAJOR 3
#define | PX_FOUNDATION_VERSION_MINOR 4
#define | PX_FOUNDATION_VERSION_BUGFIX 0
#define | PX_FOUNDATION_VERSION ((PX_FOUNDATION_VERSION_MAJOR << 24) + (PX_FOUNDATION_VERSION_MINOR << 16) + (PX_FOUNDATION_VERSION_BUGFIX << 8) + 0)

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsFPU.h File Reference

Go to the source code of this file.

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsInclude.h File Reference

#include "Ps.h"
#include <windows.h>

Go to the source code of this file.

Defines

#define | _WIN32_WINNT 0x0501
#define | NOGDICAPMASKS
#define | NOVIRTUALKEYCODES
#define | NOWINMESSAGES
#define | NOWINSTYLES
#define | NOSYSMETRICS
#define | NOMENUS
#define | NOICONS
#define | NOKEYSTATES
#define | NOSYSCOMMANDS
#define | NORASTEROPS
#define | NOSHOWWINDOW
#define | NOATOM
#define | NOCLIPBOARD
#define | NOCOLOR
#define | NOCTLMGR
#define | NODRAWTEXT
#define | NOGDI
#define | NOMB
#define | NOMEMMGR
#define | NOMETAFILE
#define | NOMINMAX
#define | NOOPENFILE
#define | NOSCROLL
#define | NOSERVICE
#define | NOSOUND
#define | NOTEXTMETRIC
#define | NOWH
#define | NOWINOFFSETS
#define | NOCOMM
#define | NOKANJI
#define | NOHELP
#define | NOPROFILER
#define | NODEFERWINDOWPOS
#define | NOMCX
#define | WIN32_LEAN_AND_MEAN
#define | NOUSER
#define | NONLS
#define | NOMSG

Define Documentation

#define _WIN32_WINNT 0x0501

#define NOATOM

#define NOCLIPBOARD

#define NOCOLOR

#define NOCOMM

#define NOCTLMGR

#define NODEFERWINDOWPOS

#define NODRAWTEXT

#define NOGDI

#define NOGDICAPMASKS

#define NOHELP

#define NOICONS

#define NOKANJI

#define NOKEYSTATES

#define NOMB

#define NOMCX

#define NOMEMMGR

#define NOMENUS

#define NOMETAFILE

#define NOMINMAX

#define NOMSG

#define NONLS

#define NOOPENFILE

#define NOPROFILER

#define NORASTEROPS

#define NOSCROLL

#define NOSERVICE

#define NOSHOWWINDOW

#define NOSOUND

#define NOSYSCOMMANDS

#define NOSYSMETRICS

#define NOTEXTMETRIC

#define NOUSER

#define NOVIRTUALKEYCODES

#define NOWH

#define NOWINMESSAGES

#define NOWINOFFSETS

#define NOWINSTYLES

#define WIN32_LEAN_AND_MEAN

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/include/windows/PsWindowsIntrinsics.h File Reference

#include "Ps.h"
#include "foundation/PxAssert.h"
#include <intrin.h>
#include <math.h>
#include <float.h>
#include <mmintrin.h>

Go to the source code of this file.

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | NS_EXPECT_TRUE(x) x
#define | NS_EXPECT_FALSE(x) x

Functions

PX_FORCE_INLINE void | physx::shdfnd::memoryBarrier ()
PX_FORCE_INLINE uint32_t | physx::shdfnd::highestSetBitUnsafe (uint32_t v)
PX_FORCE_INLINE uint32_t | physx::shdfnd::lowestSetBitUnsafe (uint32_t v)
PX_FORCE_INLINE uint32_t | physx::shdfnd::countLeadingZeros (uint32_t v)
PX_FORCE_INLINE void | physx::shdfnd::prefetchLine (const void *ptr, uint32_t offset=0)
PX_FORCE_INLINE void | physx::shdfnd::prefetch (const void *ptr, uint32_t count=1)
PX_CUDA_CALLABLE
PX_FORCE_INLINE float 		physx::shdfnd::recipFast (float a)
platform-specific reciprocal
PX_CUDA_CALLABLE
PX_FORCE_INLINE float 		physx::shdfnd::recipSqrtFast (float a)
platform-specific fast reciprocal square root
PX_CUDA_CALLABLE
PX_FORCE_INLINE float 		physx::shdfnd::floatFloor (float x)
platform-specific floor

Define Documentation

#define NS_EXPECT_FALSE ( x ) x

#define NS_EXPECT_TRUE ( x ) x

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAllocator.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAllocator.cpp File Reference

#include "PsAllocator.h"
#include "PsHashMap.h"
#include "PsArray.h"
#include "PsMutex.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

void | physx::shdfnd::initializeNamedAllocatorGlobals ()
void | physx::shdfnd::terminateNamedAllocatorGlobals ()
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAssert.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsAssert.cpp File Reference

#include "PxAssert.h"
#include <stdio.h>
#include "PsString.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.

Functions

PxAssertHandler & | physx::PxGetAssertHandler ()
void | physx::PxSetAssertHandler (PxAssertHandler &handler)
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsGlobals.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsGlobals.cpp File Reference

#include "PxPreprocessor.h"
#include "Ps.h"
#include "PsGlobals.h"
#include "PsTempAllocator.h"
#include "PsVersionNumber.h"
#include "PxErrorCallback.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API
PxProfilerCallback * 		physx::shdfnd::getProfilerCallback ()
PX_FOUNDATION_API void | physx::shdfnd::setProfilerCallback (PxProfilerCallback *profiler)
PX_FOUNDATION_API
PxAllocatorCallback & 		physx::shdfnd::getAllocator ()
PX_FOUNDATION_API PxErrorCallback & | physx::shdfnd::getErrorCallback ()
PX_FOUNDATION_API uint32_t | physx::shdfnd::getInitializationCount ()
PX_FOUNDATION_API void | physx::shdfnd::setReflectionAllocatorReportsNames (bool val)
PX_FOUNDATION_API bool | physx::shdfnd::getReflectionAllocatorReportsNames ()
PX_FOUNDATION_API void | physx::shdfnd::initializeSharedFoundation (uint32_t version, PxAllocatorCallback &, PxErrorCallback &)
PX_FOUNDATION_API bool | physx::shdfnd::sharedFoundationIsInitialized ()
PX_FOUNDATION_API void | physx::shdfnd::terminateSharedFoundation ()

Variables

PxProfilerCallback * | physx::shdfnd::gProfilerCallback = NULL
PxAllocatorCallback * | physx::shdfnd::gAllocatorCallback = NULL
PxErrorCallback * | physx::shdfnd::gErrorCallback = NULL
uint32_t | physx::shdfnd::gInitializationCount = 0
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsHeaderTest.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsHeaderTest.cpp File Reference

#include "PxMat33.h"
#include "PxQuat.h"
#include "PxTransform.h"
#include "PsUserAllocated.h"
#include "PsFPU.h"
#include "Ps.h"
#include "PsAlignedMalloc.h"
#include "PsAlloca.h"
#include "PsAllocator.h"
#include "PsAtomic.h"
#include "PsBasicTemplates.h"
#include "PsBitUtils.h"
#include "PsCpu.h"
#include "PsHash.h"
#include "PsHashSet.h"
#include "PsHashInternals.h"
#include "PsInlineAllocator.h"
#include "PsIntrinsics.h"
#include "PsMutex.h"
#include "PsPool.h"
#include "PsSList.h"
#include "PsSocket.h"
#include "PsSort.h"
#include "PsSortInternals.h"
#include "PsString.h"
#include "PsSync.h"
#include "PsTempAllocator.h"
#include "PsThread.h"
#include "PsTime.h"
#include "PsVersionNumber.h"
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsString.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsString.cpp File Reference

#include "PsString.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API int32_t | physx::shdfnd::strcmp (const char *str1, const char *str2)
PX_FOUNDATION_API int32_t | physx::shdfnd::strncmp (const char *str1, const char *str2, size_t count)
PX_FOUNDATION_API int32_t | physx::shdfnd::snprintf (char *dst, size_t dstSize, const char *format,...)
PX_FOUNDATION_API int32_t | physx::shdfnd::sscanf (const char *buffer, const char *format,...)
PX_FOUNDATION_API size_t | physx::shdfnd::strlcpy (char *dst, size_t dstSize, const char *src)
PX_FOUNDATION_API size_t | physx::shdfnd::strlcat (char *dst, size_t dstSize, const char *src)
PX_FOUNDATION_API void | physx::shdfnd::strlwr (char *str)
PX_FOUNDATION_API void | physx::shdfnd::strupr (char *str)
PX_FOUNDATION_API int32_t | physx::shdfnd::vsnprintf (char *dst, size_t dstSize, const char *src, va_list arg)
PX_FOUNDATION_API int32_t | physx::shdfnd::stricmp (const char *str1, const char *str2)
PX_FOUNDATION_API int32_t | physx::shdfnd::strnicmp (const char *str1, const char *str2, size_t count)
PX_FOUNDATION_API void | physx::shdfnd::printFormatted (const char *,...)
Prints the formatted data, trying to make sure it's visible to the app programmer.
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsTempAllocator.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/PsTempAllocator.cpp File Reference

#include "PsTempAllocator.h"
#include "PsArray.h"
#include "PsMutex.h"
#include "PsAtomic.h"
#include "PxMath.h"
#include "PsIntrinsics.h"
#include "PsBitUtils.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

void | physx::shdfnd::initializeTempAllocatorGlobals ()
void | physx::shdfnd::terminateTempAllocatorGlobals ()

Variable Documentation

AllocFreeTable allocFreeTable

Mutex allocMutex

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsAtomic.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsAtomic.cpp File Reference

#include "windows/PsWindowsInclude.h"
#include "PsAtomic.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API int32_t | physx::shdfnd::atomicExchange (volatile int32_t *dest, int32_t val)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicCompareExchange (volatile int32_t *dest, int32_t exch, int32_t comp)
PX_FOUNDATION_API void * | physx::shdfnd::atomicCompareExchangePointer (volatile void **dest, void *exch, void *comp)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicIncrement (volatile int32_t *val)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicDecrement (volatile int32_t *val)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicAdd (volatile int32_t *val, int32_t delta)
PX_FOUNDATION_API int32_t | physx::shdfnd::atomicMax (volatile int32_t *val, int32_t val2)
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsCpu.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsCpu.cpp File Reference

#include "PsCpu.h"
#include <intrin.h>

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsFPU.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsFPU.cpp File Reference

#include "PsFPU.h"
#include "float.h"
#include "PsIntrinsics.h"

Defines

#define _MCW_ALL _MCW_DN | _MCW_EM | _MCW_IC | _MCW_RC | _MCW_PC

Define Documentation

#define _MCW_ALL _MCW_DN | _MCW_EM | _MCW_IC | _MCW_RC | _MCW_PC

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsMutex.cpp File Reference

#include "windows/PsWindowsInclude.h"
#include "PsUserAllocated.h"
#include "PsMutex.h"
#include "PsThread.h"
#include "PxErrorCallback.h"

Classes

class | physx::shdfnd::ReadWriteLockImpl

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Variable Documentation

CRITICAL_SECTION mLock

Thread::Id mOwner

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsPrintString.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsPrintString.cpp File Reference

#include "PsString.h"
#include <stdio.h>
#include <windows.h>
#include <string.h>
#include <stdarg.h>

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Functions

PX_FOUNDATION_API void | physx::shdfnd::printString (const char *)
Prints the string literally (does not consume % specifier), trying to make sure it's visible to the app programmer.
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSList.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSList.cpp File Reference

#include "windows/PsWindowsInclude.h"
#include "PsAllocator.h"
#include "PsSList.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSocket.cpp File Reference

#include "windows/PsWindowsInclude.h"
#include "PsSocket.h"
#include "PsThread.h"
#include "PsArray.h"
#include "PxIntrinsics.h"
#include <Winsock2.h>

Classes

class | physx::shdfnd::SocketImpl
class | physx::shdfnd::BufferedSocketImpl

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSync.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsSync.cpp File Reference

#include "windows/PsWindowsInclude.h"
#include "PsUserAllocated.h"
#include "PsSync.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsThread.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsThread.cpp File Reference

#include "windows/PsWindowsInclude.h"
#include "PsThread.h"
#include "PxErrorCallback.h"
#include "PxAssert.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd

Defines

#define | NS_MS_VC_EXCEPTION 0x406D1388

Typedefs

typedef BOOL(WINAPI * | physx::shdfnd::LPFN_GLPI )(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD)

Functions

PX_FOUNDATION_API uint32_t | physx::shdfnd::TlsAlloc ()
PX_FOUNDATION_API void | physx::shdfnd::TlsFree (uint32_t index)
PX_FOUNDATION_API void * | physx::shdfnd::TlsGet (uint32_t index)
PX_FOUNDATION_API uint32_t | physx::shdfnd::TlsSet (uint32_t index, void *value)

Define Documentation

#define NS_MS_VC_EXCEPTION 0x406D1388

Variable Documentation

uint32_t affinityMask

void* arg

DWORD dwFlags

DWORD dwThreadID

DWORD dwType

ThreadImpl::ExecuteFn fn

LONG quitNow

State state

LPCSTR szName

HANDLE thread

DWORD threadID

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsTime.cpp File Reference

  • File List
  • File Members

E:/p4/sw/physx/PxShared/1.0/trunk/src/foundation/src/windows/PsWindowsTime.cpp File Reference

#include "PsTime.h"
#include "windows/PsWindowsInclude.h"

Namespaces

namespace | physx
Sorts an array of objects in ascending order, assuming that the predicate implements the < operator:.
namespace | physx::shdfnd
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Defines
  • _
  • a
  • d
  • f
  • m
  • n
  • o
  • p
  • q
  • s
  • t
  • w
Here is a list of all file members with links to the files they belong to:

- _ -

  • _MCW_ALL : PsWindowsFPU.cpp
  • _WIN32_WINNT : PsWindowsInclude.h

- a -

  • affinityMask : PsWindowsThread.cpp
  • allocFreeTable : PsTempAllocator.cpp
  • allocMutex : PsTempAllocator.cpp
  • arg : PsWindowsThread.cpp

- d -

  • dwFlags : PsWindowsThread.cpp
  • dwThreadID : PsWindowsThread.cpp
  • dwType : PsWindowsThread.cpp

- f -

  • fn : PsWindowsThread.cpp

- m -

  • mLock : PsWindowsMutex.cpp
  • mOwner : PsWindowsMutex.cpp

- n -

  • NOATOM : PsWindowsInclude.h
  • NOCLIPBOARD : PsWindowsInclude.h
  • NOCOLOR : PsWindowsInclude.h
  • NOCOMM : PsWindowsInclude.h
  • NOCTLMGR : PsWindowsInclude.h
  • NODEFERWINDOWPOS : PsWindowsInclude.h
  • NODRAWTEXT : PsWindowsInclude.h
  • NOGDI : PsWindowsInclude.h
  • NOGDICAPMASKS : PsWindowsInclude.h
  • NOHELP : PsWindowsInclude.h
  • NOICONS : PsWindowsInclude.h
  • NOKANJI : PsWindowsInclude.h
  • NOKEYSTATES : PsWindowsInclude.h
  • NOMB : PsWindowsInclude.h
  • NOMCX : PsWindowsInclude.h
  • NOMEMMGR : PsWindowsInclude.h
  • NOMENUS : PsWindowsInclude.h
  • NOMETAFILE : PsWindowsInclude.h
  • NOMINMAX : PsWindowsInclude.h
  • NOMSG : PsWindowsInclude.h
  • NONLS : PsWindowsInclude.h
  • NOOPENFILE : PsWindowsInclude.h
  • NOPROFILER : PsWindowsInclude.h
  • NORASTEROPS : PsWindowsInclude.h
  • NOSCROLL : PsWindowsInclude.h
  • NOSERVICE : PsWindowsInclude.h
  • NOSHOWWINDOW : PsWindowsInclude.h
  • NOSOUND : PsWindowsInclude.h
  • NOSYSCOMMANDS : PsWindowsInclude.h
  • NOSYSMETRICS : PsWindowsInclude.h
  • NOTEXTMETRIC : PsWindowsInclude.h
  • NOUSER : PsWindowsInclude.h
  • NOVIRTUALKEYCODES : PsWindowsInclude.h
  • NOWH : PsWindowsInclude.h
  • NOWINMESSAGES : PsWindowsInclude.h
  • NOWINOFFSETS : PsWindowsInclude.h
  • NOWINSTYLES : PsWindowsInclude.h
  • NS_EXPECT_FALSE : PsWindowsIntrinsics.h
  • NS_EXPECT_TRUE : PsWindowsIntrinsics.h
  • NS_MS_VC_EXCEPTION : PsWindowsThread.cpp

- o -

  • operator delete() : PsAllocator.h
  • operator delete[]() : PsAllocator.h
  • operator new() : PsAllocator.h
  • operator new[]() : PsAllocator.h

- p -

  • PX_ALIGNED16_ALLOC : PsAllocator.h
  • PX_ALIGNED16_FREE : PsAllocator.h
  • PX_ALLOC : PsAllocator.h
  • PX_ALLOC_TEMP : PsAllocator.h
  • PX_ALLOCA : PsAlloca.h
  • PX_DEBUG_EXP : Ps.h
  • PX_DELETE : PsAllocator.h
  • PX_DELETE_AND_RESET : PsAllocator.h
  • PX_DELETE_ARRAY : PsAllocator.h
  • PX_DELETE_POD : PsAllocator.h
  • PX_FOUNDATION_VERSION : PsVersionNumber.h
  • PX_FOUNDATION_VERSION_BUGFIX : PsVersionNumber.h
  • PX_FOUNDATION_VERSION_MAJOR : PsVersionNumber.h
  • PX_FOUNDATION_VERSION_MINOR : PsVersionNumber.h
  • PX_FPU_GUARD : PsFPU.h
  • PX_FR : PsFPU.h
  • PX_FREE : PsAllocator.h
  • PX_FREE_AND_RESET : PsAllocator.h
  • PX_IR : PsFPU.h
  • PX_NEW : PsAllocator.h
  • PX_NEW_TEMP : PsAllocator.h
  • PX_PLACEMENT_NEW : PsAllocator.h
  • PX_SIGN_BITMASK : Ps.h , PsFPU.h
  • PX_SIMD_GUARD : PsFPU.h
  • PX_SIR : PsFPU.h
  • PX_SLIST_ALIGNMENT : PsSList.h
  • PX_SORT_PARANOIA : PsSort.h
  • PX_SUPPORT_GUARDS : PsFPU.h
  • PX_USE_NAMED_ALLOCATOR : PsAllocator.h
  • PxAllocaAligned : PsAllocator.h

- q -

  • quitNow : PsWindowsThread.cpp

- s -

  • state : PsWindowsThread.cpp
  • szName : PsWindowsThread.cpp

- t -

  • thread : PsWindowsThread.cpp
  • threadID : PsWindowsThread.cpp

- w -

  • WIN32_LEAN_AND_MEAN : PsWindowsInclude.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PS_H
00031 #define PSFOUNDATION_PS_H
00032
00035 #include "foundation/Px.h"
00036
00040 #if PX_WINDOWS_FAMILY || PX_XBOXONE
00041 #pragma intrinsic(memcmp)
00042 #pragma intrinsic(memcpy)
00043 #pragma intrinsic(memset)
00044 #pragma intrinsic(abs)
00045 #pragma intrinsic(labs)
00046 #endif
00047
00048 // An expression that should expand to nothing in non PX_CHECKED builds.
00049 // We currently use this only for tagging the purpose of containers for memory use tracking.
00050 #if PX_CHECKED
00051 #define PX_DEBUG_EXP(x) (x)
00052 #else
00053 #define PX_DEBUG_EXP(x)
00054 #endif
00055
00056 #define PX_SIGN_BITMASK 0x80000000
00057
00058 namespace physx
00059 {
00060 namespace shdfnd
00061 {
00062 // Int-as-bool type - has some uses for efficiency and with SIMD
00063 typedef int IntBool;
00064 static const IntBool IntFalse = 0;
00065 static const IntBool IntTrue = 1;
00066 }
00067
00068 } // namespace physx
00069
00070 #endif // #ifndef PSFOUNDATION_PS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSALIGNEDMALLOC_H
00031 #define PSFOUNDATION_PSALIGNEDMALLOC_H
00032
00033 #include "PsUserAllocated.h"
00034
00041 namespace physx
00042 {
00043 namespace shdfnd
00044 {
00050 // SCS: AlignedMalloc with 3 params not found, seems not used on PC either
00051 // disabled for now to avoid GCC error
00052
00053 template <uint32_t N, typename BaseAllocator = NonTrackingAllocator>
00054 class AlignedAllocator : public BaseAllocator
00055 {
00056   public:
00057         AlignedAllocator(const BaseAllocator& base = BaseAllocator()) : BaseAllocator(base)
00058         {
00059         }
00060
00061         void* allocate(size_t size, const char* file, int line)
00062         {
00063                 size_t pad = N - 1 + sizeof(size_t); // store offset for delete.
00064                 uint8_t* base = reinterpret_cast<uint8_t*>(BaseAllocator::allocate(size + pad, file, line));
00065                 if(!base)
00066                         return NULL;
00067
00068                 uint8_t* ptr = reinterpret_cast<uint8_t*>(size_t(base + pad) & ~(size_t(N) - 1)); // aligned pointer, ensuring N is a size_t
00069                 // wide mask
00070                 reinterpret_cast<size_t*>(ptr)[-1] = size_t(ptr - base); // store offset
00071
00072                 return ptr;
00073         }
00074         void deallocate(void* ptr)
00075         {
00076                 if(ptr == NULL)
00077                         return;
00078
00079                 uint8_t* base = reinterpret_cast<uint8_t*>(ptr) - reinterpret_cast<size_t*>(ptr)[-1];
00080                 BaseAllocator::deallocate(base);
00081         }
00082 };
00083
00084 } // namespace shdfnd
00085 } // namespace physx
00086
00087 #endif // #ifndef PSFOUNDATION_PSALIGNEDMALLOC_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSALLOCA_H
00031 #define PSFOUNDATION_PSALLOCA_H
00032
00033 #include "PsTempAllocator.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00039 template <typename T, typename Alloc = TempAllocator>
00040 class ScopedPointer : private Alloc
00041 {
00042   public:
00043         ~ScopedPointer()
00044         {
00045                 if(mOwned)
00046                         Alloc::deallocate(mPointer);
00047         }
00048
00049         operator T*() const
00050         {
00051                 return mPointer;
00052         }
00053
00054         T* mPointer;
00055         bool mOwned;
00056 };
00057
00058 } // namespace shdfnd
00059 } // namespace physx
00060
00062 #ifdef __SPU__
00063 #define PX_ALLOCA(var, type, count) type* var = reinterpret_cast<type*>(PxAlloca(sizeof(type) * (count)))
00064 #else
00065 #define PX_ALLOCA(var, type, count)                                                                                    \
00066         physx::shdfnd::ScopedPointer<type> var;                                                                           \
00067         {                                                                                                                  \
00068                 uint32_t size = sizeof(type) * (count);                                                                        \
00069                 var.mOwned = size > 1024;                                                                                      \
00070                 if(var.mOwned)                                                                                                 \
00071                         var.mPointer = reinterpret_cast<type*>(physx::shdfnd::TempAllocator().allocate(size, __FILE__, __LINE__));\
00072                 else                                                                                                           \
00073                         var.mPointer = reinterpret_cast<type*>(PxAlloca(size));                                                    \
00074         }
00075 #endif
00076 #endif // #ifndef PSFOUNDATION_PSALLOCA_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSALLOCATOR_H
00031 #define PSFOUNDATION_PSALLOCATOR_H
00032
00033 #include "foundation/PxAllocatorCallback.h"
00034 #include "Ps.h"
00035 #include "PsGlobals.h"
00036
00037 #if(PX_WINDOWS_FAMILY || PX_WINRT || PX_XBOXONE)
00038 #include <exception>
00039 #include <typeinfo.h>
00040 #endif
00041 #if(PX_APPLE_FAMILY)
00042 #include <typeinfo>
00043 #endif
00044
00045 #include <new>
00046
00047 // Allocation macros going through user allocator
00048 #if PX_CHECKED
00049 #define PX_ALLOC(n, name) physx::shdfnd::NamedAllocator(name).allocate(n, __FILE__, __LINE__)
00050 #else
00051 #define PX_ALLOC(n, name) physx::shdfnd::NonTrackingAllocator().allocate(n, __FILE__, __LINE__)
00052 #endif
00053 #define PX_ALLOC_TEMP(n, name) PX_ALLOC(n, name)
00054 #define PX_FREE(x) physx::shdfnd::NonTrackingAllocator().deallocate(x)
00055 #define PX_FREE_AND_RESET(x)                                                                                           \
00056         {                                                                                                                  \
00057                 PX_FREE(x);                                                                                                    \
00058                 x = 0;                                                                                                         \
00059         }
00060
00061 // The following macros support plain-old-types and classes derived from UserAllocated.
00062 #define PX_NEW(T) new (physx::shdfnd::ReflectionAllocator<T>(), __FILE__, __LINE__) T
00063 #define PX_NEW_TEMP(T) PX_NEW(T)
00064 #define PX_DELETE(x) delete x
00065 #define PX_DELETE_AND_RESET(x)                                                                                         \
00066         {                                                                                                                  \
00067                 PX_DELETE(x);                                                                                                  \
00068                 x = 0;                                                                                                         \
00069         }
00070 #define PX_DELETE_POD(x)                                                                                               \
00071         {                                                                                                                  \
00072                 PX_FREE(x);                                                                                                    \
00073                 x = 0;                                                                                                         \
00074         }
00075 #define PX_DELETE_ARRAY(x)                                                                                             \
00076         {                                                                                                                  \
00077                 PX_DELETE([] x);                                                                                               \
00078                 x = 0;                                                                                                         \
00079         }
00080
00081 // aligned allocation
00082 #define PX_ALIGNED16_ALLOC(n) physx::shdfnd::AlignedAllocator<16>().allocate(n, __FILE__, __LINE__)
00083 #define PX_ALIGNED16_FREE(x) physx::shdfnd::AlignedAllocator<16>().deallocate(x)
00084
00086 #define PX_PLACEMENT_NEW(p, T) new (p) T
00087
00088 #if PX_DEBUG || PX_CHECKED
00089 #define PX_USE_NAMED_ALLOCATOR 1
00090 #else
00091 #define PX_USE_NAMED_ALLOCATOR 0
00092 #endif
00093
00094 // Don't use inline for alloca !!!
00095 #if PX_WINDOWS_FAMILY || PX_WINRT
00096 #include <malloc.h>
00097 #define PxAlloca(x) _alloca(x)
00098 #elif PX_LINUX || PX_ANDROID
00099 #include <malloc.h>
00100 #define PxAlloca(x) alloca(x)
00101 #elif PX_APPLE_FAMILY
00102 #include <alloca.h>
00103 #define PxAlloca(x) alloca(x)
00104 #elif PX_PS4
00105 #include <memory.h>
00106 #define PxAlloca(x) alloca(x)
00107 #elif PX_XBOXONE
00108 #include <malloc.h>
00109 #define PxAlloca(x) alloca(x)
00110 #endif
00111
00112 #define PxAllocaAligned(x, alignment) ((size_t(PxAlloca(x + alignment)) + (alignment - 1)) & ~size_t(alignment - 1))
00113
00114 namespace physx
00115 {
00116 namespace shdfnd
00117 {
00118 /*
00119  * Bootstrap allocator using malloc/free.
00120  * Don't use unless your objects get allocated before foundation is initialized.
00121  */
00122 class RawAllocator
00123 {
00124   public:
00125         RawAllocator(const char* = 0)
00126         {
00127         }
00128         void* allocate(size_t size, const char*, int)
00129         {
00130                 // malloc returns valid pointer for size==0, no need to check
00131                 return ::malloc(size);
00132         }
00133         void deallocate(void* ptr)
00134         {
00135                 // free(0) is guaranteed to have no side effect, no need to check
00136                 ::free(ptr);
00137         }
00138 };
00139
00140 /*
00141  * Allocator that simply calls straight back to the application without tracking.
00142  * This is used by the heap (Foundation::mNamedAllocMap) that tracks allocations
00143  * because it needs to be able to grow as a result of an allocation.
00144  * Making the hash table re-entrant to deal with this may not make sense.
00145  */
00146 class NonTrackingAllocator
00147 {
00148   public:
00149         PX_FORCE_INLINE NonTrackingAllocator(const char* = 0)
00150         {
00151         }
00152         PX_FORCE_INLINE void* allocate(size_t size, const char* file, int line)
00153         {
00154                 return !size ? 0 : getAllocator().allocate(size, "NonTrackedAlloc", file, line);
00155         }
00156         PX_FORCE_INLINE void deallocate(void* ptr)
00157         {
00158                 if(ptr)
00159                         getAllocator().deallocate(ptr);
00160         }
00161 };
00162
00166 void initializeNamedAllocatorGlobals();
00167 void terminateNamedAllocatorGlobals();
00168
00169 #if PX_USE_NAMED_ALLOCATOR // can be slow, so only use in debug/checked
00170 class PX_FOUNDATION_API NamedAllocator
00171 {
00172   public:
00173         NamedAllocator(const PxEMPTY);
00174         NamedAllocator(const char* name = 0); // todo: should not have default argument!
00175         NamedAllocator(const NamedAllocator&);
00176         ~NamedAllocator();
00177         NamedAllocator& operator=(const NamedAllocator&);
00178         void* allocate(size_t size, const char* filename, int line);
00179         void deallocate(void* ptr);
00180 };
00181 #else
00182 class NamedAllocator;
00183 #endif // PX_DEBUG
00184
00189 template <typename T>
00190 class ReflectionAllocator
00191 {
00192         static const char* getName()
00193         {
00194                 if(!getReflectionAllocatorReportsNames())
00195                         return "<allocation names disabled>";
00196 #if PX_GCC_FAMILY
00197                 return __PRETTY_FUNCTION__;
00198 #else
00199                 // name() calls malloc(), raw_name() wouldn't
00200                 return typeid(T).name();
00201 #endif
00202         }
00203
00204   public:
00205         ReflectionAllocator(const PxEMPTY)
00206         {
00207         }
00208         ReflectionAllocator(const char* = 0)
00209         {
00210         }
00211         inline ReflectionAllocator(const ReflectionAllocator&)
00212         {
00213         }
00214         void* allocate(size_t size, const char* filename, int line)
00215         {
00216                 return size ? getAllocator().allocate(size, getName(), filename, line) : 0;
00217         }
00218         void deallocate(void* ptr)
00219         {
00220                 if(ptr)
00221                         getAllocator().deallocate(ptr);
00222         }
00223 };
00224
00225 template <typename T>
00226 struct AllocatorTraits
00227 {
00228 #if PX_USE_NAMED_ALLOCATOR
00229         typedef NamedAllocator Type;
00230 #else
00231         typedef ReflectionAllocator<T> Type;
00232 #endif
00233 };
00234
00235 // if you get a build error here, you are trying to PX_NEW a class
00236 // that is neither plain-old-type nor derived from UserAllocated
00237 template <typename T, typename X>
00238 union EnableIfPod
00239 {
00240         int i;
00241         T t;
00242         typedef X Type;
00243 };
00244
00245 } // namespace shdfnd
00246 } // namespace physx
00247
00248 // Global placement new for ReflectionAllocator templated by
00249 // plain-old-type. Allows using PX_NEW for pointers and built-in-types.
00250 //
00251 // ATTENTION: You need to use PX_DELETE_POD or PX_FREE to deallocate
00252 // memory, not PX_DELETE. PX_DELETE_POD redirects to PX_FREE.
00253 //
00254 // Rationale: PX_DELETE uses global operator delete(void*), which we dont' want to overload.
00255 // Any other definition of PX_DELETE couldn't support array syntax 'PX_DELETE([]a);'.
00256 // PX_DELETE_POD was preferred over PX_DELETE_ARRAY because it is used
00257 // less often and applies to both single instances and arrays.
00258 template <typename T>
00259 PX_INLINE void* operator new(size_t size, physx::shdfnd::ReflectionAllocator<T> alloc, const char* fileName,
00260                              typename physx::shdfnd::EnableIfPod<T, int>::Type line)
00261 {
00262         return alloc.allocate(size, fileName, line);
00263 }
00264
00265 template <typename T>
00266 PX_INLINE void* operator new [](size_t size, physx::shdfnd::ReflectionAllocator<T> alloc, const char* fileName,
00267                                 typename physx::shdfnd::EnableIfPod<T, int>::Type line)
00268 { return alloc.allocate(size, fileName, line); }
00269
00270 // If construction after placement new throws, this placement delete is being called.
00271 template <typename T>
00272 PX_INLINE void operator delete(void* ptr, physx::shdfnd::ReflectionAllocator<T> alloc, const char* fileName,
00273                                typename physx::shdfnd::EnableIfPod<T, int>::Type line)
00274 {
00275         PX_UNUSED(fileName);
00276         PX_UNUSED(line);
00277
00278         alloc.deallocate(ptr);
00279 }
00280
00281 // If construction after placement new throws, this placement delete is being called.
00282 template <typename T>
00283 PX_INLINE void operator delete [](void* ptr, physx::shdfnd::ReflectionAllocator<T> alloc, const char* fileName,
00284                                   typename physx::shdfnd::EnableIfPod<T, int>::Type line)
00285 {
00286         PX_UNUSED(fileName);
00287         PX_UNUSED(line);
00288
00289         alloc.deallocate(ptr);
00290 }
00291
00292 #endif // #ifndef PSFOUNDATION_PSALLOCATOR_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSARRAY_H
00031 #define PSFOUNDATION_PSARRAY_H
00032
00033 #include "foundation/PxAssert.h"
00034 #include "foundation/PxIntrinsics.h"
00035 #include "PsAllocator.h"
00036 #include "PsBasicTemplates.h"
00037
00038 #if PX_LINUX || PX_ANDROID || (PX_IOS && !PX_A64) || PX_OSX
00039 #include <tr1/type_traits>
00040 #elif PX_WINRT || PX_XBOXONE || (PX_IOS && PX_A64) || PX_WIN64 || PX_WIN32 || PX_PS4
00041 #include <type_traits>
00042 #if PX_IOS && PX_A64
00043 namespace std { namespace tr1 { using std::is_pod; } }
00044 #endif
00045 #else
00046 #error "OS with no defined path to type_traits.h"
00047 #endif
00048
00049 #if PX_VC == 9 || PX_VC == 10
00050 #pragma warning(push)
00051 #pragma warning(disable : 4347) // behavior change: 'function template' is called instead of 'function'
00052 #endif
00053
00054 namespace physx
00055 {
00056 namespace shdfnd
00057 {
00058 template <class Serializer>
00059 void exportArray(Serializer& stream, const void* data, uint32_t size, uint32_t sizeOfElement, uint32_t capacity);
00060 char* importArray(char* address, void** data, uint32_t size, uint32_t sizeOfElement, uint32_t capacity);
00061
00072 template <class T, class Alloc = typename AllocatorTraits<T>::Type>
00073 class Array : protected Alloc
00074 {
00075   public:
00076         typedef T* Iterator;
00077         typedef const T* ConstIterator;
00078
00079         explicit Array(const PxEMPTY v) : Alloc(v)
00080         {
00081                 if(mData)
00082                         mCapacity |= PX_SIGN_BITMASK;
00083         }
00084
00088         PX_INLINE explicit Array(const Alloc& alloc = Alloc()) : Alloc(alloc), mData(0), mSize(0), mCapacity(0)
00089         {
00090         }
00091
00095         PX_INLINE explicit Array(uint32_t size, const T& a = T(), const Alloc& alloc = Alloc())
00096         : Alloc(alloc), mData(0), mSize(0), mCapacity(0)
00097         {
00098                 resize(size, a);
00099         }
00100
00104         template <class A>
00105         PX_INLINE explicit Array(const Array<T, A>& other, const Alloc& alloc = Alloc())
00106         : Alloc(alloc)
00107         {
00108                 copy(other);
00109         }
00110
00111         // This is necessary else the basic default copy constructor is used in the case of both arrays being of the same
00112         // template instance
00113         // The C++ standard clearly states that a template constructor is never a copy constructor [2]. In other words,
00114         // the presence of a template constructor does not suppress the implicit declaration of the copy constructor.
00115         // Also never make a copy constructor explicit, or copy-initialization* will no longer work. This is because
00116         // 'binding an rvalue to a const reference requires an accessible copy constructor' (http://gcc.gnu.org/bugs/)
00117         // *http://stackoverflow.com/questions/1051379/is-there-a-difference-in-c-between-copy-initialization-and-assignment-initializ
00118         PX_INLINE Array(const Array& other, const Alloc& alloc = Alloc()) : Alloc(alloc)
00119         {
00120                 copy(other);
00121         }
00122
00126         PX_INLINE explicit Array(const T* first, const T* last, const Alloc& alloc = Alloc())
00127         : Alloc(alloc), mSize(last < first ? 0 : uint32_t(last - first)), mCapacity(mSize)
00128         {
00129                 mData = allocate(mSize);
00130                 copy(mData, mData + mSize, first);
00131         }
00132
00136         PX_INLINE ~Array()
00137         {
00138                 destroy(mData, mData + mSize);
00139
00140                 if(capacity() && !isInUserMemory())
00141                         deallocate(mData);
00142         }
00143
00147         template <class A>
00148         PX_INLINE Array& operator=(const Array<T, A>& rhs)
00149         {
00150                 if(&rhs == this)
00151                         return *this;
00152
00153                 clear();
00154                 reserve(rhs.mSize);
00155                 copy(mData, mData + rhs.mSize, rhs.mData);
00156
00157                 mSize = rhs.mSize;
00158                 return *this;
00159         }
00160
00161         PX_INLINE Array& operator=(const Array& t) // Needs to be declared, see comment at copy-constructor
00162         {
00163                 return operator=<Alloc>(t);
00164         }
00165
00166         PX_FORCE_INLINE static bool isArrayOfPOD()
00167         {
00168 #if PX_VC>=14
00169                 return std::is_trivially_copyable<T>::value;
00170 #else
00171                 return std::tr1::is_pod<T>::value;
00172 #endif
00173         }
00174
00182         PX_FORCE_INLINE const T& operator[](uint32_t i) const
00183         {
00184                 PX_ASSERT(i < mSize);
00185                 return mData[i];
00186         }
00187
00195         PX_FORCE_INLINE T& operator[](uint32_t i)
00196         {
00197                 PX_ASSERT(i < mSize);
00198                 return mData[i];
00199         }
00200
00206         PX_FORCE_INLINE ConstIterator begin() const
00207         {
00208                 return mData;
00209         }
00210
00211         PX_FORCE_INLINE Iterator begin()
00212         {
00213                 return mData;
00214         }
00215
00222         PX_FORCE_INLINE ConstIterator end() const
00223         {
00224                 return mData + mSize;
00225         }
00226
00227         PX_FORCE_INLINE Iterator end()
00228         {
00229                 return mData + mSize;
00230         }
00231
00237         PX_FORCE_INLINE const T& front() const
00238         {
00239                 PX_ASSERT(mSize);
00240                 return mData[0];
00241         }
00242
00243         PX_FORCE_INLINE T& front()
00244         {
00245                 PX_ASSERT(mSize);
00246                 return mData[0];
00247         }
00248
00254         PX_FORCE_INLINE const T& back() const
00255         {
00256                 PX_ASSERT(mSize);
00257                 return mData[mSize - 1];
00258         }
00259
00260         PX_FORCE_INLINE T& back()
00261         {
00262                 PX_ASSERT(mSize);
00263                 return mData[mSize - 1];
00264         }
00265
00272         PX_FORCE_INLINE uint32_t size() const
00273         {
00274                 return mSize;
00275         }
00276
00280         PX_INLINE void clear()
00281         {
00282                 destroy(mData, mData + mSize);
00283                 mSize = 0;
00284         }
00285
00291         PX_FORCE_INLINE bool empty() const
00292         {
00293                 return mSize == 0;
00294         }
00295
00302         PX_INLINE Iterator find(const T& a)
00303         {
00304                 uint32_t index;
00305                 for(index = 0; index < mSize && mData[index] != a; index++)
00306                         ;
00307                 return mData + index;
00308         }
00309
00310         PX_INLINE ConstIterator find(const T& a) const
00311         {
00312                 uint32_t index;
00313                 for(index = 0; index < mSize && mData[index] != a; index++)
00314                         ;
00315                 return mData + index;
00316         }
00317
00319
00324
00325
00326         PX_FORCE_INLINE T& pushBack(const T& a)
00327         {
00328                 if(capacity() <= mSize)
00329                         return growAndPushBack(a);
00330
00331                 PX_PLACEMENT_NEW(reinterpret_cast<void*>(mData + mSize), T)(a);
00332
00333                 return mData[mSize++];
00334         }
00335
00337
00340
00341         PX_INLINE T popBack()
00342         {
00343                 PX_ASSERT(mSize);
00344                 T t = mData[mSize - 1];
00345
00346                 if (!isArrayOfPOD())
00347                 {
00348                         mData[--mSize].~T();
00349                 }
00350                 else
00351                 {
00352                         --mSize;
00353                 }
00354
00355                 return t;
00356         }
00357
00359
00362
00363         PX_INLINE T& insert()
00364         {
00365                 if(capacity() <= mSize)
00366                         grow(capacityIncrement());
00367
00368                 T* ptr = mData + mSize++;
00369                 new (ptr) T; // not 'T()' because PODs should not get default-initialized.
00370                 return *ptr;
00371         }
00372
00374
00381
00382         PX_INLINE void replaceWithLast(uint32_t i)
00383         {
00384                 PX_ASSERT(i < mSize);
00385                 mData[i] = mData[--mSize];
00386
00387                 if (!isArrayOfPOD())
00388                 {
00389                         mData[mSize].~T();
00390                 }
00391         }
00392
00393         PX_INLINE void replaceWithLast(Iterator i)
00394         {
00395                 replaceWithLast(static_cast<uint32_t>(i - mData));
00396         }
00397
00399
00406
00407
00408         PX_INLINE bool findAndReplaceWithLast(const T& a)
00409         {
00410                 uint32_t index = 0;
00411                 while(index < mSize && mData[index] != a)
00412                         ++index;
00413                 if(index == mSize)
00414                         return false;
00415                 replaceWithLast(index);
00416                 return true;
00417         }
00418
00420
00427
00428         PX_INLINE void remove(uint32_t i)
00429         {
00430                 PX_ASSERT(i < mSize);
00431
00432                 if (isArrayOfPOD())
00433                 {
00434                         if (i + 1 != mSize)
00435                         {
00436                                 physx::intrinsics::memMove(mData + i, mData + i + 1, (mSize - i - 1) * sizeof(T));
00437                         }
00438                 }
00439                 else
00440                 {
00441                         for(T* it = mData + i; it->~T(), ++i < mSize; ++it)
00442                                 new (it) T(mData[i]);
00443                 }
00444
00445                 --mSize;
00446         }
00447
00449
00457
00458         PX_INLINE void removeRange(uint32_t begin, uint32_t count)
00459         {
00460                 PX_ASSERT(begin < mSize);
00461                 PX_ASSERT((begin + count) <= mSize);
00462
00463                 if (!isArrayOfPOD())
00464                 {
00465                         for(uint32_t i = 0; i < count; i++)
00466                         {
00467                                 mData[begin + i].~T(); // call the destructor on the ones being removed first.
00468                         }
00469                 }
00470
00471                 T* dest = &mData[begin];                       // location we are copying the tail end objects to
00472                 T* src = &mData[begin + count];                // start of tail objects
00473                 uint32_t move_count = mSize - (begin + count); // compute remainder that needs to be copied down
00474
00475                 if (isArrayOfPOD())
00476                 {
00477                         physx::intrinsics::memMove(dest, src, move_count * sizeof(T));
00478                 }
00479                 else
00480                 {
00481                         for(uint32_t i = 0; i < move_count; i++)
00482                         {
00483                                 new (dest) T(*src); // copy the old one to the new location
00484                                 src->~T();          // call the destructor on the old location
00485                                 dest++;
00486                                 src++;
00487                         }
00488                 }
00489                 mSize -= count;
00490         }
00491
00493
00496
00497         PX_NOINLINE void resize(const uint32_t size, const T& a = T());
00498
00499         PX_NOINLINE void resizeUninitialized(const uint32_t size);
00500
00502
00506
00507         PX_INLINE void shrink()
00508         {
00509                 recreate(mSize);
00510         }
00511
00513
00516
00517         PX_INLINE void reset()
00518         {
00519                 resize(0);
00520                 shrink();
00521         }
00522
00524
00527
00528         PX_INLINE void reserve(const uint32_t capacity)
00529         {
00530                 if(capacity > this->capacity())
00531                         grow(capacity);
00532         }
00533
00535
00538
00539         PX_FORCE_INLINE uint32_t capacity() const
00540         {
00541                 return mCapacity & ~PX_SIGN_BITMASK;
00542         }
00543
00545
00548
00549         PX_FORCE_INLINE void forceSize_Unsafe(uint32_t size)
00550         {
00551                 PX_ASSERT(size <= mCapacity);
00552                 mSize = size;
00553         }
00554
00556
00559
00560         PX_INLINE void swap(Array<T, Alloc>& other)
00561         {
00562                 shdfnd::swap(mData, other.mData);
00563                 shdfnd::swap(mSize, other.mSize);
00564                 shdfnd::swap(mCapacity, other.mCapacity);
00565         }
00566
00568
00571
00572         PX_INLINE void assign(const T* first, const T* last)
00573         {
00574                 resizeUninitialized(uint32_t(last - first));
00575                 copy(begin(), end(), first);
00576         }
00577
00578         // We need one bit to mark arrays that have been deserialized from a user-provided memory block.
00579         // For alignment & memory saving purpose we store that bit in the rarely used capacity member.
00580         PX_FORCE_INLINE uint32_t isInUserMemory() const
00581         {
00582                 return mCapacity & PX_SIGN_BITMASK;
00583         }
00584
00586         PX_INLINE Alloc& getAllocator()
00587         {
00588                 return *this;
00589         }
00590
00591   protected:
00592         // constructor for where we don't own the memory
00593         Array(T* memory, uint32_t size, uint32_t capacity, const Alloc& alloc = Alloc())
00594         : Alloc(alloc), mData(memory), mSize(size), mCapacity(capacity | PX_SIGN_BITMASK)
00595         {
00596         }
00597
00598         template <class A>
00599         PX_NOINLINE void copy(const Array<T, A>& other);
00600
00601         PX_INLINE T* allocate(uint32_t size)
00602         {
00603                 if(size > 0)
00604                 {
00605                         T* p = reinterpret_cast<T*>(Alloc::allocate(sizeof(T) * size, __FILE__, __LINE__));
00610 #if PX_CHECKED
00611                         if(p)
00612                         {
00613                                 for(uint32_t i = 0; i < (sizeof(T) * size); ++i)
00614                                         reinterpret_cast<uint8_t*>(p)[i] = 0xcd;
00615                         }
00616 #endif
00617                         return p;
00618                 }
00619                 return 0;
00620         }
00621
00622         PX_INLINE void deallocate(void* mem)
00623         {
00624                 Alloc::deallocate(mem);
00625         }
00626
00627         static PX_INLINE bool isZeroInit(const T& object)
00628         {
00629                 char ZeroBuffOnStack[sizeof(object)] = {};
00630                 return memcmp(&object, ZeroBuffOnStack, sizeof(object)) == 0;
00631         }
00632
00633         static PX_INLINE void create(T* first, T* last, const T& a)
00634         {
00635                 if (isArrayOfPOD() && isZeroInit(a))
00636                 {
00637                         if(last>first)
00638                                 physx::intrinsics::memZero(first, uint32_t((last-first) * sizeof(T)));
00639                 }
00640                 else
00641                 {
00642                         for(; first<last; ++first)
00643                                 ::new(first)T(a);
00644                 }
00645         }
00646
00647         static PX_INLINE void copy(T* first, T* last, const T* src)
00648         {
00649                 if (last <= first)
00650                         return;
00651
00652                 if (isArrayOfPOD())
00653                 {
00654                         physx::intrinsics::memCopy(first, src, uint32_t((last-first) * sizeof(T)));
00655                 }
00656                 else
00657                 {
00658                         for(; first<last; ++first, ++src)
00659                                 ::new (first)T(*src);
00660                 }
00661         }
00662
00663         static PX_INLINE void destroy(T* first, T* last)
00664         {
00665                 if (!isArrayOfPOD())
00666                 {
00667                         for(; first < last; ++first)
00668                                 first->~T();
00669                 }
00670         }
00671
00676         PX_NOINLINE T& growAndPushBack(const T& a);
00677
00684         PX_INLINE void grow(uint32_t capacity)
00685         {
00686                 PX_ASSERT(this->capacity() < capacity);
00687                 recreate(capacity);
00688         }
00689
00696         PX_NOINLINE void recreate(uint32_t capacity);
00697
00698         // The idea here is to prevent accidental bugs with pushBack or insert. Unfortunately
00699         // it interacts badly with InlineArrays with smaller inline allocations.
00700         // TODO(dsequeira): policy template arg, this is exactly what they're for.
00701         PX_INLINE uint32_t capacityIncrement() const
00702         {
00703                 const uint32_t capacity = this->capacity();
00704                 return capacity == 0 ? 1 : capacity * 2;
00705         }
00706
00707         T* mData;
00708         uint32_t mSize;
00709         uint32_t mCapacity;
00710 };
00711
00712 template <class T, class Alloc>
00713 PX_NOINLINE void Array<T, Alloc>::resize(const uint32_t size, const T& a)
00714 {
00715         reserve(size);
00716         create(mData + mSize, mData + size, a);
00717         destroy(mData + size, mData + mSize);
00718         mSize = size;
00719 }
00720
00721 template <class T, class Alloc>
00722 template <class A>
00723 PX_NOINLINE void Array<T, Alloc>::copy(const Array<T, A>& other)
00724 {
00725         if(!other.empty())
00726         {
00727                 mData = allocate(mSize = mCapacity = other.size());
00728                 copy(mData, mData + mSize, other.begin());
00729         }
00730         else
00731         {
00732                 mData = NULL;
00733                 mSize = 0;
00734                 mCapacity = 0;
00735         }
00736
00737         // mData = allocate(other.mSize);
00738         // mSize = other.mSize;
00739         // mCapacity = other.mSize;
00740         // copy(mData, mData + mSize, other.mData);
00741 }
00742
00743 template <class T, class Alloc>
00744 PX_NOINLINE void Array<T, Alloc>::resizeUninitialized(const uint32_t size)
00745 {
00746         reserve(size);
00747         mSize = size;
00748 }
00749
00750 template <class T, class Alloc>
00751 PX_NOINLINE T& Array<T, Alloc>::growAndPushBack(const T& a)
00752 {
00753         uint32_t capacity = capacityIncrement();
00754
00755         T* newData = allocate(capacity);
00756         PX_ASSERT((!capacity) || (newData && (newData != mData)));
00757         copy(newData, newData + mSize, mData);
00758
00759         // inserting element before destroying old array
00760         // avoids referencing destroyed object when duplicating array element.
00761         PX_PLACEMENT_NEW(reinterpret_cast<void*>(newData + mSize), T)(a);
00762
00763         destroy(mData, mData + mSize);
00764         if(!isInUserMemory())
00765                 deallocate(mData);
00766
00767         mData = newData;
00768         mCapacity = capacity;
00769
00770         return mData[mSize++];
00771 }
00772
00773 template <class T, class Alloc>
00774 PX_NOINLINE void Array<T, Alloc>::recreate(uint32_t capacity)
00775 {
00776         T* newData = allocate(capacity);
00777         PX_ASSERT((!capacity) || (newData && (newData != mData)));
00778
00779         copy(newData, newData + mSize, mData);
00780         destroy(mData, mData + mSize);
00781         if(!isInUserMemory())
00782                 deallocate(mData);
00783
00784         mData = newData;
00785         mCapacity = capacity;
00786 }
00787
00788 template <class T, class Alloc>
00789 PX_INLINE void swap(Array<T, Alloc>& x, Array<T, Alloc>& y)
00790 {
00791         x.swap(y);
00792 }
00793
00794 } // namespace shdfnd
00795 } // namespace physx
00796
00797 #if PX_VC == 9 || PX_VC == 10
00798 #pragma warning(pop)
00799 #endif
00800
00801 #endif // #ifndef PSFOUNDATION_PSARRAY_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSATOMIC_H
00031 #define PSFOUNDATION_PSATOMIC_H
00032
00033 #include "Ps.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00039 /* set *dest equal to val. Return the old value of *dest */
00040 PX_FOUNDATION_API int32_t atomicExchange(volatile int32_t* dest, int32_t val);
00041
00042 /* if *dest == comp, replace with exch. Return original value of *dest */
00043 PX_FOUNDATION_API int32_t atomicCompareExchange(volatile int32_t* dest, int32_t exch, int32_t comp);
00044
00045 /* if *dest == comp, replace with exch. Return original value of *dest */
00046 PX_FOUNDATION_API void* atomicCompareExchangePointer(volatile void** dest, void* exch, void* comp);
00047
00048 /* increment the specified location. Return the incremented value */
00049 PX_FOUNDATION_API int32_t atomicIncrement(volatile int32_t* val);
00050
00051 /* decrement the specified location. Return the decremented value */
00052 PX_FOUNDATION_API int32_t atomicDecrement(volatile int32_t* val);
00053
00054 /* add delta to *val. Return the new value */
00055 PX_FOUNDATION_API int32_t atomicAdd(volatile int32_t* val, int32_t delta);
00056
00057 /* compute the maximum of dest and val. Return the new value */
00058 PX_FOUNDATION_API int32_t atomicMax(volatile int32_t* val, int32_t val2);
00059
00060 } // namespace shdfnd
00061 } // namespace physx
00062
00063 #endif // #ifndef PSFOUNDATION_PSATOMIC_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSBASICTEMPLATES_H
00031 #define PSFOUNDATION_PSBASICTEMPLATES_H
00032
00033 #include "Ps.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00039 template <typename A>
00040 struct Equal
00041 {
00042         bool operator()(const A& a, const A& b) const
00043         {
00044                 return a == b;
00045         }
00046 };
00047
00048 template <typename A>
00049 struct Less
00050 {
00051         bool operator()(const A& a, const A& b) const
00052         {
00053                 return a < b;
00054         }
00055 };
00056
00057 template <typename A>
00058 struct Greater
00059 {
00060         bool operator()(const A& a, const A& b) const
00061         {
00062                 return a > b;
00063         }
00064 };
00065
00066 template <class F, class S>
00067 class Pair
00068 {
00069   public:
00070         F first;
00071         S second;
00072         Pair() : first(F()), second(S())
00073         {
00074         }
00075         Pair(const F& f, const S& s) : first(f), second(s)
00076         {
00077         }
00078         Pair(const Pair& p) : first(p.first), second(p.second)
00079         {
00080         }
00081         // CN - fix for /.../PsBasicTemplates.h(61) : warning C4512: 'physx::shdfnd::Pair<F,S>' : assignment operator could
00082         // not be generated
00083         Pair& operator=(const Pair& p)
00084         {
00085                 first = p.first;
00086                 second = p.second;
00087                 return *this;
00088         }
00089         bool operator==(const Pair& p) const
00090         {
00091                 return first == p.first && second == p.second;
00092         }
00093         bool operator<(const Pair& p) const
00094         {
00095                 if(first < p.first)
00096                         return true;
00097                 else
00098                         return !(p.first < first) && (second < p.second);
00099         }
00100 };
00101
00102 template <unsigned int A>
00103 struct LogTwo
00104 {
00105         static const unsigned int value = LogTwo<(A >> 1)>::value + 1;
00106 };
00107 template <>
00108 struct LogTwo<1>
00109 {
00110         static const unsigned int value = 0;
00111 };
00112
00113 template <typename T>
00114 struct UnConst
00115 {
00116         typedef T Type;
00117 };
00118 template <typename T>
00119 struct UnConst<const T>
00120 {
00121         typedef T Type;
00122 };
00123
00124 template <typename T>
00125 T pointerOffset(void* p, ptrdiff_t offset)
00126 {
00127         return reinterpret_cast<T>(reinterpret_cast<char*>(p) + offset);
00128 }
00129 template <typename T>
00130 T pointerOffset(const void* p, ptrdiff_t offset)
00131 {
00132         return reinterpret_cast<T>(reinterpret_cast<const char*>(p) + offset);
00133 }
00134
00135 template <class T>
00136 PX_CUDA_CALLABLE PX_INLINE void swap(T& x, T& y)
00137 {
00138         const T tmp = x;
00139         x = y;
00140         y = tmp;
00141 }
00142
00143 } // namespace shdfnd
00144 } // namespace physx
00145
00146 #endif // #ifndef PSFOUNDATION_PSBASICTEMPLATES_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSBITUTILS_H
00031 #define PSFOUNDATION_PSBITUTILS_H
00032
00033 #include "foundation/PxIntrinsics.h"
00034 #include "foundation/PxAssert.h"
00035 #include "PsIntrinsics.h"
00036 #include "Ps.h"
00037
00038 namespace physx
00039 {
00040 namespace shdfnd
00041 {
00042 PX_INLINE uint32_t bitCount(uint32_t v)
00043 {
00044         // from http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
00045         uint32_t const w = v - ((v >> 1) & 0x55555555);
00046         uint32_t const x = (w & 0x33333333) + ((w >> 2) & 0x33333333);
00047         return (((x + (x >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
00048 }
00049
00050 PX_INLINE bool isPowerOfTwo(uint32_t x)
00051 {
00052         return x != 0 && (x & (x - 1)) == 0;
00053 }
00054
00055 // "Next Largest Power of 2
00056 // Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm
00057 // that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with
00058 // the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next
00059 // largest power of 2. For a 32-bit value:"
00060 PX_INLINE uint32_t nextPowerOfTwo(uint32_t x)
00061 {
00062         x |= (x >> 1);
00063         x |= (x >> 2);
00064         x |= (x >> 4);
00065         x |= (x >> 8);
00066         x |= (x >> 16);
00067         return x + 1;
00068 }
00069
00074 PX_INLINE uint32_t lowestSetBit(uint32_t x)
00075 {
00076         PX_ASSERT(x);
00077         return lowestSetBitUnsafe(x);
00078 }
00079
00084 PX_INLINE uint32_t highestSetBit(uint32_t x)
00085 {
00086         PX_ASSERT(x);
00087         return highestSetBitUnsafe(x);
00088 }
00089
00090 // Helper function to approximate log2 of an integer value
00091 // assumes that the input is actually power of two.
00092 // todo: replace 2 usages with 'highestSetBit'
00093 PX_INLINE uint32_t ilog2(uint32_t num)
00094 {
00095         for(uint32_t i = 0; i < 32; i++)
00096         {
00097                 num >>= 1;
00098                 if(num == 0)
00099                         return i;
00100         }
00101
00102         PX_ASSERT(0);
00103         return uint32_t(-1);
00104 }
00105
00106 } // namespace shdfnd
00107 } // namespace physx
00108
00109 #endif // #ifndef PSFOUNDATION_PSBITUTILS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSCPU_H
00031 #define PSFOUNDATION_PSCPU_H
00032
00033 #include "Ps.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00039 class Cpu
00040 {
00041   public:
00042         static uint8_t getCpuId();
00043 };
00044 }
00045 }
00046
00047 #endif // #ifndef PSFOUNDATION_PSCPU_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSFPU_H
00031 #define PSFOUNDATION_PSFPU_H
00032
00033 #include "Ps.h"
00034 #include "PsIntrinsics.h"
00035
00036 #define PX_IR(x) ((uint32_t&)(x))
00037 #define PX_SIR(x) ((int32_t&)(x))
00038 #define PX_FR(x) ((float&)(x))
00039
00040 // signed integer representation of a floating-point value.
00041
00042 // Floating-point representation of a integer value.
00043
00044 #define PX_SIGN_BITMASK 0x80000000
00045
00046 #define PX_FPU_GUARD shdfnd::FPUGuard scopedFpGuard;
00047 #define PX_SIMD_GUARD shdfnd::SIMDGuard scopedFpGuard;
00048
00049 #define PX_SUPPORT_GUARDS (PX_WINDOWS_FAMILY || PX_XBOXONE || PX_LINUX || PX_PS4 || PX_OSX)
00050
00051 namespace physx
00052 {
00053 namespace shdfnd
00054 {
00055 // sets the default SDK state for scalar and SIMD units
00056 class PX_FOUNDATION_API FPUGuard
00057 {
00058   public:
00059         FPUGuard();  // set fpu control word for PhysX
00060         ~FPUGuard(); // restore fpu control word
00061   private:
00062         uint32_t mControlWords[8];
00063 };
00064
00065 // sets default SDK state for simd unit only, lighter weight than FPUGuard
00066 class SIMDGuard
00067 {
00068   public:
00069         PX_INLINE SIMDGuard();  // set simd control word for PhysX
00070         PX_INLINE ~SIMDGuard(); // restore simd control word
00071   private:
00072 #if PX_SUPPORT_GUARDS
00073         uint32_t mControlWord;
00074 #endif
00075 };
00076
00080 PX_FOUNDATION_API void enableFPExceptions();
00081
00085 PX_FOUNDATION_API void disableFPExceptions();
00086
00087 } // namespace shdfnd
00088 } // namespace physx
00089
00090 #if PX_WINDOWS_FAMILY || PX_XBOXONE
00091 #include "windows/PsWindowsFPU.h"
00092 #elif PX_LINUX || PX_PS4 || PX_OSX
00093 #include "unix/PsUnixFPU.h"
00094 #else
00095 PX_INLINE physx::shdfnd::SIMDGuard::SIMDGuard()
00096 {
00097 }
00098 PX_INLINE physx::shdfnd::SIMDGuard::~SIMDGuard()
00099 {
00100 }
00101 #endif
00102
00103 #endif // #ifndef PSFOUNDATION_PSFPU_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSGLOBALS_H
00031 #define PSFOUNDATION_PSGLOBALS_H
00032
00033 #include "foundation/PxErrors.h"
00034
00035 namespace physx
00036 {
00037
00038 class PxAssertHandler;
00039 class PxErrorCallback;
00040 class PxAllocatorCallback;
00041 class PxProfilerCallback;
00042
00043 namespace shdfnd
00044 {
00045
00046 // note: it's illegal to initialize the shared foundation twice without terminating in between
00047
00048 PX_FOUNDATION_API void initializeSharedFoundation(uint32_t version, PxAllocatorCallback&, PxErrorCallback&);
00049 PX_FOUNDATION_API bool sharedFoundationIsInitialized();
00050 PX_FOUNDATION_API void terminateSharedFoundation();
00051
00052 // number of times foundation has been init'd. 0 means never initialized, so if we wrap we go from UINT32_MAX to 1. Used
00053 // for things that happen at most once (e.g. some warnings)
00054 PX_FOUNDATION_API uint32_t getInitializationCount();
00055
00056 PX_FOUNDATION_API PxAllocatorCallback& getAllocator();
00057 PX_FOUNDATION_API PxErrorCallback& getErrorCallback();
00058
00059 // on some platforms (notably 360) the CRT does non-recoverable allocations when asked for type names. Hence
00060 // we provide a mechanism to disable this capability
00061 PX_FOUNDATION_API void setReflectionAllocatorReportsNames(bool val);
00062 PX_FOUNDATION_API bool getReflectionAllocatorReportsNames();
00063
00064
00065 PX_FOUNDATION_API PxProfilerCallback *getProfilerCallback();
00066 PX_FOUNDATION_API void setProfilerCallback(PxProfilerCallback *profiler);
00067
00068
00069 }
00070 }
00071
00072 #endif // #ifndef PSFOUNDATION_PSGLOBALS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSHASH_H
00031 #define PSFOUNDATION_PSHASH_H
00032
00033 #include "Ps.h"
00034 #include "PsBasicTemplates.h"
00035
00036 #if PX_VC
00037 #pragma warning(push)
00038 #pragma warning(disable : 4302)
00039 #endif
00040
00041 #if PX_LINUX
00042 #include "PxSimpleTypes.h"
00043 #endif
00044
00049 namespace physx
00050 {
00051 namespace shdfnd
00052 {
00053 // Hash functions
00054
00055 // Thomas Wang's 32 bit mix
00056 // http://www.cris.com/~Ttwang/tech/inthash.htm
00057 PX_FORCE_INLINE uint32_t hash(const uint32_t key)
00058 {
00059         uint32_t k = key;
00060         k += ~(k << 15);
00061         k ^= (k >> 10);
00062         k += (k << 3);
00063         k ^= (k >> 6);
00064         k += ~(k << 11);
00065         k ^= (k >> 16);
00066         return uint32_t(k);
00067 }
00068
00069 PX_FORCE_INLINE uint32_t hash(const int32_t key)
00070 {
00071         return hash(uint32_t(key));
00072 }
00073
00074 // Thomas Wang's 64 bit mix
00075 // http://www.cris.com/~Ttwang/tech/inthash.htm
00076 PX_FORCE_INLINE uint32_t hash(const uint64_t key)
00077 {
00078         uint64_t k = key;
00079         k += ~(k << 32);
00080         k ^= (k >> 22);
00081         k += ~(k << 13);
00082         k ^= (k >> 8);
00083         k += (k << 3);
00084         k ^= (k >> 15);
00085         k += ~(k << 27);
00086         k ^= (k >> 31);
00087         return uint32_t(UINT32_MAX & k);
00088 }
00089
00090 #if PX_APPLE_FAMILY
00091 // hash for size_t, to make gcc happy
00092 PX_INLINE uint32_t hash(const size_t key)
00093 {
00094 #if PX_P64_FAMILY
00095         return hash(uint64_t(key));
00096 #else
00097         return hash(uint32_t(key));
00098 #endif
00099 }
00100 #endif
00101
00102 // Hash function for pointers
00103 PX_INLINE uint32_t hash(const void* ptr)
00104 {
00105 #if PX_P64_FAMILY
00106         return hash(uint64_t(ptr));
00107 #else
00108         return hash(uint32_t(UINT32_MAX & size_t(ptr)));
00109 #endif
00110 }
00111
00112 // Hash function for pairs
00113 template <typename F, typename S>
00114 PX_INLINE uint32_t hash(const Pair<F, S>& p)
00115 {
00116         uint32_t seed = 0x876543;
00117         uint32_t m = 1000007;
00118         return hash(p.second) ^ (m * (hash(p.first) ^ (m * seed)));
00119 }
00120
00121 // hash object for hash map template parameter
00122 template <class Key>
00123 struct Hash
00124 {
00125         uint32_t operator()(const Key& k) const
00126         {
00127                 return hash(k);
00128         }
00129         bool equal(const Key& k0, const Key& k1) const
00130         {
00131                 return k0 == k1;
00132         }
00133 };
00134
00135 // specialization for strings
00136 template <>
00137 struct Hash<const char*>
00138 {
00139   public:
00140         uint32_t operator()(const char* _string) const
00141         {
00142                 // "DJB" string hash
00143                 const uint8_t* string = reinterpret_cast<const uint8_t*>(_string);
00144                 uint32_t h = 5381;
00145                 for(const uint8_t* ptr = string; *ptr; ptr++)
00146                         h = ((h << 5) + h) ^ uint32_t(*ptr);
00147                 return h;
00148         }
00149         bool equal(const char* string0, const char* string1) const
00150         {
00151                 return !strcmp(string0, string1);
00152         }
00153 };
00154
00155 } // namespace shdfnd
00156 } // namespace physx
00157
00158 #if PX_VC
00159 #pragma warning(pop)
00160 #endif
00161
00162 #endif // #ifndef PSFOUNDATION_PSHASH_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSHASHINTERNALS_H
00031 #define PSFOUNDATION_PSHASHINTERNALS_H
00032
00033 #include "PsBasicTemplates.h"
00034 #include "PsArray.h"
00035 #include "PsBitUtils.h"
00036 #include "PsHash.h"
00037 #include "foundation/PxIntrinsics.h"
00038
00039 #if PX_VC
00040 #pragma warning(push)
00041 #pragma warning(disable : 4127) // conditional expression is constant
00042 #endif
00043 namespace physx
00044 {
00045 namespace shdfnd
00046 {
00047 namespace internal
00048 {
00049 template <class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
00050 class HashBase : private Allocator
00051 {
00052         void init(uint32_t initialTableSize, float loadFactor)
00053         {
00054                 mBuffer = NULL;
00055                 mEntries = NULL;
00056                 mEntriesNext = NULL;
00057                 mHash = NULL;
00058                 mEntriesCapacity = 0;
00059                 mHashSize = 0;
00060                 mLoadFactor = loadFactor;
00061                 mFreeList = uint32_t(EOL);
00062                 mTimestamp = 0;
00063                 mEntriesCount = 0;
00064
00065                 if(initialTableSize)
00066                         reserveInternal(initialTableSize);
00067         }
00068
00069   public:
00070         typedef Entry EntryType;
00071
00072         HashBase(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : Allocator(PX_DEBUG_EXP("hashBase"))
00073         {
00074                 init(initialTableSize, loadFactor);
00075         }
00076
00077         HashBase(uint32_t initialTableSize, float loadFactor, const Allocator& alloc) : Allocator(alloc)
00078         {
00079                 init(initialTableSize, loadFactor);
00080         }
00081
00082         HashBase(const Allocator& alloc) : Allocator(alloc)
00083         {
00084                 init(64, 0.75f);
00085         }
00086
00087         ~HashBase()
00088         {
00089                 destroy(); // No need to clear()
00090
00091                 if(mBuffer)
00092                         Allocator::deallocate(mBuffer);
00093         }
00094
00095         static const uint32_t EOL = 0xffffffff;
00096
00097         PX_INLINE Entry* create(const Key& k, bool& exists)
00098         {
00099                 uint32_t h = 0;
00100                 if(mHashSize)
00101                 {
00102                         h = hash(k);
00103                         uint32_t index = mHash[h];
00104                         while(index != EOL && !HashFn().equal(GetKey()(mEntries[index]), k))
00105                                 index = mEntriesNext[index];
00106                         exists = index != EOL;
00107                         if(exists)
00108                                 return mEntries + index;
00109                 }
00110                 else
00111                         exists = false;
00112
00113                 if(freeListEmpty())
00114                 {
00115                         grow();
00116                         h = hash(k);
00117                 }
00118
00119                 uint32_t entryIndex = freeListGetNext();
00120
00121                 mEntriesNext[entryIndex] = mHash[h];
00122                 mHash[h] = entryIndex;
00123
00124                 mEntriesCount++;
00125                 mTimestamp++;
00126
00127                 return mEntries + entryIndex;
00128         }
00129
00130         PX_INLINE const Entry* find(const Key& k) const
00131         {
00132                 if(!mHashSize)
00133                         return NULL;
00134
00135                 const uint32_t h = hash(k);
00136                 uint32_t index = mHash[h];
00137                 while(index != EOL && !HashFn().equal(GetKey()(mEntries[index]), k))
00138                         index = mEntriesNext[index];
00139                 return index != EOL ? mEntries + index : NULL;
00140         }
00141
00142         PX_INLINE bool erase(const Key& k)
00143         {
00144                 if(!mHashSize)
00145                         return false;
00146
00147                 const uint32_t h = hash(k);
00148                 uint32_t* ptr = mHash + h;
00149                 while(*ptr != EOL && !HashFn().equal(GetKey()(mEntries[*ptr]), k))
00150                         ptr = mEntriesNext + *ptr;
00151
00152                 if(*ptr == EOL)
00153                         return false;
00154
00155                 const uint32_t index = *ptr;
00156                 *ptr = mEntriesNext[index];
00157
00158                 mEntries[index].~Entry();
00159
00160                 mEntriesCount--;
00161                 mTimestamp++;
00162
00163                 if(compacting && index != mEntriesCount)
00164                         replaceWithLast(index);
00165
00166                 freeListAdd(index);
00167
00168                 return true;
00169         }
00170
00171         PX_INLINE uint32_t size() const
00172         {
00173                 return mEntriesCount;
00174         }
00175
00176         PX_INLINE uint32_t capacity() const
00177         {
00178                 return mHashSize;
00179         }
00180
00181         void clear()
00182         {
00183                 if(!mHashSize || mEntriesCount == 0)
00184                         return;
00185
00186                 destroy();
00187
00188                 intrinsics::memSet(mHash, EOL, mHashSize * sizeof(uint32_t));
00189
00190                 const uint32_t sizeMinus1 = mEntriesCapacity - 1;
00191                 for(uint32_t i = 0; i < sizeMinus1; i++)
00192                 {
00193                         prefetchLine(mEntriesNext + i, 128);
00194                         mEntriesNext[i] = i + 1;
00195                 }
00196                 mEntriesNext[mEntriesCapacity - 1] = uint32_t(EOL);
00197                 mFreeList = 0;
00198                 mEntriesCount = 0;
00199         }
00200
00201         void reserve(uint32_t size)
00202         {
00203                 if(size > mHashSize)
00204                         reserveInternal(size);
00205         }
00206
00207         PX_INLINE const Entry* getEntries() const
00208         {
00209                 return mEntries;
00210         }
00211
00212         PX_INLINE Entry* insertUnique(const Key& k)
00213         {
00214                 PX_ASSERT(find(k) == NULL);
00215                 uint32_t h = hash(k);
00216
00217                 uint32_t entryIndex = freeListGetNext();
00218
00219                 mEntriesNext[entryIndex] = mHash[h];
00220                 mHash[h] = entryIndex;
00221
00222                 mEntriesCount++;
00223                 mTimestamp++;
00224
00225                 return mEntries + entryIndex;
00226         }
00227
00228   private:
00229         void destroy()
00230         {
00231                 for(uint32_t i = 0; i < mHashSize; i++)
00232                 {
00233                         for(uint32_t j = mHash[i]; j != EOL; j = mEntriesNext[j])
00234                                 mEntries[j].~Entry();
00235                 }
00236         }
00237
00238         template <typename HK, typename GK, class A, bool comp>
00239         PX_NOINLINE void copy(const HashBase<Entry, Key, HK, GK, A, comp>& other);
00240
00241         // free list management - if we're coalescing, then we use mFreeList to hold
00242         // the top of the free list and it should always be equal to size(). Otherwise,
00243         // we build a free list in the next() pointers.
00244
00245         PX_INLINE void freeListAdd(uint32_t index)
00246         {
00247                 if(compacting)
00248                 {
00249                         mFreeList--;
00250                         PX_ASSERT(mFreeList == mEntriesCount);
00251                 }
00252                 else
00253                 {
00254                         mEntriesNext[index] = mFreeList;
00255                         mFreeList = index;
00256                 }
00257         }
00258
00259         PX_INLINE void freeListAdd(uint32_t start, uint32_t end)
00260         {
00261                 if(!compacting)
00262                 {
00263                         for(uint32_t i = start; i < end - 1; i++) // add the new entries to the free list
00264                                 mEntriesNext[i] = i + 1;
00265
00266                         // link in old free list
00267                         mEntriesNext[end - 1] = mFreeList;
00268                         PX_ASSERT(mFreeList != end - 1);
00269                         mFreeList = start;
00270                 }
00271                 else if(mFreeList == EOL) // don't reset the free ptr for the compacting hash unless it's empty
00272                         mFreeList = start;
00273         }
00274
00275         PX_INLINE uint32_t freeListGetNext()
00276         {
00277                 PX_ASSERT(!freeListEmpty());
00278                 if(compacting)
00279                 {
00280                         PX_ASSERT(mFreeList == mEntriesCount);
00281                         return mFreeList++;
00282                 }
00283                 else
00284                 {
00285                         uint32_t entryIndex = mFreeList;
00286                         mFreeList = mEntriesNext[mFreeList];
00287                         return entryIndex;
00288                 }
00289         }
00290
00291         PX_INLINE bool freeListEmpty() const
00292         {
00293                 if(compacting)
00294                         return mEntriesCount == mEntriesCapacity;
00295                 else
00296                         return mFreeList == EOL;
00297         }
00298
00299         PX_INLINE void replaceWithLast(uint32_t index)
00300         {
00301                 PX_PLACEMENT_NEW(mEntries + index, Entry)(mEntries[mEntriesCount]);
00302                 mEntries[mEntriesCount].~Entry();
00303                 mEntriesNext[index] = mEntriesNext[mEntriesCount];
00304
00305                 uint32_t h = hash(GetKey()(mEntries[index]));
00306                 uint32_t* ptr;
00307                 for(ptr = mHash + h; *ptr != mEntriesCount; ptr = mEntriesNext + *ptr)
00308                         PX_ASSERT(*ptr != EOL);
00309                 *ptr = index;
00310         }
00311
00312         PX_INLINE uint32_t hash(const Key& k, uint32_t hashSize) const
00313         {
00314                 return HashFn()(k) & (hashSize - 1);
00315         }
00316
00317         PX_INLINE uint32_t hash(const Key& k) const
00318         {
00319                 return hash(k, mHashSize);
00320         }
00321
00322         void reserveInternal(uint32_t size)
00323         {
00324                 if(!isPowerOfTwo(size))
00325                         size = nextPowerOfTwo(size);
00326
00327                 PX_ASSERT(!(size & (size - 1)));
00328
00329                 // decide whether iteration can be done on the entries directly
00330                 bool resizeCompact = compacting || freeListEmpty();
00331
00332                 // define new table sizes
00333                 uint32_t oldEntriesCapacity = mEntriesCapacity;
00334                 uint32_t newEntriesCapacity = uint32_t(float(size) * mLoadFactor);
00335                 uint32_t newHashSize = size;
00336
00337                 // allocate new common buffer and setup pointers to new tables
00338                 uint8_t* newBuffer;
00339                 uint32_t* newHash;
00340                 uint32_t* newEntriesNext;
00341                 Entry* newEntries;
00342                 {
00343                         uint32_t newHashByteOffset = 0;
00344                         uint32_t newEntriesNextBytesOffset = newHashByteOffset + newHashSize * sizeof(uint32_t);
00345                         uint32_t newEntriesByteOffset = newEntriesNextBytesOffset + newEntriesCapacity * sizeof(uint32_t);
00346                         newEntriesByteOffset += (16 - (newEntriesByteOffset & 15)) & 15;
00347                         uint32_t newBufferByteSize = newEntriesByteOffset + newEntriesCapacity * sizeof(Entry);
00348
00349                         newBuffer = reinterpret_cast<uint8_t*>(Allocator::allocate(newBufferByteSize, __FILE__, __LINE__));
00350                         PX_ASSERT(newBuffer);
00351
00352                         newHash = reinterpret_cast<uint32_t*>(newBuffer + newHashByteOffset);
00353                         newEntriesNext = reinterpret_cast<uint32_t*>(newBuffer + newEntriesNextBytesOffset);
00354                         newEntries = reinterpret_cast<Entry*>(newBuffer + newEntriesByteOffset);
00355                 }
00356
00357                 // initialize new hash table
00358                 intrinsics::memSet(newHash, uint32_t(EOL), newHashSize * sizeof(uint32_t));
00359
00360                 // iterate over old entries, re-hash and create new entries
00361                 if(resizeCompact)
00362                 {
00363                         // check that old free list is empty - we don't need to copy the next entries
00364                         PX_ASSERT(compacting || mFreeList == EOL);
00365
00366                         for(uint32_t index = 0; index < mEntriesCount; ++index)
00367                         {
00368                                 uint32_t h = hash(GetKey()(mEntries[index]), newHashSize);
00369                                 newEntriesNext[index] = newHash[h];
00370                                 newHash[h] = index;
00371
00372                                 PX_PLACEMENT_NEW(newEntries + index, Entry)(mEntries[index]);
00373                                 mEntries[index].~Entry();
00374                         }
00375                 }
00376                 else
00377                 {
00378                         // copy old free list, only required for non compact resizing
00379                         intrinsics::memCopy(newEntriesNext, mEntriesNext, mEntriesCapacity * sizeof(uint32_t));
00380
00381                         for(uint32_t bucket = 0; bucket < mHashSize; bucket++)
00382                         {
00383                                 uint32_t index = mHash[bucket];
00384                                 while(index != EOL)
00385                                 {
00386                                         uint32_t h = hash(GetKey()(mEntries[index]), newHashSize);
00387                                         newEntriesNext[index] = newHash[h];
00388                                         PX_ASSERT(index != newHash[h]);
00389
00390                                         newHash[h] = index;
00391
00392                                         PX_PLACEMENT_NEW(newEntries + index, Entry)(mEntries[index]);
00393                                         mEntries[index].~Entry();
00394
00395                                         index = mEntriesNext[index];
00396                                 }
00397                         }
00398                 }
00399
00400                 // swap buffer and pointers
00401                 Allocator::deallocate(mBuffer);
00402                 mBuffer = newBuffer;
00403                 mHash = newHash;
00404                 mHashSize = newHashSize;
00405                 mEntriesNext = newEntriesNext;
00406                 mEntries = newEntries;
00407                 mEntriesCapacity = newEntriesCapacity;
00408
00409                 freeListAdd(oldEntriesCapacity, newEntriesCapacity);
00410         }
00411
00412         void grow()
00413         {
00414                 PX_ASSERT((mFreeList == EOL) || (compacting && (mEntriesCount == mEntriesCapacity)));
00415
00416                 uint32_t size = mHashSize == 0 ? 16 : mHashSize * 2;
00417                 reserve(size);
00418         }
00419
00420         uint8_t* mBuffer;
00421         Entry* mEntries;
00422         uint32_t* mEntriesNext; // same size as mEntries
00423         uint32_t* mHash;
00424         uint32_t mEntriesCapacity;
00425         uint32_t mHashSize;
00426         float mLoadFactor;
00427         uint32_t mFreeList;
00428         uint32_t mTimestamp;
00429         uint32_t mEntriesCount; // number of entries
00430
00431   public:
00432         class Iter
00433         {
00434           public:
00435                 PX_INLINE Iter(HashBase& b) : mBucket(0), mEntry(uint32_t(b.EOL)), mTimestamp(b.mTimestamp), mBase(b)
00436                 {
00437                         if(mBase.mEntriesCapacity > 0)
00438                         {
00439                                 mEntry = mBase.mHash[0];
00440                                 skip();
00441                         }
00442                 }
00443
00444                 PX_INLINE void check() const
00445                 {
00446                         PX_ASSERT(mTimestamp == mBase.mTimestamp);
00447                 }
00448                 PX_INLINE Entry operator*() const
00449                 {
00450                         check();
00451                         return mBase.mEntries[mEntry];
00452                 }
00453                 PX_INLINE Entry* operator->() const
00454                 {
00455                         check();
00456                         return mBase.mEntries + mEntry;
00457                 }
00458                 PX_INLINE Iter operator++()
00459                 {
00460                         check();
00461                         advance();
00462                         return *this;
00463                 }
00464                 PX_INLINE Iter operator++(int)
00465                 {
00466                         check();
00467                         Iter i = *this;
00468                         advance();
00469                         return i;
00470                 }
00471                 PX_INLINE bool done() const
00472                 {
00473                         check();
00474                         return mEntry == mBase.EOL;
00475                 }
00476
00477           private:
00478                 PX_INLINE void advance()
00479                 {
00480                         mEntry = mBase.mEntriesNext[mEntry];
00481                         skip();
00482                 }
00483                 PX_INLINE void skip()
00484                 {
00485                         while(mEntry == mBase.EOL)
00486                         {
00487                                 if(++mBucket == mBase.mHashSize)
00488                                         break;
00489                                 mEntry = mBase.mHash[mBucket];
00490                         }
00491                 }
00492
00493                 Iter& operator=(const Iter&);
00494
00495                 uint32_t mBucket;
00496                 uint32_t mEntry;
00497                 uint32_t mTimestamp;
00498                 HashBase& mBase;
00499         };
00500 };
00501
00502 template <class Entry, class Key, class HashFn, class GetKey, class Allocator, bool compacting>
00503 template <typename HK, typename GK, class A, bool comp>
00504 PX_NOINLINE void
00505 HashBase<Entry, Key, HashFn, GetKey, Allocator, compacting>::copy(const HashBase<Entry, Key, HK, GK, A, comp>& other)
00506 {
00507         reserve(other.mEntriesCount);
00508
00509         for(uint32_t i = 0; i < other.mEntriesCount; i++)
00510         {
00511                 for(uint32_t j = other.mHash[i]; j != EOL; j = other.mEntriesNext[j])
00512                 {
00513                         const Entry& otherEntry = other.mEntries[j];
00514
00515                         bool exists;
00516                         Entry* newEntry = create(GK()(otherEntry), exists);
00517                         PX_ASSERT(!exists);
00518
00519                         PX_PLACEMENT_NEW(newEntry, Entry)(otherEntry);
00520                 }
00521         }
00522 }
00523
00524 template <class Key, class HashFn, class Allocator = typename AllocatorTraits<Key>::Type, bool Coalesced = false>
00525 class HashSetBase
00526 {
00527         PX_NOCOPY(HashSetBase)
00528   public:
00529         struct GetKey
00530         {
00531                 PX_INLINE const Key& operator()(const Key& e)
00532                 {
00533                         return e;
00534                 }
00535         };
00536
00537         typedef HashBase<Key, Key, HashFn, GetKey, Allocator, Coalesced> BaseMap;
00538         typedef typename BaseMap::Iter Iterator;
00539
00540         HashSetBase(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
00541         : mBase(initialTableSize, loadFactor, alloc)
00542         {
00543         }
00544
00545         HashSetBase(const Allocator& alloc) : mBase(64, 0.75f, alloc)
00546         {
00547         }
00548
00549         HashSetBase(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : mBase(initialTableSize, loadFactor)
00550         {
00551         }
00552
00553         bool insert(const Key& k)
00554         {
00555                 bool exists;
00556                 Key* e = mBase.create(k, exists);
00557                 if(!exists)
00558                         PX_PLACEMENT_NEW(e, Key)(k);
00559                 return !exists;
00560         }
00561
00562         PX_INLINE bool contains(const Key& k) const
00563         {
00564                 return mBase.find(k) != 0;
00565         }
00566         PX_INLINE bool erase(const Key& k)
00567         {
00568                 return mBase.erase(k);
00569         }
00570         PX_INLINE uint32_t size() const
00571         {
00572                 return mBase.size();
00573         }
00574         PX_INLINE uint32_t capacity() const
00575         {
00576                 return mBase.capacity();
00577         }
00578         PX_INLINE void reserve(uint32_t size)
00579         {
00580                 mBase.reserve(size);
00581         }
00582         PX_INLINE void clear()
00583         {
00584                 mBase.clear();
00585         }
00586
00587   protected:
00588         BaseMap mBase;
00589 };
00590
00591 template <class Key, class Value, class HashFn, class Allocator = typename AllocatorTraits<Pair<const Key, Value> >::Type>
00592 class HashMapBase
00593 {
00594         PX_NOCOPY(HashMapBase)
00595   public:
00596         typedef Pair<const Key, Value> Entry;
00597
00598         struct GetKey
00599         {
00600                 PX_INLINE const Key& operator()(const Entry& e)
00601                 {
00602                         return e.first;
00603                 }
00604         };
00605
00606         typedef HashBase<Entry, Key, HashFn, GetKey, Allocator, true> BaseMap;
00607         typedef typename BaseMap::Iter Iterator;
00608
00609         HashMapBase(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
00610         : mBase(initialTableSize, loadFactor, alloc)
00611         {
00612         }
00613
00614         HashMapBase(const Allocator& alloc) : mBase(64, 0.75f, alloc)
00615         {
00616         }
00617
00618         HashMapBase(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : mBase(initialTableSize, loadFactor)
00619         {
00620         }
00621
00622         bool insert(const Key /*&*/ k, const Value /*&*/ v)
00623         {
00624                 bool exists;
00625                 Entry* e = mBase.create(k, exists);
00626                 if(!exists)
00627                         PX_PLACEMENT_NEW(e, Entry)(k, v);
00628                 return !exists;
00629         }
00630
00631         Value& operator[](const Key& k)
00632         {
00633                 bool exists;
00634                 Entry* e = mBase.create(k, exists);
00635                 if(!exists)
00636                         PX_PLACEMENT_NEW(e, Entry)(k, Value());
00637
00638                 return e->second;
00639         }
00640
00641         PX_INLINE const Entry* find(const Key& k) const
00642         {
00643                 return mBase.find(k);
00644         }
00645         PX_INLINE bool erase(const Key& k)
00646         {
00647                 return mBase.erase(k);
00648         }
00649         PX_INLINE uint32_t size() const
00650         {
00651                 return mBase.size();
00652         }
00653         PX_INLINE uint32_t capacity() const
00654         {
00655                 return mBase.capacity();
00656         }
00657         PX_INLINE Iterator getIterator()
00658         {
00659                 return Iterator(mBase);
00660         }
00661         PX_INLINE void reserve(uint32_t size)
00662         {
00663                 mBase.reserve(size);
00664         }
00665         PX_INLINE void clear()
00666         {
00667                 mBase.clear();
00668         }
00669
00670   protected:
00671         BaseMap mBase;
00672 };
00673 }
00674
00675 } // namespace shdfnd
00676 } // namespace physx
00677
00678 #if PX_VC
00679 #pragma warning(pop)
00680 #endif
00681 #endif // #ifndef PSFOUNDATION_PSHASHINTERNALS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSHASHMAP_H
00031 #define PSFOUNDATION_PSHASHMAP_H
00032
00033 #include "PsHashInternals.h"
00034
00035 // TODO: make this doxy-format
00036 //
00037 // This header defines two hash maps. Hash maps
00038 // * support custom initial table sizes (rounded up internally to power-of-2)
00039 // * support custom static allocator objects
00040 // * auto-resize, based on a load factor (i.e. a 64-entry .75 load factor hash will resize
00041 //                                        when the 49th element is inserted)
00042 // * are based on open hashing
00043 // * have O(1) contains, erase
00044 //
00045 // Maps have STL-like copying semantics, and properly initialize and destruct copies of objects
00046 //
00047 // There are two forms of map: coalesced and uncoalesced. Coalesced maps keep the entries in the
00048 // initial segment of an array, so are fast to iterate over; however deletion is approximately
00049 // twice as expensive.
00050 //
00051 // HashMap<T>:
00052 //              bool                    insert(const Key& k, const Value& v)    O(1) amortized (exponential resize policy)
00053 //              Value &                 operator[](const Key& k)                                O(1) for existing objects, else O(1) amortized
00054 //              const Entry *   find(const Key& k);                                             O(1)
00055 //              bool                    erase(const T& k);                                              O(1)
00056 //              uint32_t                        size();                                                                 constant
00057 //              void                    reserve(uint32_t size);                                 O(MAX(currentOccupancy,size))
00058 //              void                    clear();                                                                O(currentOccupancy) (with zero constant for objects
00059 // without
00060 // destructors)
00061 //      Iterator                getIterator();
00062 //
00063 // operator[] creates an entry if one does not exist, initializing with the default constructor.
00064 // CoalescedHashMap<T> does not support getIterator, but instead supports
00065 //              const Key *getEntries();
00066 //
00067 // Use of iterators:
00068 //
00069 // for(HashMap::Iterator iter = test.getIterator(); !iter.done(); ++iter)
00070 //                      myFunction(iter->first, iter->second);
00071
00072 namespace physx
00073 {
00074 namespace shdfnd
00075 {
00076 template <class Key, class Value, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
00077 class HashMap : public internal::HashMapBase<Key, Value, HashFn, Allocator>
00078 {
00079   public:
00080         typedef internal::HashMapBase<Key, Value, HashFn, Allocator> HashMapBase;
00081         typedef typename HashMapBase::Iterator Iterator;
00082
00083         HashMap(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : HashMapBase(initialTableSize, loadFactor)
00084         {
00085         }
00086         HashMap(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
00087         : HashMapBase(initialTableSize, loadFactor, alloc)
00088         {
00089         }
00090         HashMap(const Allocator& alloc) : HashMapBase(64, 0.75f, alloc)
00091         {
00092         }
00093         Iterator getIterator()
00094         {
00095                 return Iterator(HashMapBase::mBase);
00096         }
00097 };
00098
00099 template <class Key, class Value, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
00100 class CoalescedHashMap : public internal::HashMapBase<Key, Value, HashFn, Allocator>
00101 {
00102   public:
00103         typedef internal::HashMapBase<Key, Value, HashFn, Allocator> HashMapBase;
00104
00105         CoalescedHashMap(uint32_t initialTableSize = 64, float loadFactor = 0.75f)
00106         : HashMapBase(initialTableSize, loadFactor)
00107         {
00108         }
00109         const Pair<const Key, Value>* getEntries() const
00110         {
00111                 return HashMapBase::mBase.getEntries();
00112         }
00113 };
00114
00115 } // namespace shdfnd
00116 } // namespace physx
00117
00118 #endif // #ifndef PSFOUNDATION_PSHASHMAP_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSHASHSET_H
00031 #define PSFOUNDATION_PSHASHSET_H
00032
00033 #include "PsHashInternals.h"
00034
00035 // TODO: make this doxy-format
00036
00037 // This header defines two hash sets. Hash sets
00038 // * support custom initial table sizes (rounded up internally to power-of-2)
00039 // * support custom static allocator objects
00040 // * auto-resize, based on a load factor (i.e. a 64-entry .75 load factor hash will resize
00041 //                                        when the 49th element is inserted)
00042 // * are based on open hashing
00043 //
00044 // Sets have STL-like copying semantics, and properly initialize and destruct copies of objects
00045 //
00046 // There are two forms of set: coalesced and uncoalesced. Coalesced sets keep the entries in the
00047 // initial segment of an array, so are fast to iterate over; however deletion is approximately
00048 // twice as expensive.
00049 //
00050 // HashSet<T>:
00051 //              bool            insert(const T& k)                                              amortized O(1) (exponential resize policy)
00052 //              bool            contains(const T& k)    const;                  O(1)
00053 //              bool            erase(const T& k);                                              O(1)
00054 //              uint32_t                size()                                  const;                  constant
00055 //              void            reserve(uint32_t size);                                 O(MAX(size, currentOccupancy))
00056 //              void            clear();                                                                O(currentOccupancy) (with zero constant for objects without
00057 // destructors)
00058 //      Iterator    getIterator();
00059 //
00060 // Use of iterators:
00061 //
00062 // for(HashSet::Iterator iter = test.getIterator(); !iter.done(); ++iter)
00063 //                      myFunction(*iter);
00064 //
00065 // CoalescedHashSet<T> does not support getIterator, but instead supports
00066 //              const Key *getEntries();
00067 //
00068 // insertion into a set already containing the element fails returning false, as does
00069 // erasure of an element not in the set
00070 //
00071
00072 namespace physx
00073 {
00074 namespace shdfnd
00075 {
00076 template <class Key, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
00077 class HashSet : public internal::HashSetBase<Key, HashFn, Allocator, false>
00078 {
00079   public:
00080         typedef internal::HashSetBase<Key, HashFn, Allocator, false> HashSetBase;
00081         typedef typename HashSetBase::Iterator Iterator;
00082
00083         HashSet(uint32_t initialTableSize = 64, float loadFactor = 0.75f) : HashSetBase(initialTableSize, loadFactor)
00084         {
00085         }
00086         HashSet(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
00087         : HashSetBase(initialTableSize, loadFactor, alloc)
00088         {
00089         }
00090         HashSet(const Allocator& alloc) : HashSetBase(64, 0.75f, alloc)
00091         {
00092         }
00093         Iterator getIterator()
00094         {
00095                 return Iterator(HashSetBase::mBase);
00096         }
00097 };
00098
00099 template <class Key, class HashFn = Hash<Key>, class Allocator = NonTrackingAllocator>
00100 class CoalescedHashSet : public internal::HashSetBase<Key, HashFn, Allocator, true>
00101 {
00102   public:
00103         typedef typename internal::HashSetBase<Key, HashFn, Allocator, true> HashSetBase;
00104
00105         CoalescedHashSet(uint32_t initialTableSize = 64, float loadFactor = 0.75f)
00106         : HashSetBase(initialTableSize, loadFactor)
00107         {
00108         }
00109
00110         CoalescedHashSet(uint32_t initialTableSize, float loadFactor, const Allocator& alloc)
00111         : HashSetBase(initialTableSize, loadFactor, alloc)
00112         {
00113         }
00114         CoalescedHashSet(const Allocator& alloc) : HashSetBase(64, 0.75f, alloc)
00115         {
00116         }
00117
00118         const Key* getEntries() const
00119         {
00120                 return HashSetBase::mBase.getEntries();
00121         }
00122 };
00123
00124 } // namespace shdfnd
00125 } // namespace physx
00126
00127 #endif // #ifndef PSFOUNDATION_PSHASHSET_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSINLINEALLOCATOR_H
00031 #define PSFOUNDATION_PSINLINEALLOCATOR_H
00032
00033 #include "PsUserAllocated.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00039 // this is used by the array class to allocate some space for a small number
00040 // of objects along with the metadata
00041 template <uint32_t N, typename BaseAllocator>
00042 class InlineAllocator : private BaseAllocator
00043 {
00044   public:
00045         InlineAllocator(const PxEMPTY v) : BaseAllocator(v)
00046         {
00047         }
00048
00049         InlineAllocator(const BaseAllocator& alloc = BaseAllocator()) : BaseAllocator(alloc), mBufferUsed(false)
00050         {
00051         }
00052
00053         InlineAllocator(const InlineAllocator& aloc) : BaseAllocator(aloc), mBufferUsed(false)
00054         {
00055         }
00056
00057         void* allocate(uint32_t size, const char* filename, int line)
00058         {
00059                 if(!mBufferUsed && size <= N)
00060                 {
00061                         mBufferUsed = true;
00062                         return mBuffer;
00063                 }
00064                 return BaseAllocator::allocate(size, filename, line);
00065         }
00066
00067         void deallocate(void* ptr)
00068         {
00069                 if(ptr == mBuffer)
00070                         mBufferUsed = false;
00071                 else
00072                         BaseAllocator::deallocate(ptr);
00073         }
00074
00075         PX_FORCE_INLINE uint8_t* getInlineBuffer()
00076         {
00077                 return mBuffer;
00078         }
00079         PX_FORCE_INLINE bool isBufferUsed() const
00080         {
00081                 return mBufferUsed;
00082         }
00083
00084   protected:
00085         uint8_t mBuffer[N];
00086         bool mBufferUsed;
00087 };
00088 } // namespace shdfnd
00089 } // namespace physx
00090
00091 #endif // #ifndef PSFOUNDATION_PSINLINEALLOCATOR_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSINLINEARRAY_H
00031 #define PSFOUNDATION_PSINLINEARRAY_H
00032
00033 #include "PsArray.h"
00034 #include "PsInlineAllocator.h"
00035
00036 namespace physx
00037 {
00038 namespace shdfnd
00039 {
00040
00041 // array that pre-allocates for N elements
00042 template <typename T, uint32_t N, typename Alloc = typename AllocatorTraits<T>::Type>
00043 class InlineArray : public Array<T, InlineAllocator<N * sizeof(T), Alloc> >
00044 {
00045         typedef InlineAllocator<N * sizeof(T), Alloc> Allocator;
00046
00047   public:
00048         InlineArray(const PxEMPTY v) : Array<T, Allocator>(v)
00049         {
00050                 if(isInlined())
00051                         this->mData = reinterpret_cast<T*>(Array<T, Allocator>::getInlineBuffer());
00052         }
00053
00054         PX_INLINE bool isInlined() const
00055         {
00056                 return Allocator::isBufferUsed();
00057         }
00058
00059         PX_INLINE explicit InlineArray(const Alloc& alloc = Alloc()) : Array<T, Allocator>(alloc)
00060         {
00061                 this->mData = this->allocate(N);
00062                 this->mCapacity = N;
00063         }
00064 };
00065 } // namespace shdfnd
00066 } // namespace physx
00067
00068 #endif // #ifndef PSFOUNDATION_PSINLINEARRAY_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSINTRINSICS_H
00031 #define PSFOUNDATION_PSINTRINSICS_H
00032
00033 #include "foundation/PxPreprocessor.h"
00034
00035 #if(PX_WINDOWS_FAMILY || PX_WINRT)
00036 #include "windows/PsWindowsIntrinsics.h"
00037 #elif(PX_LINUX || PX_ANDROID || PX_APPLE_FAMILY || PX_PS4)
00038 #include "unix/PsUnixIntrinsics.h"
00039 #elif PX_XBOXONE
00040 #include "XboxOne/PsXboxOneIntrinsics.h"
00041 #else
00042 #error "Platform not supported!"
00043 #endif
00044
00045 #endif // #ifndef PSFOUNDATION_PSINTRINSICS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSMUTEX_H
00031 #define PSFOUNDATION_PSMUTEX_H
00032
00033 #include "PsAllocator.h"
00034
00035 /*
00036  * This <new> inclusion is a best known fix for gcc 4.4.1 error:
00037  * Creating object file for apex/src/PsAllocator.cpp ...
00038  * In file included from apex/include/PsFoundation.h:30,
00039  *                from apex/src/PsAllocator.cpp:26:
00040  * apex/include/PsMutex.h: In constructor  'physx::shdfnd::MutexT<Alloc>::MutexT(const Alloc&)':
00041  * apex/include/PsMutex.h:92: error: no matching function for call to 'operator new(unsigned int,
00042  * physx::shdfnd::MutexImpl*&)'
00043  * <built-in>:0: note: candidates are: void* operator new(unsigned int)
00044  */
00045 #include <new>
00046
00047 namespace physx
00048 {
00049 namespace shdfnd
00050 {
00051 class PX_FOUNDATION_API MutexImpl
00052 {
00053   public:
00057         MutexImpl();
00058
00062         ~MutexImpl();
00063
00069         void lock();
00070
00075         bool trylock();
00076
00080         void unlock();
00081
00085         static const uint32_t& getSize();
00086 };
00087
00088 template <typename Alloc = ReflectionAllocator<MutexImpl> >
00089 class MutexT : protected Alloc
00090 {
00091         PX_NOCOPY(MutexT)
00092   public:
00093         class ScopedLock
00094         {
00095                 MutexT<Alloc>& mMutex;
00096                 PX_NOCOPY(ScopedLock)
00097           public:
00098                 PX_INLINE ScopedLock(MutexT<Alloc>& mutex) : mMutex(mutex)
00099                 {
00100                         mMutex.lock();
00101                 }
00102                 PX_INLINE ~ScopedLock()
00103                 {
00104                         mMutex.unlock();
00105                 }
00106         };
00107
00111         MutexT(const Alloc& alloc = Alloc()) : Alloc(alloc)
00112         {
00113                 mImpl = reinterpret_cast<MutexImpl*>(Alloc::allocate(MutexImpl::getSize(), __FILE__, __LINE__));
00114                 PX_PLACEMENT_NEW(mImpl, MutexImpl)();
00115         }
00116
00120         ~MutexT()
00121         {
00122                 mImpl->~MutexImpl();
00123                 Alloc::deallocate(mImpl);
00124         }
00125
00131         void lock() const
00132         {
00133                 mImpl->lock();
00134         }
00135
00141         bool trylock() const
00142         {
00143                 return mImpl->trylock();
00144         }
00145
00150         void unlock() const
00151         {
00152                 mImpl->unlock();
00153         }
00154
00155   private:
00156         MutexImpl* mImpl;
00157 };
00158
00159 class PX_FOUNDATION_API ReadWriteLock
00160 {
00161         PX_NOCOPY(ReadWriteLock)
00162   public:
00163         ReadWriteLock();
00164         ~ReadWriteLock();
00165
00166         void lockReader();
00167         void lockWriter();
00168
00169         void unlockReader();
00170         void unlockWriter();
00171
00172   private:
00173         class ReadWriteLockImpl* mImpl;
00174 };
00175
00176 class ScopedReadLock
00177 {
00178         PX_NOCOPY(ScopedReadLock)
00179   public:
00180         PX_INLINE ScopedReadLock(ReadWriteLock& lock) : mLock(lock)
00181         {
00182                 mLock.lockReader();
00183         }
00184         PX_INLINE ~ScopedReadLock()
00185         {
00186                 mLock.unlockReader();
00187         }
00188
00189   private:
00190         ReadWriteLock& mLock;
00191 };
00192
00193 class ScopedWriteLock
00194 {
00195         PX_NOCOPY(ScopedWriteLock)
00196   public:
00197         PX_INLINE ScopedWriteLock(ReadWriteLock& lock) : mLock(lock)
00198         {
00199                 mLock.lockWriter();
00200         }
00201         PX_INLINE ~ScopedWriteLock()
00202         {
00203                 mLock.unlockWriter();
00204         }
00205
00206   private:
00207         ReadWriteLock& mLock;
00208 };
00209
00210 typedef MutexT<> Mutex;
00211
00212 /*
00213  * Use this type of lock for mutex behaviour that must operate on SPU and PPU
00214  * On non-PS3 platforms, it is implemented using Mutex
00215  */
00216 class AtomicLock
00217 {
00218         Mutex mMutex;
00219         PX_NOCOPY(AtomicLock)
00220
00221   public:
00222         AtomicLock()
00223         {
00224         }
00225
00226         bool lock()
00227         {
00228                 mMutex.lock();
00229                 return true;
00230         }
00231
00232         bool trylock()
00233         {
00234                 return mMutex.trylock();
00235         }
00236
00237         bool unlock()
00238         {
00239                 mMutex.unlock();
00240                 return true;
00241         }
00242 };
00243
00244 class AtomicLockCopy
00245 {
00246         AtomicLock* pLock;
00247
00248   public:
00249         AtomicLockCopy() : pLock(NULL)
00250         {
00251         }
00252
00253         AtomicLockCopy& operator=(AtomicLock& lock)
00254         {
00255                 pLock = &lock;
00256                 return *this;
00257         }
00258
00259         bool lock()
00260         {
00261                 return pLock->lock();
00262         }
00263
00264         bool trylock()
00265         {
00266                 return pLock->trylock();
00267         }
00268
00269         bool unlock()
00270         {
00271                 return pLock->unlock();
00272         }
00273 };
00274
00275 class AtomicRwLock
00276 {
00277         ReadWriteLock m_Lock;
00278         PX_NOCOPY(AtomicRwLock)
00279
00280   public:
00281         AtomicRwLock()
00282         {
00283         }
00284
00285         void lockReader()
00286         {
00287                 m_Lock.lockReader();
00288         }
00289         void lockWriter()
00290         {
00291                 m_Lock.lockWriter();
00292         }
00293
00294         bool tryLockReader()
00295         {
00296                 // Todo - implement this
00297                 m_Lock.lockReader();
00298                 return true;
00299         }
00300
00301         void unlockReader()
00302         {
00303                 m_Lock.unlockReader();
00304         }
00305         void unlockWriter()
00306         {
00307                 m_Lock.unlockWriter();
00308         }
00309 };
00310
00311 class ScopedAtomicLock
00312 {
00313         PX_INLINE ScopedAtomicLock(AtomicLock& lock) : mLock(lock)
00314         {
00315                 mLock.lock();
00316         }
00317         PX_INLINE ~ScopedAtomicLock()
00318         {
00319                 mLock.unlock();
00320         }
00321
00322         PX_NOCOPY(ScopedAtomicLock)
00323   private:
00324         AtomicLock& mLock;
00325 };
00326
00327 } // namespace shdfnd
00328 } // namespace physx
00329
00330 #endif // #ifndef PSFOUNDATION_PSMUTEX_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSPOOL_H
00031 #define PSFOUNDATION_PSPOOL_H
00032
00033 #include "PsArray.h"
00034 #include "PsSort.h"
00035 #include "PsBasicTemplates.h"
00036 #include "PsBasicTemplates.h"
00037 #include "PsInlineArray.h"
00038
00039 namespace physx
00040 {
00041 namespace shdfnd
00042 {
00043
00047 template <class T, class Alloc = typename AllocatorTraits<T>::Type>
00048 class PoolBase : public UserAllocated, public Alloc
00049 {
00050         PX_NOCOPY(PoolBase)
00051   protected:
00052         PoolBase(const Alloc& alloc, uint32_t elementsPerSlab, uint32_t slabSize)
00053         : Alloc(alloc)
00054         , mSlabs(alloc)
00055         , mElementsPerSlab(elementsPerSlab)
00056         , mUsed(0)
00057         , mSlabSize(slabSize)
00058         , mFreeElement(0)
00059         {
00060                 PX_COMPILE_TIME_ASSERT(sizeof(T) >= sizeof(size_t));
00061         }
00062
00063   public:
00064         ~PoolBase()
00065         {
00066                 if(mUsed)
00067                         disposeElements();
00068
00069                 for(void** slabIt = mSlabs.begin(), *slabEnd = mSlabs.end(); slabIt != slabEnd; ++slabIt)
00070                         Alloc::deallocate(*slabIt);
00071         }
00072
00073         // Allocate space for single object
00074         PX_INLINE T* allocate()
00075         {
00076                 if(mFreeElement == 0)
00077                         allocateSlab();
00078                 T* p = reinterpret_cast<T*>(mFreeElement);
00079                 mFreeElement = mFreeElement->mNext;
00080                 mUsed++;
00085 #if PX_CHECKED
00086                 for(uint32_t i = 0; i < sizeof(T); ++i)
00087                         reinterpret_cast<uint8_t*>(p)[i] = 0xcd;
00088 #endif
00089                 return p;
00090         }
00091
00092         // Put space for a single element back in the lists
00093         PX_INLINE void deallocate(T* p)
00094         {
00095                 if(p)
00096                 {
00097                         PX_ASSERT(mUsed);
00098                         mUsed--;
00099                         push(reinterpret_cast<FreeList*>(p));
00100                 }
00101         }
00102
00103         PX_INLINE T* construct()
00104         {
00105                 T* t = allocate();
00106                 return t ? new (t) T() : 0;
00107         }
00108
00109         template <class A1>
00110         PX_INLINE T* construct(A1& a)
00111         {
00112                 T* t = allocate();
00113                 return t ? new (t) T(a) : 0;
00114         }
00115
00116         template <class A1, class A2>
00117         PX_INLINE T* construct(A1& a, A2& b)
00118         {
00119                 T* t = allocate();
00120                 return t ? new (t) T(a, b) : 0;
00121         }
00122
00123         template <class A1, class A2, class A3>
00124         PX_INLINE T* construct(A1& a, A2& b, A3& c)
00125         {
00126                 T* t = allocate();
00127                 return t ? new (t) T(a, b, c) : 0;
00128         }
00129
00130         template <class A1, class A2, class A3>
00131         PX_INLINE T* construct(A1* a, A2& b, A3& c)
00132         {
00133                 T* t = allocate();
00134                 return t ? new (t) T(a, b, c) : 0;
00135         }
00136
00137         template <class A1, class A2, class A3, class A4>
00138         PX_INLINE T* construct(A1& a, A2& b, A3& c, A4& d)
00139         {
00140                 T* t = allocate();
00141                 return t ? new (t) T(a, b, c, d) : 0;
00142         }
00143
00144         template <class A1, class A2, class A3, class A4, class A5>
00145         PX_INLINE T* construct(A1& a, A2& b, A3& c, A4& d, A5& e)
00146         {
00147                 T* t = allocate();
00148                 return t ? new (t) T(a, b, c, d, e) : 0;
00149         }
00150
00151         PX_INLINE void destroy(T* const p)
00152         {
00153                 if(p)
00154                 {
00155                         p->~T();
00156                         deallocate(p);
00157                 }
00158         }
00159
00160   protected:
00161         struct FreeList
00162         {
00163                 FreeList* mNext;
00164         };
00165
00166         // All the allocated slabs, sorted by pointer
00167         InlineArray<void*, 64, Alloc> mSlabs;
00168
00169         uint32_t mElementsPerSlab;
00170         uint32_t mUsed;
00171         uint32_t mSlabSize;
00172
00173         FreeList* mFreeElement; // Head of free-list
00174
00175         // Helper function to get bitmap of allocated elements
00176
00177         void push(FreeList* p)
00178         {
00179                 p->mNext = mFreeElement;
00180                 mFreeElement = p;
00181         }
00182
00183         // Allocate a slab and segregate it into the freelist
00184         void allocateSlab()
00185         {
00186                 T* slab = reinterpret_cast<T*>(Alloc::allocate(mSlabSize, __FILE__, __LINE__));
00187
00188                 mSlabs.pushBack(slab);
00189
00190                 // Build a chain of nodes for the freelist
00191                 T* it = slab + mElementsPerSlab;
00192                 while(--it >= slab)
00193                         push(reinterpret_cast<FreeList*>(it));
00194         }
00195
00196         /*
00197         Cleanup method. Go through all active slabs and call destructor for live objects,
00198         then free their memory
00199         */
00200         void disposeElements()
00201         {
00202                 Array<void*, Alloc> freeNodes(*this);
00203                 while(mFreeElement)
00204                 {
00205                         freeNodes.pushBack(mFreeElement);
00206                         mFreeElement = mFreeElement->mNext;
00207                 }
00208                 Alloc& alloc(*this);
00209                 sort(freeNodes.begin(), freeNodes.size(), Less<void*>(), alloc);
00210                 sort(mSlabs.begin(), mSlabs.size(), Less<void*>(), alloc);
00211
00212                 typename Array<void*, Alloc>::Iterator slabIt = mSlabs.begin(), slabEnd = mSlabs.end();
00213                 for(typename Array<void*, Alloc>::Iterator freeIt = freeNodes.begin(); slabIt != slabEnd; ++slabIt)
00214                 {
00215                         for(T* tIt = reinterpret_cast<T*>(*slabIt), *tEnd = tIt + mElementsPerSlab; tIt != tEnd; ++tIt)
00216                         {
00217                                 if(freeIt != freeNodes.end() && *freeIt == tIt)
00218                                         ++freeIt;
00219                                 else
00220                                         tIt->~T();
00221                         }
00222                 }
00223         }
00224
00225         /*
00226         Go through all slabs and call destructor if the slab is empty
00227         */
00228         void releaseEmptySlabs()
00229         {
00230                 Array<void*, Alloc> freeNodes(*this);
00231                 Array<void*, Alloc> slabNodes(mSlabs, *this);
00232                 while(mFreeElement)
00233                 {
00234                         freeNodes.pushBack(mFreeElement);
00235                         mFreeElement = mFreeElement->mNext;
00236                 }
00237
00238                 typename Array<void*, Alloc>::Iterator freeIt = freeNodes.begin(), freeEnd = freeNodes.end(),
00239                                                        lastCheck = freeNodes.end() - mElementsPerSlab;
00240
00241                 if(freeNodes.size() > mElementsPerSlab)
00242                 {
00243                         Alloc& alloc(*this);
00244                         sort(freeNodes.begin(), freeNodes.size(), Less<void*>(), alloc);
00245                         sort(slabNodes.begin(), slabNodes.size(), Less<void*>(), alloc);
00246
00247                         mSlabs.clear();
00248                         for(void** slabIt = slabNodes.begin(), *slabEnd = slabNodes.end(); slabIt != slabEnd; ++slabIt)
00249                         {
00250                                 while((freeIt < lastCheck) && (*slabIt > (*freeIt)))
00251                                 {
00252                                         push(reinterpret_cast<FreeList*>(*freeIt));
00253                                         freeIt++;
00254                                 }
00255
00256                                 if(*slabIt == (*freeIt)) // the slab's first element in freeList
00257                                 {
00258                                         const size_t endSlabAddress = size_t(*slabIt) + mSlabSize;
00259                                         const size_t endFreeAddress = size_t(*(freeIt + mElementsPerSlab - 1));
00260                                         if(endFreeAddress + sizeof(T) == endSlabAddress)
00261                                         { // all slab's element in freeList
00262                                                 Alloc::deallocate(*slabIt);
00263                                                 freeIt += mElementsPerSlab;
00264                                                 continue;
00265                                         }
00266                                 }
00267
00268                                 mSlabs.pushBack(*slabIt);
00269                         }
00270                 }
00271
00272                 while(freeIt != freeEnd)
00273                 {
00274                         push(reinterpret_cast<FreeList*>(*freeIt));
00275                         ++freeIt;
00276                 }
00277         }
00278 };
00279
00280 // original pool implementation
00281 template <class T, class Alloc = typename AllocatorTraits<T>::Type>
00282 class Pool : public PoolBase<T, Alloc>
00283 {
00284   public:
00285         Pool(const Alloc& alloc = Alloc(), uint32_t elementsPerSlab = 32)
00286         : PoolBase<T, Alloc>(alloc, elementsPerSlab, elementsPerSlab * sizeof(T))
00287         {
00288         }
00289 };
00290
00291 // allows specification of the slab size instead of the occupancy
00292 template <class T, uint32_t slabSize, class Alloc = typename AllocatorTraits<T>::Type>
00293 class Pool2 : public PoolBase<T, Alloc>
00294 {
00295   public:
00296         Pool2(const Alloc& alloc = Alloc()) : PoolBase<T, Alloc>(alloc, slabSize / sizeof(T), slabSize)
00297         {
00298         }
00299 };
00300
00301 } // namespace shdfnd
00302 } // namespace physx
00303
00304 #endif // #ifndef PSFOUNDATION_PSPOOL_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSSLIST_H
00031 #define PSFOUNDATION_PSSLIST_H
00032
00033 #include "foundation/Px.h"
00034 #include "foundation/PxAssert.h"
00035 #include "PsAlignedMalloc.h"
00036
00037 #if PX_P64_FAMILY
00038 #define PX_SLIST_ALIGNMENT 16
00039 #else
00040 #define PX_SLIST_ALIGNMENT 8
00041 #endif
00042
00043 namespace physx
00044 {
00045 namespace shdfnd
00046 {
00047
00048 #if PX_VC
00049 #pragma warning(push)
00050 #pragma warning(disable : 4324) // Padding was added at the end of a structure because of a __declspec(align) value.
00051 #endif
00052
00053 #if !PX_GCC_FAMILY
00054 __declspec(align(PX_SLIST_ALIGNMENT))
00055 #endif
00056     class SListEntry
00057 {
00058         friend struct SListImpl;
00059
00060   public:
00061         SListEntry() : mNext(NULL)
00062         {
00063                 PX_ASSERT((size_t(this) & (PX_SLIST_ALIGNMENT - 1)) == 0);
00064         }
00065
00066         // Only use on elements returned by SList::flush()
00067         // because the operation is not atomic.
00068         SListEntry* next()
00069         {
00070                 return mNext;
00071         }
00072
00073   private:
00074         SListEntry* mNext;
00075 }
00076 #if PX_GCC_FAMILY
00077 __attribute__((aligned(PX_SLIST_ALIGNMENT)));
00078 #else
00079 ;
00080 #endif
00081
00082 #if PX_VC
00083 #pragma warning(pop)
00084 #endif
00085
00086 // template-less implementation
00087 struct PX_FOUNDATION_API SListImpl
00088 {
00089         SListImpl();
00090         ~SListImpl();
00091         void push(SListEntry* entry);
00092         SListEntry* pop();
00093         SListEntry* flush();
00094         static const uint32_t& getSize();
00095 };
00096
00097 template <typename Alloc = ReflectionAllocator<SListImpl> >
00098 class SListT : protected Alloc
00099 {
00100   public:
00101         SListT(const Alloc& alloc = Alloc()) : Alloc(alloc)
00102         {
00103                 mImpl = reinterpret_cast<SListImpl*>(Alloc::allocate(SListImpl::getSize(), __FILE__, __LINE__));
00104                 PX_ASSERT((size_t(mImpl) & (PX_SLIST_ALIGNMENT - 1)) == 0);
00105                 PX_PLACEMENT_NEW(mImpl, SListImpl)();
00106         }
00107         ~SListT()
00108         {
00109                 mImpl->~SListImpl();
00110                 Alloc::deallocate(mImpl);
00111         }
00112
00113         // pushes a new element to the list
00114         void push(SListEntry& entry)
00115         {
00116                 mImpl->push(&entry);
00117         }
00118
00119         // pops an element from the list
00120         SListEntry* pop()
00121         {
00122                 return mImpl->pop();
00123         }
00124
00125         // removes all items from list, returns pointer to first element
00126         SListEntry* flush()
00127         {
00128                 return mImpl->flush();
00129         }
00130
00131   private:
00132         SListImpl* mImpl;
00133 };
00134
00135 typedef SListT<> SList;
00136
00137 } // namespace shdfnd
00138 } // namespace physx
00139
00140 #endif // #ifndef PSFOUNDATION_PSSLIST_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSSOCKET_H
00031 #define PSFOUNDATION_PSSOCKET_H
00032
00033 #include "PsUserAllocated.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00043 class PX_FOUNDATION_API Socket : public UserAllocated
00044 {
00045   public:
00046         static const uint32_t DEFAULT_BUFFER_SIZE;
00047
00048         Socket(bool inEnableBuffering = true, bool blocking = true);
00049
00050         virtual ~Socket();
00051
00067         bool connect(const char* host, uint16_t port, uint32_t timeout = 1000);
00068
00078         bool listen(uint16_t port);
00079
00095         bool accept(bool block);
00096
00100         void disconnect();
00101
00108         bool isConnected() const;
00109
00117         const char* getHost() const;
00118
00126         uint16_t getPort() const;
00127
00139         bool flush();
00140
00154         uint32_t write(const uint8_t* data, uint32_t length);
00155
00169         uint32_t read(uint8_t* data, uint32_t length);
00170
00175         void setBlocking(bool blocking);
00176
00183         bool isBlocking() const;
00184
00185   private:
00186         class SocketImpl* mImpl;
00187 };
00188
00189 } // namespace shdfnd
00190 } // namespace physx
00191
00192 #endif // PSFOUNDATION_PSSOCKET_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSSORT_H
00031 #define PSFOUNDATION_PSSORT_H
00032
00037 #include "PsSortInternals.h"
00038 #include "PsAlloca.h"
00039
00040 #define PX_SORT_PARANOIA PX_DEBUG
00041
00049 #if PX_VC
00050 #pragma warning(push)
00051 #pragma warning(disable : 4706) // disable the warning that we did an assignment within a conditional expression, as
00052 // this was intentional.
00053 #endif
00054
00055 namespace physx
00056 {
00057 namespace shdfnd
00058 {
00059 template <class T, class Predicate, class Allocator>
00060 void sort(T* elements, uint32_t count, const Predicate& compare, const Allocator& inAllocator,
00061           const uint32_t initialStackSize = 32)
00062 {
00063         static const uint32_t SMALL_SORT_CUTOFF = 5; // must be >= 3 since we need 3 for median
00064
00065         PX_ALLOCA(stackMem, int32_t, initialStackSize);
00066         internal::Stack<Allocator> stack(stackMem, initialStackSize, inAllocator);
00067
00068         int32_t first = 0, last = int32_t(count - 1);
00069         if(last > first)
00070         {
00071                 for(;;)
00072                 {
00073                         while(last > first)
00074                         {
00075                                 PX_ASSERT(first >= 0 && last < int32_t(count));
00076                                 if(uint32_t(last - first) < SMALL_SORT_CUTOFF)
00077                                 {
00078                                         internal::smallSort(elements, first, last, compare);
00079                                         break;
00080                                 }
00081                                 else
00082                                 {
00083                                         const int32_t partIndex = internal::partition(elements, first, last, compare);
00084
00085                                         // push smaller sublist to minimize stack usage
00086                                         if((partIndex - first) < (last - partIndex))
00087                                         {
00088                                                 stack.push(first, partIndex - 1);
00089                                                 first = partIndex + 1;
00090                                         }
00091                                         else
00092                                         {
00093                                                 stack.push(partIndex + 1, last);
00094                                                 last = partIndex - 1;
00095                                         }
00096                                 }
00097                         }
00098
00099                         if(stack.empty())
00100                                 break;
00101
00102                         stack.pop(first, last);
00103                 }
00104         }
00105 #if PX_SORT_PARANOIA
00106         for(uint32_t i = 1; i < count; i++)
00107                 PX_ASSERT(!compare(elements[i], elements[i - 1]));
00108 #endif
00109 }
00110
00111 template <class T, class Predicate>
00112 void sort(T* elements, uint32_t count, const Predicate& compare)
00113 {
00114         sort(elements, count, compare, typename shdfnd::AllocatorTraits<T>::Type());
00115 }
00116
00117 template <class T>
00118 void sort(T* elements, uint32_t count)
00119 {
00120         sort(elements, count, shdfnd::Less<T>(), typename shdfnd::AllocatorTraits<T>::Type());
00121 }
00122
00123 } // namespace shdfnd
00124 } // namespace physx
00125
00126 #if PX_VC
00127 #pragma warning(pop)
00128 #endif
00129
00130 #endif // #ifndef PSFOUNDATION_PSSORT_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSSORTINTERNALS_H
00031 #define PSFOUNDATION_PSSORTINTERNALS_H
00032
00037 #include "foundation/PxAssert.h"
00038 #include "foundation/PxIntrinsics.h"
00039 #include "PsBasicTemplates.h"
00040 #include "PsUserAllocated.h"
00041
00042 namespace physx
00043 {
00044 namespace shdfnd
00045 {
00046 namespace internal
00047 {
00048 template <class T, class Predicate>
00049 PX_INLINE void median3(T* elements, int32_t first, int32_t last, Predicate& compare)
00050 {
00051         /*
00052         This creates sentinels because we know there is an element at the start minimum(or equal)
00053         than the pivot and an element at the end greater(or equal) than the pivot. Plus the
00054         median of 3 reduces the chance of degenerate behavour.
00055         */
00056
00057         int32_t mid = (first + last) / 2;
00058
00059         if(compare(elements[mid], elements[first]))
00060                 swap(elements[first], elements[mid]);
00061
00062         if(compare(elements[last], elements[first]))
00063                 swap(elements[first], elements[last]);
00064
00065         if(compare(elements[last], elements[mid]))
00066                 swap(elements[mid], elements[last]);
00067
00068         // keep the pivot at last-1
00069         swap(elements[mid], elements[last - 1]);
00070 }
00071
00072 template <class T, class Predicate>
00073 PX_INLINE int32_t partition(T* elements, int32_t first, int32_t last, Predicate& compare)
00074 {
00075         median3(elements, first, last, compare);
00076
00077         /*
00078         WARNING: using the line:
00079
00080         T partValue = elements[last-1];
00081
00082         and changing the scan loops to:
00083
00084         while(comparator.greater(partValue, elements[++i]));
00085         while(comparator.greater(elements[--j], partValue);
00086
00087         triggers a compiler optimizer bug on xenon where it stores a double to the stack for partValue
00088         then loads it as a single...:-(
00089         */
00090
00091         int32_t i = first;    // we know first is less than pivot(but i gets pre incremented)
00092         int32_t j = last - 1; // pivot is in last-1 (but j gets pre decremented)
00093
00094         for(;;)
00095         {
00096                 while(compare(elements[++i], elements[last - 1]))
00097                         ;
00098                 while(compare(elements[last - 1], elements[--j]))
00099                         ;
00100
00101                 if(i >= j)
00102                         break;
00103
00104                 PX_ASSERT(i <= last && j >= first);
00105                 swap(elements[i], elements[j]);
00106         }
00107         // put the pivot in place
00108
00109         PX_ASSERT(i <= last && first <= (last - 1));
00110         swap(elements[i], elements[last - 1]);
00111
00112         return i;
00113 }
00114
00115 template <class T, class Predicate>
00116 PX_INLINE void smallSort(T* elements, int32_t first, int32_t last, Predicate& compare)
00117 {
00118         // selection sort - could reduce to fsel on 360 with floats.
00119
00120         for(int32_t i = first; i < last; i++)
00121         {
00122                 int32_t m = i;
00123                 for(int32_t j = i + 1; j <= last; j++)
00124                         if(compare(elements[j], elements[m]))
00125                                 m = j;
00126
00127                 if(m != i)
00128                         swap(elements[m], elements[i]);
00129         }
00130 }
00131
00132 template <class Allocator>
00133 class Stack
00134 {
00135         Allocator mAllocator;
00136         uint32_t mSize, mCapacity;
00137         int32_t* mMemory;
00138         bool mRealloc;
00139
00140   public:
00141         Stack(int32_t* memory, uint32_t capacity, const Allocator& inAllocator)
00142         : mAllocator(inAllocator), mSize(0), mCapacity(capacity), mMemory(memory), mRealloc(false)
00143         {
00144         }
00145         ~Stack()
00146         {
00147                 if(mRealloc)
00148                         mAllocator.deallocate(mMemory);
00149         }
00150
00151         void grow()
00152         {
00153                 mCapacity *= 2;
00154                 int32_t* newMem = reinterpret_cast<int32_t*>(mAllocator.allocate(sizeof(int32_t) * mCapacity, __FILE__, __LINE__));
00155                 intrinsics::memCopy(newMem, mMemory, mSize * sizeof(int32_t));
00156                 if(mRealloc)
00157                         mAllocator.deallocate(mMemory);
00158                 mRealloc = true;
00159                 mMemory = newMem;
00160         }
00161
00162         PX_INLINE void push(int32_t start, int32_t end)
00163         {
00164                 if(mSize >= mCapacity - 1)
00165                         grow();
00166                 mMemory[mSize++] = start;
00167                 mMemory[mSize++] = end;
00168         }
00169
00170         PX_INLINE void pop(int32_t& start, int32_t& end)
00171         {
00172                 PX_ASSERT(!empty());
00173                 end = mMemory[--mSize];
00174                 start = mMemory[--mSize];
00175         }
00176
00177         PX_INLINE bool empty()
00178         {
00179                 return mSize == 0;
00180         }
00181 };
00182 } // namespace internal
00183
00184 } // namespace shdfnd
00185 } // namespace physx
00186
00187 #endif // #ifndef PSFOUNDATION_PSSORTINTERNALS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSSTRING_H
00031 #define PSFOUNDATION_PSSTRING_H
00032
00033 #include "foundation/PxPreprocessor.h"
00034 #include "foundation/PxSimpleTypes.h"
00035 #include <stdarg.h>
00036
00037 namespace physx
00038 {
00039 namespace shdfnd
00040 {
00041
00042 // the following functions have C99 semantics. Note that C99 requires for snprintf and vsnprintf:
00043 // * the resulting string is always NULL-terminated regardless of truncation.
00044 // * in the case of truncation the return value is the number of characters that would have been created.
00045
00046 PX_FOUNDATION_API int32_t sscanf(const char* buffer, const char* format, ...);
00047 PX_FOUNDATION_API int32_t strcmp(const char* str1, const char* str2);
00048 PX_FOUNDATION_API int32_t strncmp(const char* str1, const char* str2, size_t count);
00049 PX_FOUNDATION_API int32_t snprintf(char* dst, size_t dstSize, const char* format, ...);
00050 PX_FOUNDATION_API int32_t vsnprintf(char* dst, size_t dstSize, const char* src, va_list arg);
00051
00052 // strlcat and strlcpy have BSD semantics:
00053 // * dstSize is always the size of the destination buffer
00054 // * the resulting string is always NULL-terminated regardless of truncation
00055 // * in the case of truncation the return value is the length of the string that would have been created
00056
00057 PX_FOUNDATION_API size_t strlcat(char* dst, size_t dstSize, const char* src);
00058 PX_FOUNDATION_API size_t strlcpy(char* dst, size_t dstSize, const char* src);
00059
00060 // case-insensitive string comparison
00061 PX_FOUNDATION_API int32_t stricmp(const char* str1, const char* str2);
00062 PX_FOUNDATION_API int32_t strnicmp(const char* str1, const char* str2, size_t count);
00063
00064 // in-place string case conversion
00065 PX_FOUNDATION_API void strlwr(char* str);
00066 PX_FOUNDATION_API void strupr(char* str);
00067
00074 static const size_t MAX_PRINTFORMATTED_LENGTH = 1024;
00075
00081 PX_FOUNDATION_API void printFormatted(const char*, ...);
00082
00087 PX_FOUNDATION_API void printString(const char*);
00088 }
00089 }
00090 #endif // #ifndef PSFOUNDATION_PSSTRING_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSSYNC_H
00031 #define PSFOUNDATION_PSSYNC_H
00032
00033 #include "PsAllocator.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00048 class PX_FOUNDATION_API SyncImpl
00049 {
00050   public:
00051         static const uint32_t waitForever = 0xffffffff;
00052
00053         SyncImpl();
00054
00055         ~SyncImpl();
00056
00062         bool wait(uint32_t milliseconds = waitForever);
00063
00066         void set();
00067
00070         void reset();
00071
00075         static const uint32_t& getSize();
00076 };
00077
00087 template <typename Alloc = ReflectionAllocator<SyncImpl> >
00088 class SyncT : protected Alloc
00089 {
00090   public:
00091         static const uint32_t waitForever = SyncImpl::waitForever;
00092
00093         SyncT(const Alloc& alloc = Alloc()) : Alloc(alloc)
00094         {
00095                 mImpl = reinterpret_cast<SyncImpl*>(Alloc::allocate(SyncImpl::getSize(), __FILE__, __LINE__));
00096                 PX_PLACEMENT_NEW(mImpl, SyncImpl)();
00097         }
00098
00099         ~SyncT()
00100         {
00101                 mImpl->~SyncImpl();
00102                 Alloc::deallocate(mImpl);
00103         }
00104
00110         bool wait(uint32_t milliseconds = SyncImpl::waitForever)
00111         {
00112                 return mImpl->wait(milliseconds);
00113         }
00114
00117         void set()
00118         {
00119                 mImpl->set();
00120         }
00121
00124         void reset()
00125         {
00126                 mImpl->reset();
00127         }
00128
00129   private:
00130         class SyncImpl* mImpl;
00131 };
00132
00133 typedef SyncT<> Sync;
00134
00135 } // namespace shdfnd
00136 } // namespace physx
00137
00138 #endif // #ifndef PSFOUNDATION_PSSYNC_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSTEMPALLOCATOR_H
00031 #define PSFOUNDATION_PSTEMPALLOCATOR_H
00032
00033 #include "PsAllocator.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00039 union TempAllocatorChunk
00040 {
00041         TempAllocatorChunk() : mNext(0)
00042         {
00043         }
00044         TempAllocatorChunk* mNext; // while chunk is free
00045         uint32_t mIndex;           // while chunk is allocated
00046         uint8_t mPad[16];          // 16 byte aligned allocations
00047 };
00048
00049 class TempAllocator
00050 {
00051   public:
00052         PX_FORCE_INLINE TempAllocator(const char* = 0)
00053         {
00054         }
00055         PX_FOUNDATION_API void* allocate(size_t size, const char* file, int line);
00056         PX_FOUNDATION_API void deallocate(void* ptr);
00057 };
00058
00059 void initializeTempAllocatorGlobals();
00060 void terminateTempAllocatorGlobals();
00061
00062 } // namespace shdfnd
00063 } // namespace physx
00064
00065 #endif // #ifndef PSFOUNDATION_PSTEMPALLOCATOR_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSTHREAD_H
00031 #define PSFOUNDATION_PSTHREAD_H
00032
00033 #include "PsUserAllocated.h"
00034
00035 // dsequeira: according to existing comment here (David Black would be my guess)
00036 // "This is useful to reduce bus contention on tight spin locks. And it needs
00037 // to be a macro as the xenon compiler often ignores even __forceinline." What's not
00038 // clear is why a pause function needs inlining...? (TODO: check with XBox team)
00039
00040 // todo: these need to go somewhere else
00041
00042 #if PX_WINDOWS_FAMILY || PX_WINRT || PX_XBOXONE
00043 #define PxSpinLockPause() __asm pause
00044 #if PX_WINRT
00045 #define PX_TLS_MAX_SLOTS 64
00046 #endif
00047 #elif PX_LINUX || PX_ANDROID || PX_PS4 || PX_APPLE_FAMILY
00048 #define PxSpinLockPause() asm("nop")
00049 #else
00050 #error "Platform not supported!"
00051 #endif
00052
00053 namespace physx
00054 {
00055 namespace shdfnd
00056 {
00057 struct ThreadPriority // todo: put in some other header file
00058 {
00059         enum Enum
00060         {
00064                 eHIGH         = 0,
00065
00069                 eABOVE_NORMAL = 1,
00070
00074                 eNORMAL       = 2,
00075
00079                 eBELOW_NORMAL = 3,
00080
00084                 eLOW          = 4,
00085                 eFORCE_DWORD  = 0xffFFffFF
00086         };
00087 };
00088
00089 class Runnable
00090 {
00091   public:
00092         Runnable()
00093         {
00094         }
00095         virtual ~Runnable()
00096         {
00097         }
00098         virtual void execute(void)
00099         {
00100         }
00101 };
00102
00103 class PX_FOUNDATION_API ThreadImpl
00104 {
00105   public:
00106         typedef size_t Id; // space for a pointer or an integer
00107         typedef void* (*ExecuteFn)(void*);
00108
00109         static uint32_t getDefaultStackSize();
00110         static Id getId();
00111
00118         ThreadImpl();
00119
00124         ThreadImpl(ExecuteFn fn, void* arg);
00125
00131         ~ThreadImpl();
00132
00139         void start(uint32_t stackSize, Runnable* r);
00140
00147         void kill();
00148
00154         void signalQuit();
00155
00161         bool waitForQuit();
00162
00168         bool quitIsSignalled();
00169
00173         void quit();
00174
00192         uint32_t setAffinityMask(uint32_t mask);
00193
00194         static ThreadPriority::Enum getPriority(Id threadId);
00195
00197         void setPriority(ThreadPriority::Enum prio);
00198
00200         void setName(const char* name);
00201
00203         static void sleep(uint32_t ms);
00204
00206         static void yield();
00207
00209         static uint32_t getNbPhysicalCores();
00210
00214         static const uint32_t& getSize();
00215 };
00216
00220 template <typename Alloc = ReflectionAllocator<ThreadImpl> >
00221 class ThreadT : protected Alloc, public UserAllocated, public Runnable
00222 {
00223   public:
00224         typedef ThreadImpl::Id Id; // space for a pointer or an integer
00225
00230         ThreadT(const Alloc& alloc = Alloc()) : Alloc(alloc)
00231         {
00232                 mImpl = reinterpret_cast<ThreadImpl*>(Alloc::allocate(ThreadImpl::getSize(), __FILE__, __LINE__));
00233                 PX_PLACEMENT_NEW(mImpl, ThreadImpl)();
00234         }
00235
00239         ThreadT(ThreadImpl::ExecuteFn fn, void* arg, const Alloc& alloc = Alloc()) : Alloc(alloc)
00240         {
00241                 mImpl = reinterpret_cast<ThreadImpl*>(Alloc::allocate(ThreadImpl::getSize(), __FILE__, __LINE__));
00242                 PX_PLACEMENT_NEW(mImpl, ThreadImpl)(fn, arg);
00243         }
00244
00249         virtual ~ThreadT()
00250         {
00251                 mImpl->~ThreadImpl();
00252                 Alloc::deallocate(mImpl);
00253         }
00254
00259         void start(uint32_t stackSize = ThreadImpl::getDefaultStackSize())
00260         {
00261                 mImpl->start(stackSize, this);
00262         }
00263
00270         void kill()
00271         {
00272                 mImpl->kill();
00273         }
00274
00280         virtual void execute(void)
00281         {
00282         }
00283
00289         void signalQuit()
00290         {
00291                 mImpl->signalQuit();
00292         }
00293
00299         bool waitForQuit()
00300         {
00301                 return mImpl->waitForQuit();
00302         }
00303
00309         bool quitIsSignalled()
00310         {
00311                 return mImpl->quitIsSignalled();
00312         }
00313
00317         void quit()
00318         {
00319                 mImpl->quit();
00320         }
00321
00322         uint32_t setAffinityMask(uint32_t mask)
00323         {
00324                 return mImpl->setAffinityMask(mask);
00325         }
00326
00327         static ThreadPriority::Enum getPriority(ThreadImpl::Id threadId)
00328         {
00329                 return ThreadImpl::getPriority(threadId);
00330         }
00331
00333         void setPriority(ThreadPriority::Enum prio)
00334         {
00335                 mImpl->setPriority(prio);
00336         }
00337
00339         void setName(const char* name)
00340         {
00341                 mImpl->setName(name);
00342         }
00343
00345         static void sleep(uint32_t ms)
00346         {
00347                 ThreadImpl::sleep(ms);
00348         }
00349
00351         static void yield()
00352         {
00353                 ThreadImpl::yield();
00354         }
00355
00356         static uint32_t getDefaultStackSize()
00357         {
00358                 return ThreadImpl::getDefaultStackSize();
00359         }
00360
00361         static ThreadImpl::Id getId()
00362         {
00363                 return ThreadImpl::getId();
00364         }
00365
00366         static uint32_t getNbPhysicalCores()
00367         {
00368                 return ThreadImpl::getNbPhysicalCores();
00369         }
00370
00371   private:
00372         class ThreadImpl* mImpl;
00373 };
00374
00375 typedef ThreadT<> Thread;
00376
00377 PX_FOUNDATION_API uint32_t TlsAlloc();
00378 PX_FOUNDATION_API void TlsFree(uint32_t index);
00379 PX_FOUNDATION_API void* TlsGet(uint32_t index);
00380 PX_FOUNDATION_API uint32_t TlsSet(uint32_t index, void* value);
00381
00382 } // namespace shdfnd
00383 } // namespace physx
00384
00385 #endif // #ifndef PSFOUNDATION_PSTHREAD_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSTIME_H
00031 #define PSFOUNDATION_PSTIME_H
00032
00033 #include "Ps.h"
00034
00035 #if PX_LINUX || PX_ANDROID
00036 #include <time.h>
00037 #endif
00038
00039 namespace physx
00040 {
00041 namespace shdfnd
00042 {
00043
00044 struct CounterFrequencyToTensOfNanos
00045 {
00046         uint64_t mNumerator;
00047         uint64_t mDenominator;
00048         CounterFrequencyToTensOfNanos(uint64_t inNum, uint64_t inDenom) : mNumerator(inNum), mDenominator(inDenom)
00049         {
00050         }
00051
00052         // quite slow.
00053         uint64_t toTensOfNanos(uint64_t inCounter) const
00054         {
00055                 return (inCounter * mNumerator) / mDenominator;
00056         }
00057 };
00058
00059 class PX_FOUNDATION_API Time
00060 {
00061   public:
00062         typedef double Second;
00063         static const uint64_t sNumTensOfNanoSecondsInASecond = 100000000;
00064         // This is supposedly guaranteed to not change after system boot
00065         // regardless of processors, speedstep, etc.
00066         static const CounterFrequencyToTensOfNanos& getBootCounterFrequency();
00067
00068         static CounterFrequencyToTensOfNanos getCounterFrequency();
00069
00070         static uint64_t getCurrentCounterValue();
00071
00072         // SLOW!!
00073         // Thar be a 64 bit divide in thar!
00074         static uint64_t getCurrentTimeInTensOfNanoSeconds()
00075         {
00076                 uint64_t ticks = getCurrentCounterValue();
00077                 return getBootCounterFrequency().toTensOfNanos(ticks);
00078         }
00079
00080         Time();
00081         Second getElapsedSeconds();
00082         Second peekElapsedSeconds();
00083         Second getLastTime() const;
00084
00085   private:
00086 #if PX_LINUX || PX_ANDROID || PX_APPLE_FAMILY || PX_PS4
00087         Second mLastTime;
00088 #else
00089         int64_t mTickCount;
00090 #endif
00091 };
00092 } // namespace shdfnd
00093 } // namespace physx
00094
00095 #endif // #ifndef PSFOUNDATION_PSTIME_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSUSERALLOCATED_H
00031 #define PSFOUNDATION_PSUSERALLOCATED_H
00032
00033 #include "PsAllocator.h"
00034
00035 namespace physx
00036 {
00037 namespace shdfnd
00038 {
00043 class UserAllocated
00044 {
00045   public:
00046         // PX_SERIALIZATION
00047         PX_INLINE void* operator new(size_t, void* address)
00048         {
00049                 return address;
00050         }
00051         //~PX_SERIALIZATION
00052         // Matching operator delete to the above operator new.  Don't ask me
00053         // how this makes any sense - Nuernberger.
00054         PX_INLINE void operator delete(void*, void*)
00055         {
00056         }
00057
00058         template <typename Alloc>
00059         PX_INLINE void* operator new(size_t size, Alloc alloc, const char* fileName, int line)
00060         {
00061                 return alloc.allocate(size, fileName, line);
00062         }
00063         template <typename Alloc>
00064         PX_INLINE void* operator new [](size_t size, Alloc alloc, const char* fileName, int line)
00065         { return alloc.allocate(size, fileName, line); }
00066
00067         // placement delete
00068         template <typename Alloc>
00069         PX_INLINE void operator delete(void* ptr, Alloc alloc, const char* fileName, int line)
00070         {
00071                 PX_UNUSED(fileName);
00072                 PX_UNUSED(line);
00073                 alloc.deallocate(ptr);
00074         }
00075         template <typename Alloc>
00076         PX_INLINE void operator delete [](void* ptr, Alloc alloc, const char* fileName, int line)
00077         {
00078                 PX_UNUSED(fileName);
00079                 PX_UNUSED(line);
00080                 alloc.deallocate(ptr);
00081         } PX_INLINE void
00082         operator delete(void* ptr)
00083         {
00084                 NonTrackingAllocator().deallocate(ptr);
00085         }
00086         PX_INLINE void operator delete [](void* ptr)
00087         { NonTrackingAllocator().deallocate(ptr); }
00088 };
00089 } // namespace shdfnd
00090 } // namespace physx
00091
00092 #endif // #ifndef PSFOUNDATION_PSUSERALLOCATED_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSVERSIONNUMBER_H
00031 #define PSFOUNDATION_PSVERSIONNUMBER_H
00032
00033 /*
00034 VersionNumbers:  The combination of these
00035 numbers uniquely identifies the API, and should
00036 be incremented when the SDK API changes.  This may
00037 include changes to file formats.
00038
00039 This header is included in the main SDK header files
00040 so that the entire SDK and everything that builds on it
00041 is completely rebuilt when this file changes.  Thus,
00042 this file is not to include a frequently changing
00043 build number.  See BuildNumber.h for that.
00044
00045 Each of these three values should stay below 255 because
00046 sometimes they are stored in a byte.
00047 */
00052 #define PX_FOUNDATION_VERSION_MAJOR 3
00053 #define PX_FOUNDATION_VERSION_MINOR 4
00054 #define PX_FOUNDATION_VERSION_BUGFIX 0
00055
00060 #define PX_FOUNDATION_VERSION                                                                                          \
00061         ((PX_FOUNDATION_VERSION_MAJOR << 24) + (PX_FOUNDATION_VERSION_MINOR << 16) + (PX_FOUNDATION_VERSION_BUGFIX << 8) + 0)
00062
00063 #endif // PSFOUNDATION_PSVERSIONNUMBER_H
00064
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSWINDOWSFPU_H
00031 #define PSFOUNDATION_PSWINDOWSFPU_H
00032
00033 PX_INLINE physx::shdfnd::SIMDGuard::SIMDGuard()
00034 {
00035 #if !PX_ARM
00036         mControlWord = _mm_getcsr();
00037         // set default (disable exceptions: _MM_MASK_MASK) and FTZ (_MM_FLUSH_ZERO_ON), DAZ (_MM_DENORMALS_ZERO_ON: (1<<6))
00038         _mm_setcsr(_MM_MASK_MASK | _MM_FLUSH_ZERO_ON | (1 << 6));
00039 #endif
00040 }
00041
00042 PX_INLINE physx::shdfnd::SIMDGuard::~SIMDGuard()
00043 {
00044 #if !PX_ARM
00045         // restore control word and clear any exception flags
00046         // (setting exception state flags cause exceptions on the first following fp operation)
00047         _mm_setcsr(mControlWord & ~_MM_EXCEPT_MASK);
00048 #endif
00049 }
00050
00051 #endif // #ifndef PSFOUNDATION_PSWINDOWSFPU_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSWINDOWSINCLUDE_H
00031 #define PSFOUNDATION_PSWINDOWSINCLUDE_H
00032
00033 #include "Ps.h"
00034
00035 #ifndef _WIN32
00036 #error "This file should only be included by Windows builds!!"
00037 #endif
00038
00039 #ifdef _WINDOWS_ // windows already included
00040 #error "Only include windows.h through this file!!"
00041 #endif
00042
00043 // We only support >= Windows XP, and we need this for critical section and
00044 #if !PX_WINRT
00045 #define _WIN32_WINNT 0x0501
00046 #else
00047 #define _WIN32_WINNT 0x0602
00048 #endif
00049
00050 // turn off as much as we can for windows. All we really need is the thread functions(critical sections/Interlocked*
00051 // etc)
00052 #define NOGDICAPMASKS
00053 #define NOVIRTUALKEYCODES
00054 #define NOWINMESSAGES
00055 #define NOWINSTYLES
00056 #define NOSYSMETRICS
00057 #define NOMENUS
00058 #define NOICONS
00059 #define NOKEYSTATES
00060 #define NOSYSCOMMANDS
00061 #define NORASTEROPS
00062 #define NOSHOWWINDOW
00063 #define NOATOM
00064 #define NOCLIPBOARD
00065 #define NOCOLOR
00066 #define NOCTLMGR
00067 #define NODRAWTEXT
00068 #define NOGDI
00069 #define NOMB
00070 #define NOMEMMGR
00071 #define NOMETAFILE
00072 #define NOMINMAX
00073 #define NOOPENFILE
00074 #define NOSCROLL
00075 #define NOSERVICE
00076 #define NOSOUND
00077 #define NOTEXTMETRIC
00078 #define NOWH
00079 #define NOWINOFFSETS
00080 #define NOCOMM
00081 #define NOKANJI
00082 #define NOHELP
00083 #define NOPROFILER
00084 #define NODEFERWINDOWPOS
00085 #define NOMCX
00086 #define WIN32_LEAN_AND_MEAN
00087 #if !PX_WINRT
00088 #define NOUSER
00089 #define NONLS
00090 #define NOMSG
00091 #endif
00092
00093 #pragma warning(push)
00094 #pragma warning(disable : 4668) //'symbol' is not defined as a preprocessor macro, replacing with '0' for 'directives'
00095 #include <windows.h>
00096 #pragma warning(pop)
00097
00098 #if PX_SSE2
00099 #include <xmmintrin.h>
00100 #endif
00101
00102 #endif // #ifndef PSFOUNDATION_PSWINDOWSINCLUDE_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


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

  • File List
  • File Members

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

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029
00030 #ifndef PSFOUNDATION_PSWINDOWSINTRINSICS_H
00031 #define PSFOUNDATION_PSWINDOWSINTRINSICS_H
00032
00033 #include "Ps.h"
00034 #include "foundation/PxAssert.h"
00035
00036 // this file is for internal intrinsics - that is, intrinsics that are used in
00037 // cross platform code but do not appear in the API
00038
00039 #if !(PX_WINDOWS_FAMILY || PX_WINRT)
00040 #error "This file should only be included by Windows or WIN8ARM builds!!"
00041 #endif
00042
00043 #pragma warning(push)
00044 //'symbol' is not defined as a preprocessor macro, replacing with '0' for 'directives'
00045 #pragma warning(disable : 4668)
00046 #if PX_VC == 10
00047 #pragma warning(disable : 4987) // nonstandard extension used: 'throw (...)'
00048 #endif
00049 #include <intrin.h>
00050 #pragma warning(pop)
00051
00052 #pragma warning(push)
00053 #pragma warning(disable : 4985) // 'symbol name': attributes not present on previous declaration
00054 #include <math.h>
00055 #pragma warning(pop)
00056
00057 #include <float.h>
00058 #include <mmintrin.h>
00059
00060 #pragma intrinsic(_BitScanForward)
00061 #pragma intrinsic(_BitScanReverse)
00062
00063 namespace physx
00064 {
00065 namespace shdfnd
00066 {
00067
00068 /*
00069 * Implements a memory barrier
00070 */
00071 PX_FORCE_INLINE void memoryBarrier()
00072 {
00073         _ReadWriteBarrier();
00074         /* long Barrier;
00075         __asm {
00076             xchg Barrier, eax
00077         }*/
00078 }
00079
00083 PX_FORCE_INLINE uint32_t highestSetBitUnsafe(uint32_t v)
00084 {
00085         unsigned long retval;
00086         _BitScanReverse(&retval, v);
00087         return retval;
00088 }
00089
00093 PX_FORCE_INLINE uint32_t lowestSetBitUnsafe(uint32_t v)
00094 {
00095         unsigned long retval;
00096         _BitScanForward(&retval, v);
00097         return retval;
00098 }
00099
00103 PX_FORCE_INLINE uint32_t countLeadingZeros(uint32_t v)
00104 {
00105         if(v)
00106         {
00107                 unsigned long bsr = (unsigned long)-1;
00108                 _BitScanReverse(&bsr, v);
00109                 return 31 - bsr;
00110         }
00111         else
00112                 return 32;
00113 }
00114
00118 #if !PX_ARM
00119 PX_FORCE_INLINE void prefetchLine(const void* ptr, uint32_t offset = 0)
00120 {
00121         // cache line on X86/X64 is 64-bytes so a 128-byte prefetch would require 2 prefetches.
00122         // However, we can only dispatch a limited number of prefetch instructions so we opt to prefetch just 1 cache line
00123         /*_mm_prefetch(((const char*)ptr + offset), _MM_HINT_T0);*/
00124         // We get slightly better performance prefetching to non-temporal addresses instead of all cache levels
00125         _mm_prefetch(((const char*)ptr + offset), _MM_HINT_NTA);
00126 }
00127 #else
00128 PX_FORCE_INLINE void prefetchLine(const void* ptr, uint32_t offset = 0)
00129 {
00130         // arm does have 32b cache line size
00131         __prefetch(((const char*)ptr + offset));
00132 }
00133 #endif
00134
00138 #if !PX_ARM
00139 PX_FORCE_INLINE void prefetch(const void* ptr, uint32_t count = 1)
00140 {
00141         const char* cp = (char*)ptr;
00142         uint64_t p = size_t(ptr);
00143         uint64_t startLine = p >> 6, endLine = (p + count - 1) >> 6;
00144         uint64_t lines = endLine - startLine + 1;
00145         do
00146         {
00147                 prefetchLine(cp);
00148                 cp += 64;
00149         } while(--lines);
00150 }
00151 #else
00152 PX_FORCE_INLINE void prefetch(const void* ptr, uint32_t count = 1)
00153 {
00154         const char* cp = (char*)ptr;
00155         uint32_t p = size_t(ptr);
00156         uint32_t startLine = p >> 5, endLine = (p + count - 1) >> 5;
00157         uint32_t lines = endLine - startLine + 1;
00158         do
00159         {
00160                 prefetchLine(cp);
00161                 cp += 32;
00162         } while(--lines);
00163 }
00164 #endif
00165
00167 PX_CUDA_CALLABLE PX_FORCE_INLINE float recipFast(float a)
00168 {
00169         return 1.0f / a;
00170 }
00171
00173 PX_CUDA_CALLABLE PX_FORCE_INLINE float recipSqrtFast(float a)
00174 {
00175         return 1.0f / ::sqrtf(a);
00176 }
00177
00179 PX_CUDA_CALLABLE PX_FORCE_INLINE float floatFloor(float x)
00180 {
00181         return ::floorf(x);
00182 }
00183
00184 #define NS_EXPECT_TRUE(x) x
00185 #define NS_EXPECT_FALSE(x) x
00186
00187 } // namespace shdfnd
00188 } // namespace physx
00189
00190 #endif // #ifndef PSFOUNDATION_PSWINDOWSINTRINSICS_H
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Alphabetical List

Class Index

A | B | C | E | F | G | H | I | L | M | N | P | R | S | T | U

A
EnableIfPod (physx::shdfnd)
I
PoolBase (physx::shdfnd) Socket (physx::shdfnd)
AlignedAllocator (physx::shdfnd) Equal (physx::shdfnd) InlineAllocator (physx::shdfnd) PoolBase::FreeList (physx::shdfnd) SocketImpl (physx::shdfnd)
Alloc
F
InlineArray (physx::shdfnd)
R
Stack (physx::shdfnd::internal)
Allocator FPUGuard (physx::shdfnd)
L
RawAllocator (physx::shdfnd) SyncImpl (physx::shdfnd)
AllocatorTraits (physx::shdfnd)
G
Less (physx::shdfnd) ReadWriteLock (physx::shdfnd) SyncT (physx::shdfnd)
Array (physx::shdfnd) Greater (physx::shdfnd) LogTwo (physx::shdfnd) ReadWriteLockImpl (physx::shdfnd)
T
AtomicLock (physx::shdfnd)
H
LogTwo< 1 > (physx::shdfnd) ReflectionAllocator (physx::shdfnd) TempAllocator (physx::shdfnd)
AtomicLockCopy (physx::shdfnd) Hash (physx::shdfnd)
M
Runnable (physx::shdfnd) TempAllocatorChunk (physx::shdfnd)
AtomicRwLock (physx::shdfnd) Hash< const char * > (physx::shdfnd) MutexImpl (physx::shdfnd)
S
ThreadImpl (physx::shdfnd)
B
HashBase (physx::shdfnd::internal) MutexT (physx::shdfnd) ScopedAtomicLock (physx::shdfnd) ThreadPriority (physx::shdfnd)
BufferedSocketImpl (physx::shdfnd) HashBase::Iter (physx::shdfnd::internal) MutexT::ScopedLock (physx::shdfnd) ScopedPointer (physx::shdfnd) ThreadT (physx::shdfnd)
C
HashMap (physx::shdfnd)
N
ScopedReadLock (physx::shdfnd) Time (physx::shdfnd)
CoalescedHashMap (physx::shdfnd) HashMapBase (physx::shdfnd::internal) NonTrackingAllocator (physx::shdfnd) ScopedWriteLock (physx::shdfnd)
U
CoalescedHashSet (physx::shdfnd) HashMapBase::GetKey (physx::shdfnd::internal)
P
SIMDGuard (physx::shdfnd) UnConst (physx::shdfnd)
CounterFrequencyToTensOfNanos (physx::shdfnd) HashSet (physx::shdfnd) Pair (physx::shdfnd) SListImpl (physx::shdfnd) UnConst< const T > (physx::shdfnd)
Cpu (physx::shdfnd) HashSetBase (physx::shdfnd::internal) Pool (physx::shdfnd) SListT (physx::shdfnd) UserAllocated (physx::shdfnd)
E
HashSetBase::GetKey (physx::shdfnd::internal) Pool2 (physx::shdfnd)

A | B | C | E | F | G | H | I | L | M | N | P | R | S | T | U

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::AlignedAllocator< N, BaseAllocator > Member List

This is the complete list of members for physx::shdfnd::AlignedAllocator< N, BaseAllocator >, including all inherited members.

AlignedAllocator(const BaseAllocator &base=BaseAllocator()) | physx::shdfnd::AlignedAllocator< N, BaseAllocator > | [inline]
allocate(size_t size, const char *file, int line) | physx::shdfnd::AlignedAllocator< N, BaseAllocator > | [inline]
deallocate(void *ptr) | physx::shdfnd::AlignedAllocator< N, BaseAllocator > | [inline]

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Array< T, Alloc > Member List

This is the complete list of members for physx::shdfnd::Array< T, Alloc >, including all inherited members.

allocate(uint32_t size) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
Array(const PxEMPTY v) | physx::shdfnd::Array< T, Alloc > | [inline, explicit]
Array(const Alloc &alloc=Alloc()) | physx::shdfnd::Array< T, Alloc > | [inline, explicit]
Array(uint32_t size, const T &a=T(), const Alloc &alloc=Alloc()) | physx::shdfnd::Array< T, Alloc > | [inline, explicit]
Array(const Array< T, A > &other, const Alloc &alloc=Alloc()) | physx::shdfnd::Array< T, Alloc > | [inline, explicit]
Array(const Array &other, const Alloc &alloc=Alloc()) | physx::shdfnd::Array< T, Alloc > | [inline]
Array(const T *first, const T *last, const Alloc &alloc=Alloc()) | physx::shdfnd::Array< T, Alloc > | [inline, explicit]
Array(T *memory, uint32_t size, uint32_t capacity, const Alloc &alloc=Alloc()) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
assign(const T *first, const T *last) | physx::shdfnd::Array< T, Alloc > | [inline]
back() const | physx::shdfnd::Array< T, Alloc > | [inline]
back() | physx::shdfnd::Array< T, Alloc > | [inline]
begin() const | physx::shdfnd::Array< T, Alloc > | [inline]
begin() | physx::shdfnd::Array< T, Alloc > | [inline]
capacity() const | physx::shdfnd::Array< T, Alloc > | [inline]
capacityIncrement() const | physx::shdfnd::Array< T, Alloc > | [inline, protected]
clear() | physx::shdfnd::Array< T, Alloc > | [inline]
ConstIterator typedef | physx::shdfnd::Array< T, Alloc > |
copy(const Array< T, A > &other) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
copy(T *first, T *last, const T *src) | physx::shdfnd::Array< T, Alloc > | [inline, protected, static]
create(T *first, T *last, const T &a) | physx::shdfnd::Array< T, Alloc > | [inline, protected, static]
deallocate(void *mem) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
destroy(T *first, T *last) | physx::shdfnd::Array< T, Alloc > | [inline, protected, static]
empty() const | physx::shdfnd::Array< T, Alloc > | [inline]
end() const | physx::shdfnd::Array< T, Alloc > | [inline]
end() | physx::shdfnd::Array< T, Alloc > | [inline]
find(const T &a) | physx::shdfnd::Array< T, Alloc > | [inline]
find(const T &a) const | physx::shdfnd::Array< T, Alloc > | [inline]
findAndReplaceWithLast(const T &a) | physx::shdfnd::Array< T, Alloc > | [inline]
forceSize_Unsafe(uint32_t size) | physx::shdfnd::Array< T, Alloc > | [inline]
front() const | physx::shdfnd::Array< T, Alloc > | [inline]
front() | physx::shdfnd::Array< T, Alloc > | [inline]
getAllocator() | physx::shdfnd::Array< T, Alloc > | [inline]
grow(uint32_t capacity) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
growAndPushBack(const T &a) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
insert() | physx::shdfnd::Array< T, Alloc > | [inline]
isArrayOfPOD() | physx::shdfnd::Array< T, Alloc > | [inline, static]
isInUserMemory() const | physx::shdfnd::Array< T, Alloc > | [inline]
isZeroInit(const T &object) | physx::shdfnd::Array< T, Alloc > | [inline, protected, static]
Iterator typedef | physx::shdfnd::Array< T, Alloc > |
mCapacity | physx::shdfnd::Array< T, Alloc > | [protected]
mData | physx::shdfnd::Array< T, Alloc > | [protected]
mSize | physx::shdfnd::Array< T, Alloc > | [protected]
operator=(const Array< T, A > &rhs) | physx::shdfnd::Array< T, Alloc > | [inline]
operator=(const Array &t) | physx::shdfnd::Array< T, Alloc > | [inline]
operator[](uint32_t i) const | physx::shdfnd::Array< T, Alloc > | [inline]
operator[](uint32_t i) | physx::shdfnd::Array< T, Alloc > | [inline]
popBack() | physx::shdfnd::Array< T, Alloc > | [inline]
pushBack(const T &a) | physx::shdfnd::Array< T, Alloc > | [inline]
recreate(uint32_t capacity) | physx::shdfnd::Array< T, Alloc > | [inline, protected]
remove(uint32_t i) | physx::shdfnd::Array< T, Alloc > | [inline]
removeRange(uint32_t begin, uint32_t count) | physx::shdfnd::Array< T, Alloc > | [inline]
replaceWithLast(uint32_t i) | physx::shdfnd::Array< T, Alloc > | [inline]
replaceWithLast(Iterator i) | physx::shdfnd::Array< T, Alloc > | [inline]
reserve(const uint32_t capacity) | physx::shdfnd::Array< T, Alloc > | [inline]
reset() | physx::shdfnd::Array< T, Alloc > | [inline]
resize(const uint32_t size, const T &a=T()) | physx::shdfnd::Array< T, Alloc > | [inline]
resizeUninitialized(const uint32_t size) | physx::shdfnd::Array< T, Alloc > | [inline]
shrink() | physx::shdfnd::Array< T, Alloc > | [inline]
size() const | physx::shdfnd::Array< T, Alloc > | [inline]
swap(Array< T, Alloc > &other) | physx::shdfnd::Array< T, Alloc > | [inline]
~Array() | physx::shdfnd::Array< T, Alloc > | [inline]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::AtomicLock Member List

This is the complete list of members for physx::shdfnd::AtomicLock, including all inherited members.

AtomicLock() | physx::shdfnd::AtomicLock | [inline]
lock() | physx::shdfnd::AtomicLock | [inline]
trylock() | physx::shdfnd::AtomicLock | [inline]
unlock() | physx::shdfnd::AtomicLock | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::AtomicLockCopy Member List

This is the complete list of members for physx::shdfnd::AtomicLockCopy, including all inherited members.

AtomicLockCopy() | physx::shdfnd::AtomicLockCopy | [inline]
lock() | physx::shdfnd::AtomicLockCopy | [inline]
operator=(AtomicLock &lock) | physx::shdfnd::AtomicLockCopy | [inline]
trylock() | physx::shdfnd::AtomicLockCopy | [inline]
unlock() | physx::shdfnd::AtomicLockCopy | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::AtomicRwLock Member List

This is the complete list of members for physx::shdfnd::AtomicRwLock, including all inherited members.

AtomicRwLock() | physx::shdfnd::AtomicRwLock | [inline]
lockReader() | physx::shdfnd::AtomicRwLock | [inline]
lockWriter() | physx::shdfnd::AtomicRwLock | [inline]
tryLockReader() | physx::shdfnd::AtomicRwLock | [inline]
unlockReader() | physx::shdfnd::AtomicRwLock | [inline]
unlockWriter() | physx::shdfnd::AtomicRwLock | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::BufferedSocketImpl Member List

This is the complete list of members for physx::shdfnd::BufferedSocketImpl, including all inherited members.

accept(bool block) | physx::shdfnd::SocketImpl |
BufferedSocketImpl(bool isBlocking) | physx::shdfnd::BufferedSocketImpl | [inline]
connect(const char *host, uint16_t port, uint32_t timeout) | physx::shdfnd::SocketImpl |
disconnect() | physx::shdfnd::SocketImpl |
flush() | physx::shdfnd::BufferedSocketImpl | [virtual]
getHost() const | physx::shdfnd::SocketImpl | [inline]
getPort() const | physx::shdfnd::SocketImpl | [inline]
isBlocking() const | physx::shdfnd::SocketImpl | [inline]
isConnected() const | physx::shdfnd::SocketImpl | [inline]
listen(uint16_t port) | physx::shdfnd::SocketImpl |
mHost | physx::shdfnd::SocketImpl | [protected]
mIsBlocking | physx::shdfnd::SocketImpl | [protected]
mIsConnected | physx::shdfnd::SocketImpl | [mutable, protected]
mListenMode | physx::shdfnd::SocketImpl | [protected]
mListenSocket | physx::shdfnd::SocketImpl | [protected]
mPort | physx::shdfnd::SocketImpl | [protected]
mSocket | physx::shdfnd::SocketImpl | [mutable, protected]
mSocketLayerIntialized | physx::shdfnd::SocketImpl | [protected]
nonBlockingTimeout() const | physx::shdfnd::SocketImpl | [protected]
read(uint8_t *data, uint32_t length) | physx::shdfnd::SocketImpl |
setBlocking(bool blocking) | physx::shdfnd::SocketImpl |
setBlockingInternal(SOCKET socket, bool blocking) | physx::shdfnd::SocketImpl | [protected]
SocketImpl(bool isBlocking) | physx::shdfnd::SocketImpl |
write(const uint8_t *data, uint32_t length) | physx::shdfnd::BufferedSocketImpl | [virtual]
~BufferedSocketImpl() | physx::shdfnd::BufferedSocketImpl | [inline, virtual]
~SocketImpl() | physx::shdfnd::SocketImpl | [virtual]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > Member List

This is the complete list of members for physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >, including all inherited members.

__pad0__ | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > | [package]
BaseMap typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
capacity() const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
clear() | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
CoalescedHashMap(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > | [inline, package]
Entry typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
erase(const Key &k) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
find(const Key &k) const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
getEntries() const | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > | [inline, package]
getIterator() | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashFn | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > | [package]
HashMapBase | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > | [package]
HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase(const Allocator &alloc) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
insert(const Keyk, const Valuev) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Iterator typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
mBase | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [protected]
operator[](const Key &k) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
reserve(uint32_t size) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
size() const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Value | physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > | [package]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > Member List

This is the complete list of members for physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >, including all inherited members.

BaseMap typedef | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > |
capacity() const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
clear() | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
CoalescedHashSet(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > | [inline]
CoalescedHashSet(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > | [inline]
CoalescedHashSet(const Allocator &alloc) | physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > | [inline]
contains(const Key &k) const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
erase(const Key &k) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
getEntries() const | physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > | [inline]
HashSetBase typedef | physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > |
HashSetBase< Key, HashFn, Allocator, true >::HashSetBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
HashSetBase< Key, HashFn, Allocator, true >::HashSetBase(const Allocator &alloc) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
HashSetBase< Key, HashFn, Allocator, true >::HashSetBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
insert(const Key &k) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
Iterator typedef | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > |
mBase | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [protected]
reserve(uint32_t size) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]
size() const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, true > | [inline]

Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Cpu Member List

This is the complete list of members for physx::shdfnd::Cpu, including all inherited members.

getCpuId() physx::shdfnd::Cpu [static]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::FPUGuard Member List

This is the complete list of members for physx::shdfnd::FPUGuard, including all inherited members.

FPUGuard() | physx::shdfnd::FPUGuard
~FPUGuard() | physx::shdfnd::FPUGuard

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > Member List

This is the complete list of members for physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >, including all inherited members.

__pad0__ | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [package]
BaseMap typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
capacity() const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
clear() | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Entry typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
erase(const Key &k) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
find(const Key &k) const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
getIterator() | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [inline, package]
HashFn | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [package]
HashMap(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [inline, package]
HashMap(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [inline, package]
HashMap(const Allocator &alloc) | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [inline, package]
HashMapBase | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [package]
HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase(const Allocator &alloc) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
insert(const Keyk, const Valuev) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Iterator typedef | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [package]
mBase | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [protected]
operator[](const Key &k) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
reserve(uint32_t size) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
size() const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Value | physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > | [package]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::HashSet< Key, HashFn, Allocator > Member List

This is the complete list of members for physx::shdfnd::HashSet< Key, HashFn, Allocator >, including all inherited members.

__pad0__ | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [package]
Allocator | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [package]
BaseMap typedef | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > |
capacity() const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
clear() | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
contains(const Key &k) const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
erase(const Key &k) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
getIterator() | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [inline, package]
HashFn | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [package]
HashSet(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [inline, package]
HashSet(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [inline, package]
HashSet(const Allocator &alloc) | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [inline, package]
HashSetBase | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [package]
HashSetBase< Key, HashFn, Allocator, false >::HashSetBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
HashSetBase< Key, HashFn, Allocator, false >::HashSetBase(const Allocator &alloc) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
HashSetBase< Key, HashFn, Allocator, false >::HashSetBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
insert(const Key &k) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
Iterator typedef | physx::shdfnd::HashSet< Key, HashFn, Allocator > | [package]
mBase | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [protected]
reserve(uint32_t size) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]
size() const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, false > | [inline]

Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::InlineAllocator< N, BaseAllocator > Member List

This is the complete list of members for physx::shdfnd::InlineAllocator< N, BaseAllocator >, including all inherited members.

allocate(uint32_t size, const char *filename, int line) | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
deallocate(void *ptr) | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
getInlineBuffer() | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
InlineAllocator(const PxEMPTY v) | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
InlineAllocator(const BaseAllocator &alloc=BaseAllocator()) | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
InlineAllocator(const InlineAllocator &aloc) | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
isBufferUsed() const | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [inline]
mBuffer | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [protected]
mBufferUsed | physx::shdfnd::InlineAllocator< N, BaseAllocator > | [protected]

Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::InlineArray< T, N, Alloc > Member List

This is the complete list of members for physx::shdfnd::InlineArray< T, N, Alloc >, including all inherited members.

allocate(uint32_t size) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected]
InlineAllocator< N *sizeof(T), Alloc >::allocate(uint32_t size, const char *filename, int line) | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [inline, protected]
Array(const PxEMPTY v) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, explicit]
Array(const InlineAllocator< N *sizeof(T), Alloc > &alloc=InlineAllocator< N *sizeof(T), Alloc >()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, explicit]
Array(uint32_t size, const T &a=T(), const InlineAllocator< N *sizeof(T), Alloc > &alloc=InlineAllocator< N *sizeof(T), Alloc >()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, explicit]
Array(const Array< T, A > &other, const InlineAllocator< N *sizeof(T), Alloc > &alloc=InlineAllocator< N *sizeof(T), Alloc >()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, explicit]
Array(const Array &other, const InlineAllocator< N *sizeof(T), Alloc > &alloc=InlineAllocator< N *sizeof(T), Alloc >()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
Array(const T *first, const T *last, const InlineAllocator< N *sizeof(T), Alloc > &alloc=InlineAllocator< N *sizeof(T), Alloc >()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, explicit]
Array(T *memory, uint32_t size, uint32_t capacity, const InlineAllocator< N *sizeof(T), Alloc > &alloc=InlineAllocator< N *sizeof(T), Alloc >()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected]
assign(const T *first, const T *last) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
back() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
back() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
begin() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
begin() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
capacity() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
capacityIncrement() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected]
clear() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
ConstIterator typedef | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > |
copy(const Array< T, A > &other) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected]
copy(T *first, T *last, const T *src) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected, static]
create(T *first, T *last, const T &a) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected, static]
deallocate(void *mem) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected]
destroy(T *first, T *last) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected, static]
empty() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
end() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
end() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
find(const T &a) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
find(const T &a) const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
findAndReplaceWithLast(const T &a) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
forceSize_Unsafe(uint32_t size) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
front() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
front() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
getAllocator() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
getInlineBuffer() | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [inline, protected]
grow(uint32_t capacity) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected]
growAndPushBack(const T &a) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [protected]
InlineAllocator(const PxEMPTY v) | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [inline, protected]
InlineAllocator(const Alloc &alloc=Alloc()) | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [inline, protected]
InlineAllocator(const InlineAllocator &aloc) | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [inline, protected]
InlineArray(const PxEMPTY v) | physx::shdfnd::InlineArray< T, N, Alloc > | [inline]
InlineArray(const Alloc &alloc=Alloc()) | physx::shdfnd::InlineArray< T, N, Alloc > | [inline, explicit]
insert() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
isArrayOfPOD() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, static]
isBufferUsed() const | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [inline, protected]
isInlined() const | physx::shdfnd::InlineArray< T, N, Alloc > | [inline]
isInUserMemory() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
isZeroInit(const T &object) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline, protected, static]
Iterator typedef | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > |
mBuffer | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [protected]
mBufferUsed | physx::shdfnd::InlineAllocator< N *sizeof(T), Alloc > | [protected]
mCapacity | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [protected]
mData | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [protected]
mSize | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [protected]
operator=(const Array< T, A > &rhs) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
operator=(const Array &t) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
operator[](uint32_t i) const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
operator[](uint32_t i) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
popBack() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
pushBack(const T &a) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
recreate(uint32_t capacity) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [protected]
remove(uint32_t i) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
removeRange(uint32_t begin, uint32_t count) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
replaceWithLast(uint32_t i) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
replaceWithLast(Iterator i) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
reserve(const uint32_t capacity) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
reset() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
resize(const uint32_t size, const T &a=T()) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > |
resizeUninitialized(const uint32_t size) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > |
shrink() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
size() const | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
swap(Array< T, InlineAllocator< N *sizeof(T), Alloc > > &other) | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]
~Array() | physx::shdfnd::Array< T, InlineAllocator< N *sizeof(T), Alloc > > | [inline]

Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::MutexImpl Member List

This is the complete list of members for physx::shdfnd::MutexImpl, including all inherited members.

getSize() | physx::shdfnd::MutexImpl | [static]
lock() | physx::shdfnd::MutexImpl |
MutexImpl() | physx::shdfnd::MutexImpl |
trylock() | physx::shdfnd::MutexImpl |
unlock() | physx::shdfnd::MutexImpl |
~MutexImpl() | physx::shdfnd::MutexImpl |

Generated on Tue Jul 28 14:21:58 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::MutexT< Alloc > Member List

This is the complete list of members for physx::shdfnd::MutexT< Alloc >, including all inherited members.

lock() const | physx::shdfnd::MutexT< Alloc > | [inline]
MutexT(const Alloc &alloc=Alloc()) | physx::shdfnd::MutexT< Alloc > | [inline]
trylock() const | physx::shdfnd::MutexT< Alloc > | [inline]
unlock() const | physx::shdfnd::MutexT< Alloc > | [inline]
~MutexT() | physx::shdfnd::MutexT< Alloc > | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock Member List

This is the complete list of members for physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock, including all inherited members.

ScopedLock(MutexT< Alloc > &mutex) | physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock | [inline]
~ScopedLock() | physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::NonTrackingAllocator Member List

This is the complete list of members for physx::shdfnd::NonTrackingAllocator, including all inherited members.

allocate(size_t size, const char *file, int line) | physx::shdfnd::NonTrackingAllocator | [inline]
deallocate(void *ptr) | physx::shdfnd::NonTrackingAllocator | [inline]
NonTrackingAllocator(const char *=0) | physx::shdfnd::NonTrackingAllocator | [inline]

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Pair< F, S > Member List

This is the complete list of members for physx::shdfnd::Pair< F, S >, including all inherited members.

first | physx::shdfnd::Pair< F, S > |
operator<(const Pair &p) const | physx::shdfnd::Pair< F, S > | [inline]
operator=(const Pair &p) | physx::shdfnd::Pair< F, S > | [inline]
operator==(const Pair &p) const | physx::shdfnd::Pair< F, S > | [inline]
Pair() | physx::shdfnd::Pair< F, S > | [inline]
Pair(const F &f, const S &s) | physx::shdfnd::Pair< F, S > | [inline]
Pair(const Pair &p) | physx::shdfnd::Pair< F, S > | [inline]
second | physx::shdfnd::Pair< F, S > |

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Pool2< T, slabSize, Alloc > Member List

This is the complete list of members for physx::shdfnd::Pool2< T, slabSize, Alloc >, including all inherited members.

allocate() | physx::shdfnd::PoolBase< T, Alloc > | [inline]
allocateSlab() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
construct() | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 *a, A2 &b, A3 &c) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c, A4 &d) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c, A4 &d, A5 &e) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
deallocate(T *p) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
destroy(T *const p) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
disposeElements() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
mElementsPerSlab | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mFreeElement | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mSlabs | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mSlabSize | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mUsed | physx::shdfnd::PoolBase< T, Alloc > | [protected]
operator delete(void *, void *) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t, void *address) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator new[](size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
Pool2(const Alloc &alloc=Alloc()) | physx::shdfnd::Pool2< T, slabSize, Alloc > | [inline]
PoolBase(const Alloc &alloc, uint32_t elementsPerSlab, uint32_t slabSize) | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
push(FreeList *p) | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
releaseEmptySlabs() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
~PoolBase() | physx::shdfnd::PoolBase< T, Alloc > | [inline]

Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Pool< T, Alloc > Member List

This is the complete list of members for physx::shdfnd::Pool< T, Alloc >, including all inherited members.

allocate() | physx::shdfnd::PoolBase< T, Alloc > | [inline]
allocateSlab() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
construct() | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 *a, A2 &b, A3 &c) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c, A4 &d) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c, A4 &d, A5 &e) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
deallocate(T *p) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
destroy(T *const p) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
disposeElements() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
mElementsPerSlab | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mFreeElement | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mSlabs | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mSlabSize | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mUsed | physx::shdfnd::PoolBase< T, Alloc > | [protected]
operator delete(void *, void *) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t, void *address) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator new[](size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
Pool(const Alloc &alloc=Alloc(), uint32_t elementsPerSlab=32) | physx::shdfnd::Pool< T, Alloc > | [inline]
PoolBase(const Alloc &alloc, uint32_t elementsPerSlab, uint32_t slabSize) | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
push(FreeList *p) | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
releaseEmptySlabs() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
~PoolBase() | physx::shdfnd::PoolBase< T, Alloc > | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::PoolBase< T, Alloc > Member List

This is the complete list of members for physx::shdfnd::PoolBase< T, Alloc >, including all inherited members.

allocate() | physx::shdfnd::PoolBase< T, Alloc > | [inline]
allocateSlab() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
construct() | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 *a, A2 &b, A3 &c) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c, A4 &d) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
construct(A1 &a, A2 &b, A3 &c, A4 &d, A5 &e) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
deallocate(T *p) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
destroy(T *const p) | physx::shdfnd::PoolBase< T, Alloc > | [inline]
disposeElements() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
mElementsPerSlab | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mFreeElement | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mSlabs | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mSlabSize | physx::shdfnd::PoolBase< T, Alloc > | [protected]
mUsed | physx::shdfnd::PoolBase< T, Alloc > | [protected]
operator delete(void *, void *) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t, void *address) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator new[](size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
PoolBase(const Alloc &alloc, uint32_t elementsPerSlab, uint32_t slabSize) | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
push(FreeList *p) | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
releaseEmptySlabs() | physx::shdfnd::PoolBase< T, Alloc > | [inline, protected]
~PoolBase() | physx::shdfnd::PoolBase< T, Alloc > | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::RawAllocator Member List

This is the complete list of members for physx::shdfnd::RawAllocator, including all inherited members.

allocate(size_t size, const char *, int) | physx::shdfnd::RawAllocator | [inline]
deallocate(void *ptr) | physx::shdfnd::RawAllocator | [inline]
RawAllocator(const char *=0) | physx::shdfnd::RawAllocator | [inline]

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ReadWriteLock Member List

This is the complete list of members for physx::shdfnd::ReadWriteLock, including all inherited members.

lockReader() | physx::shdfnd::ReadWriteLock
lockWriter() | physx::shdfnd::ReadWriteLock
ReadWriteLock() | physx::shdfnd::ReadWriteLock
unlockReader() | physx::shdfnd::ReadWriteLock
unlockWriter() | physx::shdfnd::ReadWriteLock
~ReadWriteLock() | physx::shdfnd::ReadWriteLock

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ReadWriteLockImpl Member List

This is the complete list of members for physx::shdfnd::ReadWriteLockImpl, including all inherited members.

mutex | physx::shdfnd::ReadWriteLockImpl |
readerCount | physx::shdfnd::ReadWriteLockImpl |
ReadWriteLockImpl() | physx::shdfnd::ReadWriteLockImpl | [inline]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ReflectionAllocator< T > Member List

This is the complete list of members for physx::shdfnd::ReflectionAllocator< T >, including all inherited members.

allocate(size_t size, const char *filename, int line) | physx::shdfnd::ReflectionAllocator< T > | [inline]
deallocate(void *ptr) | physx::shdfnd::ReflectionAllocator< T > | [inline]
ReflectionAllocator(const PxEMPTY) | physx::shdfnd::ReflectionAllocator< T > | [inline]
ReflectionAllocator(const char *=0) | physx::shdfnd::ReflectionAllocator< T > | [inline]
ReflectionAllocator(const ReflectionAllocator &) | physx::shdfnd::ReflectionAllocator< T > | [inline]

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Runnable Member List

This is the complete list of members for physx::shdfnd::Runnable, including all inherited members.

execute(void) | physx::shdfnd::Runnable | [inline, virtual]
Runnable() | physx::shdfnd::Runnable | [inline]
~Runnable() | physx::shdfnd::Runnable | [inline, virtual]

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::SIMDGuard Member List

This is the complete list of members for physx::shdfnd::SIMDGuard, including all inherited members.

SIMDGuard() | physx::shdfnd::SIMDGuard
~SIMDGuard() | physx::shdfnd::SIMDGuard

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::SListT< Alloc > Member List

This is the complete list of members for physx::shdfnd::SListT< Alloc >, including all inherited members.

flush() | physx::shdfnd::SListT< Alloc > | [inline]
pop() | physx::shdfnd::SListT< Alloc > | [inline]
push(SListEntry &entry) | physx::shdfnd::SListT< Alloc > | [inline]
SListT(const Alloc &alloc=Alloc()) | physx::shdfnd::SListT< Alloc > | [inline]
~SListT() | physx::shdfnd::SListT< Alloc > | [inline]

Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ScopedAtomicLock Member List

This is the complete list of members for physx::shdfnd::ScopedAtomicLock, including all inherited members.

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ScopedPointer< T, Alloc > Member List

This is the complete list of members for physx::shdfnd::ScopedPointer< T, Alloc >, including all inherited members.

mOwned | physx::shdfnd::ScopedPointer< T, Alloc > |
mPointer | physx::shdfnd::ScopedPointer< T, Alloc > |
operator T *() const | physx::shdfnd::ScopedPointer< T, Alloc > | [inline]
~ScopedPointer() | physx::shdfnd::ScopedPointer< T, Alloc > | [inline]

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ScopedReadLock Member List

This is the complete list of members for physx::shdfnd::ScopedReadLock, including all inherited members.

ScopedReadLock(ReadWriteLock &lock) | physx::shdfnd::ScopedReadLock | [inline]
~ScopedReadLock() | physx::shdfnd::ScopedReadLock | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ScopedWriteLock Member List

This is the complete list of members for physx::shdfnd::ScopedWriteLock, including all inherited members.

ScopedWriteLock(ReadWriteLock &lock) | physx::shdfnd::ScopedWriteLock | [inline]
~ScopedWriteLock() | physx::shdfnd::ScopedWriteLock | [inline]

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Socket Member List

This is the complete list of members for physx::shdfnd::Socket, including all inherited members.

accept(bool block) | physx::shdfnd::Socket |
connect(const char *host, uint16_t port, uint32_t timeout=1000) | physx::shdfnd::Socket |
DEFAULT_BUFFER_SIZE | physx::shdfnd::Socket | [static]
disconnect() | physx::shdfnd::Socket |
flush() | physx::shdfnd::Socket |
getHost() const | physx::shdfnd::Socket |
getPort() const | physx::shdfnd::Socket |
isBlocking() const | physx::shdfnd::Socket |
isConnected() const | physx::shdfnd::Socket |
listen(uint16_t port) | physx::shdfnd::Socket |
operator delete(void *, void *) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t, void *address) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator new[](size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
read(uint8_t *data, uint32_t length) | physx::shdfnd::Socket |
setBlocking(bool blocking) | physx::shdfnd::Socket |
Socket(bool inEnableBuffering=true, bool blocking=true) | physx::shdfnd::Socket |
write(const uint8_t *data, uint32_t length) | physx::shdfnd::Socket |
~Socket() | physx::shdfnd::Socket | [virtual]

Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::SocketImpl Member List

This is the complete list of members for physx::shdfnd::SocketImpl, including all inherited members.

accept(bool block) | physx::shdfnd::SocketImpl |
connect(const char *host, uint16_t port, uint32_t timeout) | physx::shdfnd::SocketImpl |
disconnect() | physx::shdfnd::SocketImpl |
flush() | physx::shdfnd::SocketImpl | [virtual]
getHost() const | physx::shdfnd::SocketImpl | [inline]
getPort() const | physx::shdfnd::SocketImpl | [inline]
isBlocking() const | physx::shdfnd::SocketImpl | [inline]
isConnected() const | physx::shdfnd::SocketImpl | [inline]
listen(uint16_t port) | physx::shdfnd::SocketImpl |
mHost | physx::shdfnd::SocketImpl | [protected]
mIsBlocking | physx::shdfnd::SocketImpl | [protected]
mIsConnected | physx::shdfnd::SocketImpl | [mutable, protected]
mListenMode | physx::shdfnd::SocketImpl | [protected]
mListenSocket | physx::shdfnd::SocketImpl | [protected]
mPort | physx::shdfnd::SocketImpl | [protected]
mSocket | physx::shdfnd::SocketImpl | [mutable, protected]
mSocketLayerIntialized | physx::shdfnd::SocketImpl | [protected]
nonBlockingTimeout() const | physx::shdfnd::SocketImpl | [protected]
read(uint8_t *data, uint32_t length) | physx::shdfnd::SocketImpl |
setBlocking(bool blocking) | physx::shdfnd::SocketImpl |
setBlockingInternal(SOCKET socket, bool blocking) | physx::shdfnd::SocketImpl | [protected]
SocketImpl(bool isBlocking) | physx::shdfnd::SocketImpl |
write(const uint8_t *data, uint32_t length) | physx::shdfnd::SocketImpl | [virtual]
~SocketImpl() | physx::shdfnd::SocketImpl | [virtual]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::SyncImpl Member List

This is the complete list of members for physx::shdfnd::SyncImpl, including all inherited members.

getSize() | physx::shdfnd::SyncImpl | [static]
reset() | physx::shdfnd::SyncImpl |
set() | physx::shdfnd::SyncImpl |
SyncImpl() | physx::shdfnd::SyncImpl |
wait(uint32_t milliseconds=waitForever) | physx::shdfnd::SyncImpl |
waitForever | physx::shdfnd::SyncImpl | [static]
~SyncImpl() | physx::shdfnd::SyncImpl |

Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::SyncT< Alloc > Member List

This is the complete list of members for physx::shdfnd::SyncT< Alloc >, including all inherited members.

reset() | physx::shdfnd::SyncT< Alloc > | [inline]
set() | physx::shdfnd::SyncT< Alloc > | [inline]
SyncT(const Alloc &alloc=Alloc()) | physx::shdfnd::SyncT< Alloc > | [inline]
wait(uint32_t milliseconds=SyncImpl::waitForever) | physx::shdfnd::SyncT< Alloc > | [inline]
waitForever | physx::shdfnd::SyncT< Alloc > | [static]
~SyncT() | physx::shdfnd::SyncT< Alloc > | [inline]

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::TempAllocator Member List

This is the complete list of members for physx::shdfnd::TempAllocator, including all inherited members.

allocate(size_t size, const char *file, int line) | physx::shdfnd::TempAllocator |
deallocate(void *ptr) | physx::shdfnd::TempAllocator |
TempAllocator(const char *=0) | physx::shdfnd::TempAllocator | [inline]

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ThreadImpl Member List

This is the complete list of members for physx::shdfnd::ThreadImpl, including all inherited members.

ExecuteFn typedef | physx::shdfnd::ThreadImpl |
getDefaultStackSize() | physx::shdfnd::ThreadImpl | [static]
getId() | physx::shdfnd::ThreadImpl | [static]
getNbPhysicalCores() | physx::shdfnd::ThreadImpl | [static]
getPriority(Id threadId) | physx::shdfnd::ThreadImpl | [static]
getSize() | physx::shdfnd::ThreadImpl | [static]
Id typedef | physx::shdfnd::ThreadImpl |
kill() | physx::shdfnd::ThreadImpl |
quit() | physx::shdfnd::ThreadImpl |
quitIsSignalled() | physx::shdfnd::ThreadImpl |
setAffinityMask(uint32_t mask) | physx::shdfnd::ThreadImpl |
setName(const char *name) | physx::shdfnd::ThreadImpl |
setPriority(ThreadPriority::Enum prio) | physx::shdfnd::ThreadImpl |
signalQuit() | physx::shdfnd::ThreadImpl |
sleep(uint32_t ms) | physx::shdfnd::ThreadImpl | [static]
start(uint32_t stackSize, Runnable *r) | physx::shdfnd::ThreadImpl |
ThreadImpl() | physx::shdfnd::ThreadImpl |
ThreadImpl(ExecuteFn fn, void *arg) | physx::shdfnd::ThreadImpl |
waitForQuit() | physx::shdfnd::ThreadImpl |
yield() | physx::shdfnd::ThreadImpl | [static]
~ThreadImpl() | physx::shdfnd::ThreadImpl |

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ThreadT< Alloc > Member List

This is the complete list of members for physx::shdfnd::ThreadT< Alloc >, including all inherited members.

execute(void) | physx::shdfnd::ThreadT< Alloc > | [inline, virtual]
getDefaultStackSize() | physx::shdfnd::ThreadT< Alloc > | [inline, static]
getId() | physx::shdfnd::ThreadT< Alloc > | [inline, static]
getNbPhysicalCores() | physx::shdfnd::ThreadT< Alloc > | [inline, static]
getPriority(ThreadImpl::Id threadId) | physx::shdfnd::ThreadT< Alloc > | [inline, static]
Id typedef | physx::shdfnd::ThreadT< Alloc > |
kill() | physx::shdfnd::ThreadT< Alloc > | [inline]
operator delete(void *, void *) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t, void *address) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator new[](size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
quit() | physx::shdfnd::ThreadT< Alloc > | [inline]
quitIsSignalled() | physx::shdfnd::ThreadT< Alloc > | [inline]
Runnable() | physx::shdfnd::Runnable | [inline]
setAffinityMask(uint32_t mask) | physx::shdfnd::ThreadT< Alloc > | [inline]
setName(const char *name) | physx::shdfnd::ThreadT< Alloc > | [inline]
setPriority(ThreadPriority::Enum prio) | physx::shdfnd::ThreadT< Alloc > | [inline]
signalQuit() | physx::shdfnd::ThreadT< Alloc > | [inline]
sleep(uint32_t ms) | physx::shdfnd::ThreadT< Alloc > | [inline, static]
start(uint32_t stackSize=ThreadImpl::getDefaultStackSize()) | physx::shdfnd::ThreadT< Alloc > | [inline]
ThreadT(const Alloc &alloc=Alloc()) | physx::shdfnd::ThreadT< Alloc > | [inline]
ThreadT(ThreadImpl::ExecuteFn fn, void *arg, const Alloc &alloc=Alloc()) | physx::shdfnd::ThreadT< Alloc > | [inline]
waitForQuit() | physx::shdfnd::ThreadT< Alloc > | [inline]
yield() | physx::shdfnd::ThreadT< Alloc > | [inline, static]
~Runnable() | physx::shdfnd::Runnable | [inline, virtual]
~ThreadT() | physx::shdfnd::ThreadT< Alloc > | [inline, virtual]

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Time Member List

This is the complete list of members for physx::shdfnd::Time, including all inherited members.

getBootCounterFrequency() | physx::shdfnd::Time | [static]
getCounterFrequency() | physx::shdfnd::Time | [static]
getCurrentCounterValue() | physx::shdfnd::Time | [static]
getCurrentTimeInTensOfNanoSeconds() | physx::shdfnd::Time | [inline, static]
getElapsedSeconds() | physx::shdfnd::Time |
getLastTime() const | physx::shdfnd::Time |
peekElapsedSeconds() | physx::shdfnd::Time |
Second typedef | physx::shdfnd::Time |
sNumTensOfNanoSecondsInASecond | physx::shdfnd::Time | [static]
Time() | physx::shdfnd::Time |

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::UserAllocated Member List

This is the complete list of members for physx::shdfnd::UserAllocated, including all inherited members.

operator delete(void *, void *) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete(void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator delete[](void *ptr) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t, void *address) | physx::shdfnd::UserAllocated | [inline]
operator new(size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]
operator new[](size_t size, Alloc alloc, const char *fileName, int line) | physx::shdfnd::UserAllocated | [inline]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > Member List

This is the complete list of members for physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >, including all inherited members.

capacity() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
clear() | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
create(const Key &k, bool &exists) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
EntryType typedef | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > |
EOL | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [static]
erase(const Key &k) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
find(const Key &k) const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
getEntries() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
HashBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
HashBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
HashBase(const Allocator &alloc) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
insertUnique(const Key &k) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
reserve(uint32_t size) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
size() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]
~HashBase() | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > | [inline]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter Member List

This is the complete list of members for physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter, including all inherited members.

check() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]
done() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]
Iter(HashBase &b) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]
operator*() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]
operator++() | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]
operator++(int) | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]
operator->() const | physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter | [inline]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > Member List

This is the complete list of members for physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >, including all inherited members.

BaseMap typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
capacity() const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
clear() | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Entry typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
erase(const Key &k) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
find(const Key &k) const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
getIterator() | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase(const Allocator &alloc) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
HashMapBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
insert(const Keyk, const Valuev) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
Iterator typedef | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > |
mBase | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [protected]
operator[](const Key &k) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
reserve(uint32_t size) | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]
size() const | physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > | [inline]

Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > Member List

This is the complete list of members for physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >, including all inherited members.

BaseMap typedef | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > |
capacity() const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
clear() | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
contains(const Key &k) const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
erase(const Key &k) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
HashSetBase(uint32_t initialTableSize, float loadFactor, const Allocator &alloc) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
HashSetBase(const Allocator &alloc) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
HashSetBase(uint32_t initialTableSize=64, float loadFactor=0.75f) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
insert(const Key &k) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
Iterator typedef | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > |
mBase | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [protected]
reserve(uint32_t size) | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]
size() const | physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > | [inline]

Generated on Tue Jul 28 14:22:02 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::Stack< Allocator > Member List

This is the complete list of members for physx::shdfnd::internal::Stack< Allocator >, including all inherited members.

empty() | physx::shdfnd::internal::Stack< Allocator > | [inline]
grow() | physx::shdfnd::internal::Stack< Allocator > | [inline]
pop(int32_t &start, int32_t &end) | physx::shdfnd::internal::Stack< Allocator > | [inline]
push(int32_t start, int32_t end) | physx::shdfnd::internal::Stack< Allocator > | [inline]
Stack(int32_t *memory, uint32_t capacity, const Allocator &inAllocator) | physx::shdfnd::internal::Stack< Allocator > | [inline]
~Stack() | physx::shdfnd::internal::Stack< Allocator > | [inline]

Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- k -

  • kill()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- l -

  • listen()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • lock()
: physx::shdfnd::MutexT< Alloc >
, physx::shdfnd::AtomicLock
, physx::shdfnd::MutexImpl
, physx::shdfnd::AtomicLockCopy
  • lockReader()
: physx::shdfnd::AtomicRwLock
, physx::shdfnd::ReadWriteLock
  • lockWriter()
: physx::shdfnd::AtomicRwLock
, physx::shdfnd::ReadWriteLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- m -

  • mBase : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • mBuffer : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • mBufferUsed : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • mCapacity : physx::shdfnd::Array< T, Alloc >
  • mData : physx::shdfnd::Array< T, Alloc >
  • mDenominator : physx::shdfnd::CounterFrequencyToTensOfNanos
  • mElementsPerSlab : physx::shdfnd::PoolBase< T, Alloc >
  • mFreeElement : physx::shdfnd::PoolBase< T, Alloc >
  • mHost : physx::shdfnd::SocketImpl
  • mIndex : physx::shdfnd::TempAllocatorChunk
  • mIsBlocking : physx::shdfnd::SocketImpl
  • mIsConnected : physx::shdfnd::SocketImpl
  • mListenMode : physx::shdfnd::SocketImpl
  • mListenSocket : physx::shdfnd::SocketImpl
  • mNext : physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList , physx::shdfnd::TempAllocatorChunk
  • mNumerator : physx::shdfnd::CounterFrequencyToTensOfNanos
  • mOwned : physx::shdfnd::ScopedPointer< T, Alloc >
  • mPad : physx::shdfnd::TempAllocatorChunk
  • mPointer : physx::shdfnd::ScopedPointer< T, Alloc >
  • mPort : physx::shdfnd::SocketImpl
  • mSize : physx::shdfnd::Array< T, Alloc >
  • mSlabs : physx::shdfnd::PoolBase< T, Alloc >
  • mSlabSize : physx::shdfnd::PoolBase< T, Alloc >
  • mSocket : physx::shdfnd::SocketImpl
  • mSocketLayerIntialized : physx::shdfnd::SocketImpl
  • mUsed : physx::shdfnd::PoolBase< T, Alloc >
  • mutex : physx::shdfnd::ReadWriteLockImpl
  • MutexImpl() : physx::shdfnd::MutexImpl
  • MutexT() : physx::shdfnd::MutexT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- n -

  • nonBlockingTimeout() : physx::shdfnd::SocketImpl
  • NonTrackingAllocator() : physx::shdfnd::NonTrackingAllocator
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- o -

  • operator delete() : physx::shdfnd::UserAllocated
  • operator delete[]() : physx::shdfnd::UserAllocated
  • operator new() : physx::shdfnd::UserAllocated
  • operator new[]() : physx::shdfnd::UserAllocated
  • operator T *() : physx::shdfnd::ScopedPointer< T, Alloc >
  • operator()()
: physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey
, physx::shdfnd::Equal< A >
, physx::shdfnd::Less< A >
, physx::shdfnd::Greater< A >
, physx::shdfnd::Hash< Key >
, physx::shdfnd::Hash< const char * >
, physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
  • operator*() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • operator++() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • operator->() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • operator<() : physx::shdfnd::Pair< F, S >
  • operator=()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::AtomicLockCopy
, physx::shdfnd::Pair< F, S >
  • operator==() : physx::shdfnd::Pair< F, S >
  • operator[]() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- ~ -

  • ~Array() : physx::shdfnd::Array< T, Alloc >
  • ~BufferedSocketImpl() : physx::shdfnd::BufferedSocketImpl
  • ~FPUGuard() : physx::shdfnd::FPUGuard
  • ~HashBase() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • ~MutexImpl() : physx::shdfnd::MutexImpl
  • ~MutexT() : physx::shdfnd::MutexT< Alloc >
  • ~PoolBase() : physx::shdfnd::PoolBase< T, Alloc >
  • ~ReadWriteLock() : physx::shdfnd::ReadWriteLock
  • ~Runnable() : physx::shdfnd::Runnable
  • ~ScopedLock() : physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • ~ScopedPointer() : physx::shdfnd::ScopedPointer< T, Alloc >
  • ~ScopedReadLock() : physx::shdfnd::ScopedReadLock
  • ~ScopedWriteLock() : physx::shdfnd::ScopedWriteLock
  • ~SIMDGuard() : physx::shdfnd::SIMDGuard
  • ~SListImpl() : physx::shdfnd::SListImpl
  • ~SListT() : physx::shdfnd::SListT< Alloc >
  • ~Socket() : physx::shdfnd::Socket
  • ~SocketImpl() : physx::shdfnd::SocketImpl
  • ~Stack() : physx::shdfnd::internal::Stack< Allocator >
  • ~SyncImpl() : physx::shdfnd::SyncImpl
  • ~SyncT() : physx::shdfnd::SyncT< Alloc >
  • ~ThreadImpl() : physx::shdfnd::ThreadImpl
  • ~ThreadT() : physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- a -

  • accept()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • AlignedAllocator() : physx::shdfnd::AlignedAllocator< N, BaseAllocator >
  • allocate()
: physx::shdfnd::AlignedAllocator< N, BaseAllocator >
, physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::InlineAllocator< N, BaseAllocator >
, physx::shdfnd::RawAllocator
, physx::shdfnd::PoolBase< T, Alloc >
, physx::shdfnd::TempAllocator
, physx::shdfnd::NonTrackingAllocator
, physx::shdfnd::ReflectionAllocator< T >
  • allocateSlab() : physx::shdfnd::PoolBase< T, Alloc >
  • Allocator : physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • Array() : physx::shdfnd::Array< T, Alloc >
  • assign() : physx::shdfnd::Array< T, Alloc >
  • AtomicLock() : physx::shdfnd::AtomicLock
  • AtomicLockCopy() : physx::shdfnd::AtomicLockCopy
  • AtomicRwLock() : physx::shdfnd::AtomicRwLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- b -

  • back() : physx::shdfnd::Array< T, Alloc >
  • BaseMap : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • begin() : physx::shdfnd::Array< T, Alloc >
  • BufferedSocketImpl() : physx::shdfnd::BufferedSocketImpl
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- c -

  • capacity() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • capacityIncrement() : physx::shdfnd::Array< T, Alloc >
  • check() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • clear() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::Array< T, Alloc >
  • CoalescedHashMap() : physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
  • CoalescedHashSet() : physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • connect()
: physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
  • ConstIterator : physx::shdfnd::Array< T, Alloc >
  • construct() : physx::shdfnd::PoolBase< T, Alloc >
  • contains() : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • copy() : physx::shdfnd::Array< T, Alloc >
  • CounterFrequencyToTensOfNanos() : physx::shdfnd::CounterFrequencyToTensOfNanos
  • create() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- d -

  • deallocate()
: physx::shdfnd::AlignedAllocator< N, BaseAllocator >
, physx::shdfnd::RawAllocator
, physx::shdfnd::ReflectionAllocator< T >
, physx::shdfnd::TempAllocator
, physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::NonTrackingAllocator
, physx::shdfnd::InlineAllocator< N, BaseAllocator >
, physx::shdfnd::PoolBase< T, Alloc >
  • DEFAULT_BUFFER_SIZE : physx::shdfnd::Socket
  • destroy()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::PoolBase< T, Alloc >
  • disconnect()
: physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
  • disposeElements() : physx::shdfnd::PoolBase< T, Alloc >
  • done() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- e -

  • eABOVE_NORMAL : physx::shdfnd::ThreadPriority
  • eBELOW_NORMAL : physx::shdfnd::ThreadPriority
  • eFORCE_DWORD : physx::shdfnd::ThreadPriority
  • eHIGH : physx::shdfnd::ThreadPriority
  • eLOW : physx::shdfnd::ThreadPriority
  • empty()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::internal::Stack< Allocator >
  • end() : physx::shdfnd::Array< T, Alloc >
  • eNORMAL : physx::shdfnd::ThreadPriority
  • Entry : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • EntryType : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • Enum : physx::shdfnd::ThreadPriority
  • EOL : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • equal()
: physx::shdfnd::Hash< const char * >
, physx::shdfnd::Hash< Key >
  • erase() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • execute()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::Runnable
  • ExecuteFn : physx::shdfnd::ThreadImpl
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- f -

  • find() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • findAndReplaceWithLast() : physx::shdfnd::Array< T, Alloc >
  • first : physx::shdfnd::Pair< F, S >
  • flush()
: physx::shdfnd::SListT< Alloc >
, physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
, physx::shdfnd::SListImpl
, physx::shdfnd::BufferedSocketImpl
  • forceSize_Unsafe() : physx::shdfnd::Array< T, Alloc >
  • FPUGuard() : physx::shdfnd::FPUGuard
  • front() : physx::shdfnd::Array< T, Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- g -

  • getAllocator() : physx::shdfnd::Array< T, Alloc >
  • getBootCounterFrequency() : physx::shdfnd::Time
  • getCounterFrequency() : physx::shdfnd::Time
  • getCpuId() : physx::shdfnd::Cpu
  • getCurrentCounterValue() : physx::shdfnd::Time
  • getCurrentTimeInTensOfNanoSeconds() : physx::shdfnd::Time
  • getDefaultStackSize()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • getElapsedSeconds() : physx::shdfnd::Time
  • getEntries() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • getHost()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • getId()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • getInlineBuffer() : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • getIterator() : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • getLastTime() : physx::shdfnd::Time
  • getNbPhysicalCores()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • getPort()
: physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
  • getPriority()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • getSize()
: physx::shdfnd::SyncImpl
, physx::shdfnd::ThreadImpl
, physx::shdfnd::SListImpl
, physx::shdfnd::MutexImpl
  • grow()
: physx::shdfnd::internal::Stack< Allocator >
, physx::shdfnd::Array< T, Alloc >
  • growAndPushBack() : physx::shdfnd::Array< T, Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- h -

  • HashBase() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • HashFn : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • HashMap() : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • HashMapBase : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • HashSet() : physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • HashSetBase() : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- i -

  • i : physx::shdfnd::EnableIfPod< T, X >
  • Id : physx::shdfnd::ThreadImpl , physx::shdfnd::ThreadT< Alloc >
  • InlineAllocator() : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • InlineArray() : physx::shdfnd::InlineArray< T, N, Alloc >
  • insert() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • insertUnique() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • isArrayOfPOD() : physx::shdfnd::Array< T, Alloc >
  • isBlocking()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • isBufferUsed() : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • isConnected()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • isInlined() : physx::shdfnd::InlineArray< T, N, Alloc >
  • isInUserMemory() : physx::shdfnd::Array< T, Alloc >
  • isZeroInit() : physx::shdfnd::Array< T, Alloc >
  • Iter() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • Iterator : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- p -

  • Pair() : physx::shdfnd::Pair< F, S >
  • peekElapsedSeconds() : physx::shdfnd::Time
  • Pool() : physx::shdfnd::Pool< T, Alloc >
  • Pool2() : physx::shdfnd::Pool2< T, slabSize, Alloc >
  • PoolBase() : physx::shdfnd::PoolBase< T, Alloc >
  • pop()
: physx::shdfnd::SListImpl
, physx::shdfnd::SListT< Alloc >
, physx::shdfnd::internal::Stack< Allocator >
  • popBack() : physx::shdfnd::Array< T, Alloc >
  • push()
: physx::shdfnd::internal::Stack< Allocator >
, physx::shdfnd::SListImpl
, physx::shdfnd::SListT< Alloc >
, physx::shdfnd::PoolBase< T, Alloc >
  • pushBack() : physx::shdfnd::Array< T, Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- q -

  • quit()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • quitIsSignalled()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- r -

  • RawAllocator() : physx::shdfnd::RawAllocator
  • read()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • readerCount : physx::shdfnd::ReadWriteLockImpl
  • ReadWriteLock() : physx::shdfnd::ReadWriteLock
  • ReadWriteLockImpl() : physx::shdfnd::ReadWriteLockImpl
  • recreate() : physx::shdfnd::Array< T, Alloc >
  • ReflectionAllocator() : physx::shdfnd::ReflectionAllocator< T >
  • releaseEmptySlabs() : physx::shdfnd::PoolBase< T, Alloc >
  • remove() : physx::shdfnd::Array< T, Alloc >
  • removeRange() : physx::shdfnd::Array< T, Alloc >
  • replaceWithLast() : physx::shdfnd::Array< T, Alloc >
  • reserve() : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • reset()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::SyncT< Alloc >
, physx::shdfnd::SyncImpl
  • resize() : physx::shdfnd::Array< T, Alloc >
  • resizeUninitialized() : physx::shdfnd::Array< T, Alloc >
  • Runnable() : physx::shdfnd::Runnable
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- s -

  • ScopedLock() : physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • ScopedReadLock() : physx::shdfnd::ScopedReadLock
  • ScopedWriteLock() : physx::shdfnd::ScopedWriteLock
  • second : physx::shdfnd::Pair< F, S >
  • Second : physx::shdfnd::Time
  • set()
: physx::shdfnd::SyncImpl
, physx::shdfnd::SyncT< Alloc >
  • setAffinityMask()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • setBlocking()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • setBlockingInternal() : physx::shdfnd::SocketImpl
  • setName()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • setPriority()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • shrink() : physx::shdfnd::Array< T, Alloc >
  • signalQuit()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • SIMDGuard() : physx::shdfnd::SIMDGuard
  • size() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • sleep()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • SListImpl() : physx::shdfnd::SListImpl
  • SListT() : physx::shdfnd::SListT< Alloc >
  • sNumTensOfNanoSecondsInASecond : physx::shdfnd::Time
  • Socket() : physx::shdfnd::Socket
  • SocketImpl() : physx::shdfnd::SocketImpl
  • Stack() : physx::shdfnd::internal::Stack< Allocator >
  • start()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • swap() : physx::shdfnd::Array< T, Alloc >
  • SyncImpl() : physx::shdfnd::SyncImpl
  • SyncT() : physx::shdfnd::SyncT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- t -

  • t : physx::shdfnd::EnableIfPod< T, X >
  • TempAllocator() : physx::shdfnd::TempAllocator
  • TempAllocatorChunk() : physx::shdfnd::TempAllocatorChunk
  • ThreadImpl() : physx::shdfnd::ThreadImpl
  • ThreadT() : physx::shdfnd::ThreadT< Alloc >
  • Time() : physx::shdfnd::Time
  • toTensOfNanos() : physx::shdfnd::CounterFrequencyToTensOfNanos
  • trylock()
: physx::shdfnd::MutexT< Alloc >
, physx::shdfnd::MutexImpl
, physx::shdfnd::AtomicLockCopy
, physx::shdfnd::AtomicLock
  • tryLockReader() : physx::shdfnd::AtomicRwLock
  • Type
: physx::shdfnd::EnableIfPod< T, X >
, physx::shdfnd::UnConst< T >
, physx::shdfnd::UnConst< const T >
, physx::shdfnd::AllocatorTraits< T >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- u -

  • unlock()
: physx::shdfnd::MutexImpl
, physx::shdfnd::MutexT< Alloc >
, physx::shdfnd::AtomicLockCopy
, physx::shdfnd::AtomicLock
  • unlockReader()
: physx::shdfnd::ReadWriteLock
, physx::shdfnd::AtomicRwLock
  • unlockWriter()
: physx::shdfnd::AtomicRwLock
, physx::shdfnd::ReadWriteLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- v -

  • Value : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • value : physx::shdfnd::LogTwo< 1 > , physx::shdfnd::LogTwo< A >
  • Value : physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- w -

  • wait()
: physx::shdfnd::SyncImpl
, physx::shdfnd::SyncT< Alloc >
  • waitForever : physx::shdfnd::SyncT< Alloc > , physx::shdfnd::SyncImpl
  • waitForQuit()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • write()
: physx::shdfnd::BufferedSocketImpl
, physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • v
  • w
  • y
  • ~
Here is a list of all class members with links to the classes they belong to:

- y -

  • yield()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Enumerations

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • Enum : physx::shdfnd::ThreadPriority
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Enumerator

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • eABOVE_NORMAL : physx::shdfnd::ThreadPriority
  • eBELOW_NORMAL : physx::shdfnd::ThreadPriority
  • eFORCE_DWORD : physx::shdfnd::ThreadPriority
  • eHIGH : physx::shdfnd::ThreadPriority
  • eLOW : physx::shdfnd::ThreadPriority
  • eNORMAL : physx::shdfnd::ThreadPriority
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- a -

  • accept()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • AlignedAllocator() : physx::shdfnd::AlignedAllocator< N, BaseAllocator >
  • allocate()
: physx::shdfnd::AlignedAllocator< N, BaseAllocator >
, physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::InlineAllocator< N, BaseAllocator >
, physx::shdfnd::RawAllocator
, physx::shdfnd::PoolBase< T, Alloc >
, physx::shdfnd::TempAllocator
, physx::shdfnd::NonTrackingAllocator
, physx::shdfnd::ReflectionAllocator< T >
  • allocateSlab() : physx::shdfnd::PoolBase< T, Alloc >
  • Array() : physx::shdfnd::Array< T, Alloc >
  • assign() : physx::shdfnd::Array< T, Alloc >
  • AtomicLock() : physx::shdfnd::AtomicLock
  • AtomicLockCopy() : physx::shdfnd::AtomicLockCopy
  • AtomicRwLock() : physx::shdfnd::AtomicRwLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- k -

  • kill()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- l -

  • listen()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • lock()
: physx::shdfnd::MutexT< Alloc >
, physx::shdfnd::AtomicLock
, physx::shdfnd::MutexImpl
, physx::shdfnd::AtomicLockCopy
  • lockReader()
: physx::shdfnd::AtomicRwLock
, physx::shdfnd::ReadWriteLock
  • lockWriter()
: physx::shdfnd::AtomicRwLock
, physx::shdfnd::ReadWriteLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- m -

  • MutexImpl() : physx::shdfnd::MutexImpl
  • MutexT() : physx::shdfnd::MutexT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- n -

  • nonBlockingTimeout() : physx::shdfnd::SocketImpl
  • NonTrackingAllocator() : physx::shdfnd::NonTrackingAllocator
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- o -

  • operator delete() : physx::shdfnd::UserAllocated
  • operator delete[]() : physx::shdfnd::UserAllocated
  • operator new() : physx::shdfnd::UserAllocated
  • operator new[]() : physx::shdfnd::UserAllocated
  • operator T *() : physx::shdfnd::ScopedPointer< T, Alloc >
  • operator()()
: physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey
, physx::shdfnd::Equal< A >
, physx::shdfnd::Less< A >
, physx::shdfnd::Greater< A >
, physx::shdfnd::Hash< Key >
, physx::shdfnd::Hash< const char * >
, physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey
  • operator*() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • operator++() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • operator->() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • operator<() : physx::shdfnd::Pair< F, S >
  • operator=()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::AtomicLockCopy
, physx::shdfnd::Pair< F, S >
  • operator==() : physx::shdfnd::Pair< F, S >
  • operator[]() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- ~ -

  • ~Array() : physx::shdfnd::Array< T, Alloc >
  • ~BufferedSocketImpl() : physx::shdfnd::BufferedSocketImpl
  • ~FPUGuard() : physx::shdfnd::FPUGuard
  • ~HashBase() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • ~MutexImpl() : physx::shdfnd::MutexImpl
  • ~MutexT() : physx::shdfnd::MutexT< Alloc >
  • ~PoolBase() : physx::shdfnd::PoolBase< T, Alloc >
  • ~ReadWriteLock() : physx::shdfnd::ReadWriteLock
  • ~Runnable() : physx::shdfnd::Runnable
  • ~ScopedLock() : physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • ~ScopedPointer() : physx::shdfnd::ScopedPointer< T, Alloc >
  • ~ScopedReadLock() : physx::shdfnd::ScopedReadLock
  • ~ScopedWriteLock() : physx::shdfnd::ScopedWriteLock
  • ~SIMDGuard() : physx::shdfnd::SIMDGuard
  • ~SListImpl() : physx::shdfnd::SListImpl
  • ~SListT() : physx::shdfnd::SListT< Alloc >
  • ~Socket() : physx::shdfnd::Socket
  • ~SocketImpl() : physx::shdfnd::SocketImpl
  • ~Stack() : physx::shdfnd::internal::Stack< Allocator >
  • ~SyncImpl() : physx::shdfnd::SyncImpl
  • ~SyncT() : physx::shdfnd::SyncT< Alloc >
  • ~ThreadImpl() : physx::shdfnd::ThreadImpl
  • ~ThreadT() : physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- b -

  • back() : physx::shdfnd::Array< T, Alloc >
  • begin() : physx::shdfnd::Array< T, Alloc >
  • BufferedSocketImpl() : physx::shdfnd::BufferedSocketImpl
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- c -

  • capacity() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • capacityIncrement() : physx::shdfnd::Array< T, Alloc >
  • check() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
  • clear() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::Array< T, Alloc >
  • CoalescedHashMap() : physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
  • CoalescedHashSet() : physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • connect()
: physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
  • construct() : physx::shdfnd::PoolBase< T, Alloc >
  • contains() : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • copy() : physx::shdfnd::Array< T, Alloc >
  • CounterFrequencyToTensOfNanos() : physx::shdfnd::CounterFrequencyToTensOfNanos
  • create() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- d -

  • deallocate()
: physx::shdfnd::AlignedAllocator< N, BaseAllocator >
, physx::shdfnd::RawAllocator
, physx::shdfnd::ReflectionAllocator< T >
, physx::shdfnd::TempAllocator
, physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::NonTrackingAllocator
, physx::shdfnd::InlineAllocator< N, BaseAllocator >
, physx::shdfnd::PoolBase< T, Alloc >
  • destroy()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::PoolBase< T, Alloc >
  • disconnect()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • disposeElements() : physx::shdfnd::PoolBase< T, Alloc >
  • done() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- e -

  • empty()
: physx::shdfnd::Array< T, Alloc >
, physx::shdfnd::internal::Stack< Allocator >
  • end() : physx::shdfnd::Array< T, Alloc >
  • equal()
: physx::shdfnd::Hash< Key >
, physx::shdfnd::Hash< const char * >
  • erase() : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • execute()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::Runnable
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- f -

  • find() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • findAndReplaceWithLast() : physx::shdfnd::Array< T, Alloc >
  • flush()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
, physx::shdfnd::BufferedSocketImpl
, physx::shdfnd::SListT< Alloc >
, physx::shdfnd::SListImpl
  • forceSize_Unsafe() : physx::shdfnd::Array< T, Alloc >
  • FPUGuard() : physx::shdfnd::FPUGuard
  • front() : physx::shdfnd::Array< T, Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- g -

  • getAllocator() : physx::shdfnd::Array< T, Alloc >
  • getBootCounterFrequency() : physx::shdfnd::Time
  • getCounterFrequency() : physx::shdfnd::Time
  • getCpuId() : physx::shdfnd::Cpu
  • getCurrentCounterValue() : physx::shdfnd::Time
  • getCurrentTimeInTensOfNanoSeconds() : physx::shdfnd::Time
  • getDefaultStackSize()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • getElapsedSeconds() : physx::shdfnd::Time
  • getEntries() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • getHost()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • getId()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • getInlineBuffer() : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • getIterator() : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • getLastTime() : physx::shdfnd::Time
  • getNbPhysicalCores()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • getPort()
: physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
  • getPriority()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • getSize()
: physx::shdfnd::SyncImpl
, physx::shdfnd::ThreadImpl
, physx::shdfnd::SListImpl
, physx::shdfnd::MutexImpl
  • grow()
: physx::shdfnd::internal::Stack< Allocator >
, physx::shdfnd::Array< T, Alloc >
  • growAndPushBack() : physx::shdfnd::Array< T, Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- h -

  • HashBase() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • HashMap() : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • HashMapBase() : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • HashSet() : physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • HashSetBase() : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- i -

  • InlineAllocator() : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • InlineArray() : physx::shdfnd::InlineArray< T, N, Alloc >
  • insert() : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >
  • insertUnique() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • isArrayOfPOD() : physx::shdfnd::Array< T, Alloc >
  • isBlocking()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • isBufferUsed() : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • isConnected()
: physx::shdfnd::SocketImpl
, physx::shdfnd::Socket
  • isInlined() : physx::shdfnd::InlineArray< T, N, Alloc >
  • isInUserMemory() : physx::shdfnd::Array< T, Alloc >
  • isZeroInit() : physx::shdfnd::Array< T, Alloc >
  • Iter() : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >::HashBase::Iter
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- p -

  • Pair() : physx::shdfnd::Pair< F, S >
  • peekElapsedSeconds() : physx::shdfnd::Time
  • Pool() : physx::shdfnd::Pool< T, Alloc >
  • Pool2() : physx::shdfnd::Pool2< T, slabSize, Alloc >
  • PoolBase() : physx::shdfnd::PoolBase< T, Alloc >
  • pop()
: physx::shdfnd::SListImpl
, physx::shdfnd::SListT< Alloc >
, physx::shdfnd::internal::Stack< Allocator >
  • popBack() : physx::shdfnd::Array< T, Alloc >
  • push()
: physx::shdfnd::internal::Stack< Allocator >
, physx::shdfnd::SListImpl
, physx::shdfnd::SListT< Alloc >
, physx::shdfnd::PoolBase< T, Alloc >
  • pushBack() : physx::shdfnd::Array< T, Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- q -

  • quit()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • quitIsSignalled()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- r -

  • RawAllocator() : physx::shdfnd::RawAllocator
  • read()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • ReadWriteLock() : physx::shdfnd::ReadWriteLock
  • ReadWriteLockImpl() : physx::shdfnd::ReadWriteLockImpl
  • recreate() : physx::shdfnd::Array< T, Alloc >
  • ReflectionAllocator() : physx::shdfnd::ReflectionAllocator< T >
  • releaseEmptySlabs() : physx::shdfnd::PoolBase< T, Alloc >
  • remove() : physx::shdfnd::Array< T, Alloc >
  • removeRange() : physx::shdfnd::Array< T, Alloc >
  • replaceWithLast() : physx::shdfnd::Array< T, Alloc >
  • reserve() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • reset()
: physx::shdfnd::SyncT< Alloc >
, physx::shdfnd::SyncImpl
, physx::shdfnd::Array< T, Alloc >
  • resize() : physx::shdfnd::Array< T, Alloc >
  • resizeUninitialized() : physx::shdfnd::Array< T, Alloc >
  • Runnable() : physx::shdfnd::Runnable
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- s -

  • ScopedLock() : physx::shdfnd::MutexT< Alloc >::MutexT::ScopedLock
  • ScopedReadLock() : physx::shdfnd::ScopedReadLock
  • ScopedWriteLock() : physx::shdfnd::ScopedWriteLock
  • set()
: physx::shdfnd::SyncImpl
, physx::shdfnd::SyncT< Alloc >
  • setAffinityMask()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • setBlocking()
: physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
  • setBlockingInternal() : physx::shdfnd::SocketImpl
  • setName()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • setPriority()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • shrink() : physx::shdfnd::Array< T, Alloc >
  • signalQuit()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • SIMDGuard() : physx::shdfnd::SIMDGuard
  • size() : physx::shdfnd::Array< T, Alloc > , physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • sleep()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • SListImpl() : physx::shdfnd::SListImpl
  • SListT() : physx::shdfnd::SListT< Alloc >
  • Socket() : physx::shdfnd::Socket
  • SocketImpl() : physx::shdfnd::SocketImpl
  • Stack() : physx::shdfnd::internal::Stack< Allocator >
  • start()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
  • swap() : physx::shdfnd::Array< T, Alloc >
  • SyncImpl() : physx::shdfnd::SyncImpl
  • SyncT() : physx::shdfnd::SyncT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- t -

  • TempAllocator() : physx::shdfnd::TempAllocator
  • TempAllocatorChunk() : physx::shdfnd::TempAllocatorChunk
  • ThreadImpl() : physx::shdfnd::ThreadImpl
  • ThreadT() : physx::shdfnd::ThreadT< Alloc >
  • Time() : physx::shdfnd::Time
  • toTensOfNanos() : physx::shdfnd::CounterFrequencyToTensOfNanos
  • trylock()
: physx::shdfnd::MutexImpl
, physx::shdfnd::AtomicLockCopy
, physx::shdfnd::MutexT< Alloc >
, physx::shdfnd::AtomicLock
  • tryLockReader() : physx::shdfnd::AtomicRwLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- u -

  • unlock()
: physx::shdfnd::MutexImpl
, physx::shdfnd::MutexT< Alloc >
, physx::shdfnd::AtomicLockCopy
, physx::shdfnd::AtomicLock
  • unlockReader()
: physx::shdfnd::ReadWriteLock
, physx::shdfnd::AtomicRwLock
  • unlockWriter()
: physx::shdfnd::AtomicRwLock
, physx::shdfnd::ReadWriteLock
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- w -

  • wait()
: physx::shdfnd::SyncImpl
, physx::shdfnd::SyncT< Alloc >
  • waitForQuit()
: physx::shdfnd::ThreadT< Alloc >
, physx::shdfnd::ThreadImpl
  • write()
: physx::shdfnd::BufferedSocketImpl
, physx::shdfnd::Socket
, physx::shdfnd::SocketImpl
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Functions

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • k
  • l
  • m
  • n
  • o
  • p
  • q
  • r
  • s
  • t
  • u
  • w
  • y
  • ~

- y -

  • yield()
: physx::shdfnd::ThreadImpl
, physx::shdfnd::ThreadT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Typedefs

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator

  • BaseMap : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • ConstIterator : physx::shdfnd::Array< T, Alloc >
  • Entry : physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • EntryType : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >
  • ExecuteFn : physx::shdfnd::ThreadImpl
  • HashSetBase : physx::shdfnd::CoalescedHashSet< Key, HashFn, Allocator >
  • Id : physx::shdfnd::ThreadImpl , physx::shdfnd::ThreadT< Alloc >
  • Iterator : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator > , physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::Array< T, Alloc > , physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • Second : physx::shdfnd::Time
  • Type
: physx::shdfnd::AllocatorTraits< T >
, physx::shdfnd::UnConst< const T >
, physx::shdfnd::UnConst< T >
, physx::shdfnd::EnableIfPod< T, X >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members - Variables

  • All
  • Functions
  • Variables
  • Typedefs
  • Enumerations
  • Enumerator
  • _
  • a
  • d
  • e
  • f
  • h
  • i
  • m
  • r
  • s
  • t
  • v
  • w

- _ -

  • __pad0__ : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >

- a -

  • Allocator : physx::shdfnd::HashSet< Key, HashFn, Allocator >

- d -

  • DEFAULT_BUFFER_SIZE : physx::shdfnd::Socket

- e -

  • EOL : physx::shdfnd::internal::HashBase< Entry, Key, HashFn, GetKey, Allocator, compacting >

- f -

  • first : physx::shdfnd::Pair< F, S >

- h -

  • HashFn : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::HashSet< Key, HashFn, Allocator >
  • HashMapBase : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator > , physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >
  • HashSetBase : physx::shdfnd::HashSet< Key, HashFn, Allocator >

- i -

  • i : physx::shdfnd::EnableIfPod< T, X >

- m -

  • mBase : physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced > , physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >
  • mBuffer : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • mBufferUsed : physx::shdfnd::InlineAllocator< N, BaseAllocator >
  • mCapacity : physx::shdfnd::Array< T, Alloc >
  • mData : physx::shdfnd::Array< T, Alloc >
  • mDenominator : physx::shdfnd::CounterFrequencyToTensOfNanos
  • mElementsPerSlab : physx::shdfnd::PoolBase< T, Alloc >
  • mFreeElement : physx::shdfnd::PoolBase< T, Alloc >
  • mHost : physx::shdfnd::SocketImpl
  • mIndex : physx::shdfnd::TempAllocatorChunk
  • mIsBlocking : physx::shdfnd::SocketImpl
  • mIsConnected : physx::shdfnd::SocketImpl
  • mListenMode : physx::shdfnd::SocketImpl
  • mListenSocket : physx::shdfnd::SocketImpl
  • mNext : physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList , physx::shdfnd::TempAllocatorChunk
  • mNumerator : physx::shdfnd::CounterFrequencyToTensOfNanos
  • mOwned : physx::shdfnd::ScopedPointer< T, Alloc >
  • mPad : physx::shdfnd::TempAllocatorChunk
  • mPointer : physx::shdfnd::ScopedPointer< T, Alloc >
  • mPort : physx::shdfnd::SocketImpl
  • mSize : physx::shdfnd::Array< T, Alloc >
  • mSlabs : physx::shdfnd::PoolBase< T, Alloc >
  • mSlabSize : physx::shdfnd::PoolBase< T, Alloc >
  • mSocket : physx::shdfnd::SocketImpl
  • mSocketLayerIntialized : physx::shdfnd::SocketImpl
  • mUsed : physx::shdfnd::PoolBase< T, Alloc >
  • mutex : physx::shdfnd::ReadWriteLockImpl

- r -

  • readerCount : physx::shdfnd::ReadWriteLockImpl

- s -

  • second : physx::shdfnd::Pair< F, S >
  • sNumTensOfNanoSecondsInASecond : physx::shdfnd::Time

- t -

  • t : physx::shdfnd::EnableIfPod< T, X >

- v -

  • Value : physx::shdfnd::HashMap< Key, Value, HashFn, Allocator >
  • value : physx::shdfnd::LogTwo< 1 > , physx::shdfnd::LogTwo< A >
  • Value : physx::shdfnd::CoalescedHashMap< Key, Value, HashFn, Allocator >

- w -

  • waitForever : physx::shdfnd::SyncImpl , physx::shdfnd::SyncT< Alloc >
Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Defines
  • _
  • n
  • p
  • w

- _ -

  • _MCW_ALL : PsWindowsFPU.cpp
  • _WIN32_WINNT : PsWindowsInclude.h

- n -

  • NOATOM : PsWindowsInclude.h
  • NOCLIPBOARD : PsWindowsInclude.h
  • NOCOLOR : PsWindowsInclude.h
  • NOCOMM : PsWindowsInclude.h
  • NOCTLMGR : PsWindowsInclude.h
  • NODEFERWINDOWPOS : PsWindowsInclude.h
  • NODRAWTEXT : PsWindowsInclude.h
  • NOGDI : PsWindowsInclude.h
  • NOGDICAPMASKS : PsWindowsInclude.h
  • NOHELP : PsWindowsInclude.h
  • NOICONS : PsWindowsInclude.h
  • NOKANJI : PsWindowsInclude.h
  • NOKEYSTATES : PsWindowsInclude.h
  • NOMB : PsWindowsInclude.h
  • NOMCX : PsWindowsInclude.h
  • NOMEMMGR : PsWindowsInclude.h
  • NOMENUS : PsWindowsInclude.h
  • NOMETAFILE : PsWindowsInclude.h
  • NOMINMAX : PsWindowsInclude.h
  • NOMSG : PsWindowsInclude.h
  • NONLS : PsWindowsInclude.h
  • NOOPENFILE : PsWindowsInclude.h
  • NOPROFILER : PsWindowsInclude.h
  • NORASTEROPS : PsWindowsInclude.h
  • NOSCROLL : PsWindowsInclude.h
  • NOSERVICE : PsWindowsInclude.h
  • NOSHOWWINDOW : PsWindowsInclude.h
  • NOSOUND : PsWindowsInclude.h
  • NOSYSCOMMANDS : PsWindowsInclude.h
  • NOSYSMETRICS : PsWindowsInclude.h
  • NOTEXTMETRIC : PsWindowsInclude.h
  • NOUSER : PsWindowsInclude.h
  • NOVIRTUALKEYCODES : PsWindowsInclude.h
  • NOWH : PsWindowsInclude.h
  • NOWINMESSAGES : PsWindowsInclude.h
  • NOWINOFFSETS : PsWindowsInclude.h
  • NOWINSTYLES : PsWindowsInclude.h
  • NS_EXPECT_FALSE : PsWindowsIntrinsics.h
  • NS_EXPECT_TRUE : PsWindowsIntrinsics.h
  • NS_MS_VC_EXCEPTION : PsWindowsThread.cpp

- p -

  • PX_ALIGNED16_ALLOC : PsAllocator.h
  • PX_ALIGNED16_FREE : PsAllocator.h
  • PX_ALLOC : PsAllocator.h
  • PX_ALLOC_TEMP : PsAllocator.h
  • PX_ALLOCA : PsAlloca.h
  • PX_DEBUG_EXP : Ps.h
  • PX_DELETE : PsAllocator.h
  • PX_DELETE_AND_RESET : PsAllocator.h
  • PX_DELETE_ARRAY : PsAllocator.h
  • PX_DELETE_POD : PsAllocator.h
  • PX_FOUNDATION_VERSION : PsVersionNumber.h
  • PX_FOUNDATION_VERSION_BUGFIX : PsVersionNumber.h
  • PX_FOUNDATION_VERSION_MAJOR : PsVersionNumber.h
  • PX_FOUNDATION_VERSION_MINOR : PsVersionNumber.h
  • PX_FPU_GUARD : PsFPU.h
  • PX_FR : PsFPU.h
  • PX_FREE : PsAllocator.h
  • PX_FREE_AND_RESET : PsAllocator.h
  • PX_IR : PsFPU.h
  • PX_NEW : PsAllocator.h
  • PX_NEW_TEMP : PsAllocator.h
  • PX_PLACEMENT_NEW : PsAllocator.h
  • PX_SIGN_BITMASK : Ps.h , PsFPU.h
  • PX_SIMD_GUARD : PsFPU.h
  • PX_SIR : PsFPU.h
  • PX_SLIST_ALIGNMENT : PsSList.h
  • PX_SORT_PARANOIA : PsSort.h
  • PX_SUPPORT_GUARDS : PsFPU.h
  • PX_USE_NAMED_ALLOCATOR : PsAllocator.h
  • PxAllocaAligned : PsAllocator.h

- w -

  • WIN32_LEAN_AND_MEAN : PsWindowsInclude.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Defines

  • operator delete() : PsAllocator.h
  • operator delete[]() : PsAllocator.h
  • operator new() : PsAllocator.h
  • operator new[]() : PsAllocator.h
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • File List
  • File Members
  • All
  • Functions
  • Variables
  • Defines

  • affinityMask : PsWindowsThread.cpp
  • allocFreeTable : PsTempAllocator.cpp
  • allocMutex : PsTempAllocator.cpp
  • arg : PsWindowsThread.cpp
  • dwFlags : PsWindowsThread.cpp
  • dwThreadID : PsWindowsThread.cpp
  • dwType : PsWindowsThread.cpp
  • fn : PsWindowsThread.cpp
  • mLock : PsWindowsMutex.cpp
  • mOwner : PsWindowsMutex.cpp
  • quitNow : PsWindowsThread.cpp
  • state : PsWindowsThread.cpp
  • szName : PsWindowsThread.cpp
  • thread : PsWindowsThread.cpp
  • threadID : PsWindowsThread.cpp
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Main Page

NVIDIA(R) PsFoundation Reference Documentation

Generated on Tue Jul 28 14:21:55 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs
  • _
  • a
  • b
  • c
  • d
  • e
  • f
  • g
  • h
  • i
  • l
  • m
  • n
  • p
  • r
  • s
  • t
  • v

- _ -

  • __declspec() : physx::shdfnd

- a -

  • atomicAdd() : physx::shdfnd
  • atomicCompareExchange() : physx::shdfnd
  • atomicCompareExchangePointer() : physx::shdfnd
  • atomicDecrement() : physx::shdfnd
  • atomicExchange() : physx::shdfnd
  • atomicIncrement() : physx::shdfnd
  • atomicMax() : physx::shdfnd

- b -

  • bitCount() : physx::shdfnd

- c -

  • countLeadingZeros() : physx::shdfnd

- d -

  • disableFPExceptions() : physx::shdfnd

- e -

  • enableFPExceptions() : physx::shdfnd
  • exportArray() : physx::shdfnd

- f -

  • floatFloor() : physx::shdfnd

- g -

  • getAllocator() : physx::shdfnd
  • getErrorCallback() : physx::shdfnd
  • getInitializationCount() : physx::shdfnd
  • getProfilerCallback() : physx::shdfnd
  • getReflectionAllocatorReportsNames() : physx::shdfnd

- h -

  • hash() : physx::shdfnd
  • highestSetBit() : physx::shdfnd
  • highestSetBitUnsafe() : physx::shdfnd

- i -

  • ilog2() : physx::shdfnd
  • importArray() : physx::shdfnd
  • initializeNamedAllocatorGlobals() : physx::shdfnd
  • initializeSharedFoundation() : physx::shdfnd
  • initializeTempAllocatorGlobals() : physx::shdfnd
  • isPowerOfTwo() : physx::shdfnd

- l -

  • lowestSetBit() : physx::shdfnd
  • lowestSetBitUnsafe() : physx::shdfnd

- m -

  • median3() : physx::shdfnd::internal
  • memoryBarrier() : physx::shdfnd

- n -

  • nextPowerOfTwo() : physx::shdfnd

- p -

  • partition() : physx::shdfnd::internal
  • pointerOffset() : physx::shdfnd
  • prefetch() : physx::shdfnd
  • prefetchLine() : physx::shdfnd
  • printFormatted() : physx::shdfnd
  • printString() : physx::shdfnd
  • PxGetAssertHandler() : physx
  • PxSetAssertHandler() : physx

- r -

  • recipFast() : physx::shdfnd
  • recipSqrtFast() : physx::shdfnd

- s -

  • setProfilerCallback() : physx::shdfnd
  • setReflectionAllocatorReportsNames() : physx::shdfnd
  • sharedFoundationIsInitialized() : physx::shdfnd
  • smallSort() : physx::shdfnd::internal
  • snprintf() : physx::shdfnd
  • sort() : physx::shdfnd
  • sscanf() : physx::shdfnd
  • strcmp() : physx::shdfnd
  • stricmp() : physx::shdfnd
  • strlcat() : physx::shdfnd
  • strlcpy() : physx::shdfnd
  • strlwr() : physx::shdfnd
  • strncmp() : physx::shdfnd
  • strnicmp() : physx::shdfnd
  • strupr() : physx::shdfnd
  • swap() : physx::shdfnd

- t -

  • terminateNamedAllocatorGlobals() : physx::shdfnd
  • terminateSharedFoundation() : physx::shdfnd
  • terminateTempAllocatorGlobals() : physx::shdfnd
  • TlsAlloc() : physx::shdfnd
  • TlsFree() : physx::shdfnd
  • TlsGet() : physx::shdfnd
  • TlsSet() : physx::shdfnd

- v -

  • vsnprintf() : physx::shdfnd
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs

  • IntBool : physx::shdfnd
  • LPFN_GLPI : physx::shdfnd
  • Mutex : physx::shdfnd
  • SList : physx::shdfnd
  • Sync : physx::shdfnd
  • Thread : physx::shdfnd
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Class Members

  • Namespace List
  • Namespace Members
  • All
  • Functions
  • Variables
  • Typedefs

  • gAllocatorCallback : physx::shdfnd
  • gErrorCallback : physx::shdfnd
  • gInitializationCount : physx::shdfnd
  • gProfilerCallback : physx::shdfnd
Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::AllocatorTraits< T > Member List

This is the complete list of members for physx::shdfnd::AllocatorTraits< T >, including all inherited members.

Type typedef physx::shdfnd::AllocatorTraits< T >

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::CounterFrequencyToTensOfNanos Member List

This is the complete list of members for physx::shdfnd::CounterFrequencyToTensOfNanos, including all inherited members.

CounterFrequencyToTensOfNanos(uint64_t inNum, uint64_t inDenom) | physx::shdfnd::CounterFrequencyToTensOfNanos | [inline]
mDenominator | physx::shdfnd::CounterFrequencyToTensOfNanos |
mNumerator | physx::shdfnd::CounterFrequencyToTensOfNanos |
toTensOfNanos(uint64_t inCounter) const | physx::shdfnd::CounterFrequencyToTensOfNanos | [inline]

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Equal< A > Member List

This is the complete list of members for physx::shdfnd::Equal< A >, including all inherited members.

operator()(const A &a, const A &b) const physx::shdfnd::Equal< A > [inline]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Greater< A > Member List

This is the complete list of members for physx::shdfnd::Greater< A >, including all inherited members.

operator()(const A &a, const A &b) const physx::shdfnd::Greater< A > [inline]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Hash< Key > Member List

This is the complete list of members for physx::shdfnd::Hash< Key >, including all inherited members.

equal(const Key &k0, const Key &k1) const | physx::shdfnd::Hash< Key > | [inline]
operator()(const Key &k) const | physx::shdfnd::Hash< Key > | [inline]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Hash< const char * > Member List

This is the complete list of members for physx::shdfnd::Hash< const char * >, including all inherited members.

equal(const char *string0, const char *string1) const | physx::shdfnd::Hash< const char * > | [inline]
operator()(const char *_string) const | physx::shdfnd::Hash< const char * > | [inline]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::Less< A > Member List

This is the complete list of members for physx::shdfnd::Less< A >, including all inherited members.

operator()(const A &a, const A &b) const physx::shdfnd::Less< A > [inline]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::LogTwo< A > Member List

This is the complete list of members for physx::shdfnd::LogTwo< A >, including all inherited members.

value physx::shdfnd::LogTwo< A > [static]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::LogTwo< 1 > Member List

This is the complete list of members for physx::shdfnd::LogTwo< 1 >, including all inherited members.

value physx::shdfnd::LogTwo< 1 > [static]

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList Member List

This is the complete list of members for physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList, including all inherited members.

mNext physx::shdfnd::PoolBase< T, Alloc >::PoolBase::FreeList

Generated on Tue Jul 28 14:21:59 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::SListImpl Member List

This is the complete list of members for physx::shdfnd::SListImpl, including all inherited members.

flush() | physx::shdfnd::SListImpl |
getSize() | physx::shdfnd::SListImpl | [static]
pop() | physx::shdfnd::SListImpl |
push(SListEntry *entry) | physx::shdfnd::SListImpl |
SListImpl() | physx::shdfnd::SListImpl |
~SListImpl() | physx::shdfnd::SListImpl |

Generated on Tue Jul 28 14:22:00 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::ThreadPriority Member List

This is the complete list of members for physx::shdfnd::ThreadPriority, including all inherited members.

eABOVE_NORMAL enum value | physx::shdfnd::ThreadPriority
eBELOW_NORMAL enum value | physx::shdfnd::ThreadPriority
eFORCE_DWORD enum value | physx::shdfnd::ThreadPriority
eHIGH enum value | physx::shdfnd::ThreadPriority
eLOW enum value | physx::shdfnd::ThreadPriority
eNORMAL enum value | physx::shdfnd::ThreadPriority
Enum enum name | physx::shdfnd::ThreadPriority

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::UnConst< T > Member List

This is the complete list of members for physx::shdfnd::UnConst< T >, including all inherited members.

Type typedef physx::shdfnd::UnConst< T >

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::UnConst< const T > Member List

This is the complete list of members for physx::shdfnd::UnConst< const T >, including all inherited members.

Type typedef physx::shdfnd::UnConst< const T >

Generated on Tue Jul 28 14:21:57 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey Member List

This is the complete list of members for physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey, including all inherited members.

operator()(const Entry &e) physx::shdfnd::internal::HashMapBase< Key, Value, HashFn, Allocator >::HashMapBase::GetKey [inline]

Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey Member List

This is the complete list of members for physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey, including all inherited members.

operator()(const Key &e) physx::shdfnd::internal::HashSetBase< Key, HashFn, Allocator, Coalesced >::HashSetBase::GetKey [inline]

Generated on Tue Jul 28 14:22:03 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::EnableIfPod< T, X > Member List

This is the complete list of members for physx::shdfnd::EnableIfPod< T, X >, including all inherited members.

i | physx::shdfnd::EnableIfPod< T, X >
t | physx::shdfnd::EnableIfPod< T, X >
Type typedef | physx::shdfnd::EnableIfPod< T, X >

Generated on Tue Jul 28 14:21:56 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8


NVIDIA(R) PsFoundation Reference: Member List

physx::shdfnd::TempAllocatorChunk Member List

This is the complete list of members for physx::shdfnd::TempAllocatorChunk, including all inherited members.

mIndex | physx::shdfnd::TempAllocatorChunk |
mNext | physx::shdfnd::TempAllocatorChunk |
mPad | physx::shdfnd::TempAllocatorChunk |
TempAllocatorChunk() | physx::shdfnd::TempAllocatorChunk | [inline]

Generated on Tue Jul 28 14:22:01 2015 for NVIDIA(R) PsFoundation Reference by doxygen 1.5.8