|
From: <and...@us...> - 2008-11-14 07:22:28
|
Revision: 792
http://python-ogre.svn.sourceforge.net/python-ogre/?rev=792&view=rev
Author: andy_miller
Date: 2008-11-14 07:22:21 +0000 (Fri, 14 Nov 2008)
Log Message:
-----------
Adding tweaked NxOfre 0.22T5 header files
Added Paths:
-----------
trunk/python-ogre/ThirdParty/nxogre/BetajaenCC.h
trunk/python-ogre/ThirdParty/nxogre/BetajaenSL.h
trunk/python-ogre/ThirdParty/nxogre/BetajaenVE.h
trunk/python-ogre/ThirdParty/nxogre/NxOgre.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreActor.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreActors.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreAllocator.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreAnimatedRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreBody.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreBodyFactory.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreCharacter.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreCharacterController.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreCharacterModel.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreCharacterMovementModel.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreCloth.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreClothRaycaster.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreCompoundActor.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreConfig.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreContactCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreContactStream.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreContainer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreDebugRenderer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreDeletionCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreDominanceGroup.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreDualIdentifier.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreEffectsSystem.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreEngine.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreError.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreExtendedTypes.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreFileResource.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreFileResourceManager.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreFluid.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreForceField.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreGroup.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreHeightfield.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreHelpers.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreIntersection.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreJoint.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreJointCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreJointSet1.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreJointSet2.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreKinematicCharacter.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreKinematicCharacterSweep.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreLog.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMachine.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreManualHeightfield.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreManualMesh.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreManualMeshUtil.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMaterial.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMaterialAlias.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMemoryResource.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMemoryResourceManager.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMesh.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMeshParams.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreMeshRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreNodeRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreNxActorController.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreOgreMeshRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreOgreNodeRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreOgreSceneRenderer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreOgreTimeController.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreParams.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreParticleSystem.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePerformer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePhysXDriver.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePlatform.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePose.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePrerequisites.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePrerequisitesOgre.h
trunk/python-ogre/ThirdParty/nxogre/NxOgrePrototype.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreRaycaster.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreRemoteDebuggerConnection.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreRenderableActorFactory.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreRenderableSource.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreResource.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreResourceCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreResourceManager.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreResourceSystem.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreScene.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSceneController.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSceneParams.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSceneRenderer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSceneSource.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSceneTriggerController.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreShape.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreShapeMeshes.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreShapePrimitives.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreShapeTerrain.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreShapeWheel.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSheet.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSimpleActor.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSimpleShape.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSkeletalRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSkeleton.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSleepCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSoftBody.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreSpriteRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreStable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTesting.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTimeController.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTimeStep.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTimer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTrigger.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTriggerCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreTriggerFunction.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreUserAllocator.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreVoidPointer.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreVoxelRenderable.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreWheelContactCallback.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreWheelSet.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreWhen.h
trunk/python-ogre/ThirdParty/nxogre/NxOgreWorld.h
Added: trunk/python-ogre/ThirdParty/nxogre/BetajaenCC.h
===================================================================
--- trunk/python-ogre/ThirdParty/nxogre/BetajaenCC.h (rev 0)
+++ trunk/python-ogre/ThirdParty/nxogre/BetajaenCC.h 2008-11-14 07:22:21 UTC (rev 792)
@@ -0,0 +1,33 @@
+/*
+
+Betajaen's Container Classes
+
+Copyright (c) 2007 Robin Southern, http://www.nxogre.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+#ifndef BETAJAENS_CC_H
+#define BETAJAENS_CC_H
+
+#include "BetajaenSL.h"
+#include "BetajaenVE.h"
+
+#endif
Added: trunk/python-ogre/ThirdParty/nxogre/BetajaenSL.h
===================================================================
--- trunk/python-ogre/ThirdParty/nxogre/BetajaenSL.h (rev 0)
+++ trunk/python-ogre/ThirdParty/nxogre/BetajaenSL.h 2008-11-14 07:22:21 UTC (rev 792)
@@ -0,0 +1,1047 @@
+/*
+
+Betajaen's SharedList
+
+Copyright (c) 2007 Robin Southern, http://www.nxogre.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+#ifndef BETAJAENS_SL_H
+#define BETAJAENS_SL_H
+
+#include <cstdlib>
+#include "NxOgrePlatform.h"
+#include "NxOgreAllocator.h"
+
+// Configuration
+
+/** \brief Namespace to place the Containers in. Comment out if you want it in the global namespace.
+*/
+#define BETAJAEN_SL_NAMESPACE Betajaen
+
+
+/** \brief Export Class Macro, replace value with your export macro
+*/
+#define BETAJAEN_SL_CLASS __declspec(dllexport)
+#define BETAJAEN_SL_CLASS_FUNCTION
+#define BETAJAEN_SL_TEMPLATE_CLASS
+#define BETAJAEN_SL_TEMPLATE_CLASS_FUNCTION __forceinline
+#define BETAJAEN_SL_CLASS_EXPORT __declspec(dllexport)
+#define BETAJAEN_SL_TEMPLATE_CLASS_EXPORT __forceinline
+// __declspec(dllexport)
+
+/** \brief Delete macro. Used if you have your own leak checker, etc.
+*/
+// #define BETAJAEN_SL_DELETE(ptr) \
+// {::NxOgre::Allocator::getPtr()->watch_delete(static_cast<void*>(ptr));}; \
+// delete ptr;
+//
+// /** \brief Called just before when a class is destroyed using it's destructor.
+// */
+// #define BETAJAEN_SL_DESTRUCTOR(ptr) \
+// ::NxOgre::Allocator::getPtr()->watch_delete(begin);
+
+//////////////////////////////////////////////////////////////////////////
+
+#ifdef BETAJAEN_SL_NAMESPACE
+# define BETAJAEN_SL_NAMESPACE_START namespace BETAJAEN_SL_NAMESPACE {
+# define BETAJAEN_SL_NAMESPACE_END }
+#else
+# define BETAJAEN_SL_NAMESPACE_START /**/
+# define BETAJAEN_SL_NAMESPACE_END /**/
+#endif
+
+BETAJAEN_SL_NAMESPACE_START
+
+#if (_MSC_VER>=1000)
+# define BETAJAEN_SL_INLINE __forceinline
+#else
+# define BETAJAEN_SL_INLINE inline
+#endif
+
+#ifndef BETAJAEN_SL_CLASS
+# define BETAJAEN_SL_CLASS
+#endif
+
+#ifndef BETAJAEN_SL_TEMPLATE_CLASS
+# define BETAJAEN_SL_TEMPLATE_CLASS
+#endif
+
+#ifndef BETAJAEN_SL_TEMPLATE_CLASS_FUNCTION
+# define BETAJAEN_SL_TEMPLATE_CLASS_FUNCTION
+#endif
+
+#ifndef BETAJAEN_SL_DELETE
+# define BETAJAEN_SL_DELETE(ptr) delete ptr;
+#endif
+
+#ifndef BETAJAEN_SL_DESTRUCTOR
+# define BETAJAEN_SL_DESTRUCTOR(ptr)
+#endif
+
+BETAJAEN_SL_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_NAMESPACE_START
+
+class SharedAllocator;
+template <class TypePtr, class AllocatorType = SharedAllocator> class Flat;
+template <class BaseType, class AllocatorType = SharedAllocator> class Array;
+template <class BaseType, class AllocatorType = SharedAllocator> class SharedList;
+
+BETAJAEN_SL_NAMESPACE_END
+
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_NAMESPACE_START
+
+class BETAJAEN_SL_CLASS_EXPORT SharedAllocator {
+
+public:
+
+/////////////////////////////////////////////////////////////
+
+void* Allocate(size_t size)
+{
+ return malloc(size);
+}
+
+/////////////////////////////////////////////////////////////
+
+void Deallocate(void* mem)
+{
+ if (mem)
+ free(mem);
+}
+
+/////////////////////////////////////////////////////////////
+
+void* Reallocate(void* mem, size_t size)
+{
+ return realloc(mem, size);
+}
+
+/////////////////////////////////////////////////////////////
+
+void Copy(void* dest, void* src, size_t length)
+{
+ char* d = (char*) dest;
+ const char* s = (const char*) src;
+
+ while(length-- != 0)
+ *d++ = *s++;
+}
+
+}; // End of the SharedAllocator class.
+
+BETAJAEN_SL_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_NAMESPACE_START
+
+template
+ <
+ class Type,
+ class AllocatorType
+ >
+class BETAJAEN_SL_CLASS_EXPORT Flat
+{
+
+public:
+
+typedef Type * Iterator;
+typedef AllocatorType* AllocatorPtr;
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE Flat(AllocatorPtr allocator, bool deleteAllocator)
+ : First(NULL), Last(NULL), End(NULL), Allocator(allocator), AutoDeleteAllocator(deleteAllocator)
+{
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE ~Flat()
+{
+ _deallocate(First);
+ if (AutoDeleteAllocator)
+ delete Allocator;
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE unsigned int _size() const
+{
+ return (unsigned int) (Last - First);
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE unsigned int _capacity() const
+{
+ return (unsigned int) (First == 0 ? 0 : End - First);
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE Type* _allocate(unsigned int size)
+{
+ return (Type*) Allocator->Allocate(size * sizeof(Type));
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE void _deallocate(Type* p)
+{
+ if (p)
+ Allocator->Deallocate(p);
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE Iterator _reallocate(Iterator p, unsigned int size)
+{
+ return (Iterator) Allocator->Reallocate(p, size * sizeof(Type));
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE void _clip(unsigned int size)
+{
+
+ if (size < _size())
+ return;
+
+ Iterator new_first = _allocate(size);
+ _copy(First, Last, new_first);
+ _destroy(First, Last);
+ _deallocate(First);
+ End = new_first + size;
+ Last = new_first + _size();
+ First = new_first;
+
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE void _reserve(unsigned int new_size)
+{
+ if (_capacity() >= new_size)
+ return;
+
+ Iterator new_first = _allocate(new_size);
+ _copy(First, Last, new_first);
+ _destroy(First, Last);
+ _deallocate(First);
+ End = new_first + new_size;
+ Last = new_first + _size();
+ First = new_first;
+
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE Iterator _copy(Iterator begin, Iterator end, Iterator dest)
+{
+ for (;begin != end; ++dest, ++begin)
+ *dest = *begin;
+ return dest;
+}
+
+/////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_INLINE void _destroy(Iterator begin, Iterator end)
+{
+ for (; begin != end; ++begin) {
+ BETAJAEN_SL_DESTRUCTOR(begin)
+ begin->~Type();
+ }
+}
+
+/////////////////////////////////////////////////////////////
+
+public: BETAJAEN_SL_INLINE void _delete_range(Iterator begin, Iterator end)
+{
+ for (; begin != end; ++begin) {
+ BETAJAEN_SL_DELETE(*begin);
+ }
+}
+
+protected: AllocatorPtr Allocator;
+protected: bool AutoDeleteAllocator;
+public: Iterator First, Last, End;
+
+}; // End of Flat<Type, AllocatorType> class.
+
+BETAJAEN_SL_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_NAMESPACE_START
+
+template
+ <
+ class Type, /* Class to Store; A, myClassName, etc. */
+ class AllocatorType /* Allocator to use, or leave blank for SharedAllocator */
+ >
+class BETAJAEN_SL_CLASS_EXPORT Array {
+
+public:
+
+typedef Type* TypePtr;
+typedef const Type* ConstTypePtr;
+typedef Array<Type, AllocatorType> ArrayType;
+typedef Flat<Type, AllocatorType> FlatType;
+typedef FlatType* FlatPtr;
+
+BETAJAEN_SL_INLINE Array(AllocatorType* _allocator = NULL, bool _auto_delete_allocator = true)
+{
+ if (_allocator == NULL)
+ _allocator = new AllocatorType();
+
+ _Flat = new FlatType(_allocator, _auto_delete_allocator);
+
+}
+
+BETAJAEN_SL_INLINE ~Array()
+{
+ delete _Flat;
+}
+
+BETAJAEN_SL_INLINE TypePtr getPtr()
+{
+ return _Flat->First;
+}
+
+BETAJAEN_SL_INLINE ConstTypePtr getConstPtr() const
+{
+ return _Flat->First;
+}
+
+BETAJAEN_SL_INLINE unsigned int Size()
+{
+ return _Flat->_size();
+}
+
+BETAJAEN_SL_INLINE void Append(Type v) {
+
+ if (_Flat->End <= _Flat->Last)
+ _Flat->_reserve( (1 + _Flat->_size()) * 2);
+
+ *_Flat->Last = v;
+ _Flat->Last++;
+
+}
+
+BETAJAEN_SL_INLINE void Append(Type v, size_t length)
+{
+ if (_Flat->End <= _Flat->Last + length)
+ _Flat->_reserve( length + (_Flat->_size() * 2));
+
+ memcpy(*_Flat->Last, v, length);
+ _Flat->Last += length;
+
+}
+
+BETAJAEN_SL_INLINE void Clip() {
+ _Flat->_clip(0);
+}
+
+private: FlatPtr _Flat;
+
+};
+
+BETAJAEN_SL_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_SL_NAMESPACE_START
+
+/** \brief A list of pointers with garbage collections and the ability to
+ share the same list with similar lists. Like STL's Vector.
+
+ \example
+ <code>
+ class A;
+
+ SharedList<A> aList;
+ a.Insert(new A());
+ a.Remove(a.Last);
+ </code>
+
+*/
+template
+ <
+ class Type, /* Class to Store; A, myClassName, etc. */
+ class AllocatorType /* Allocator to use, or leave blank for SharedAllocator */
+ >
+class BETAJAEN_SL_CLASS_EXPORT SharedList {
+
+public:
+
+typedef Type* TypePtr;
+typedef TypePtr* Iterator;
+typedef SharedList<Type, AllocatorType> SharedListType;
+typedef Flat<TypePtr, AllocatorType> FlatType;
+typedef FlatType* FlatPtr;
+
+/////////////////////////////////////////////////////////////
+
+enum AbsolutePosition
+{
+ First,
+ Last
+};
+
+
+/** \brief Iterator interface
+*/
+class BETAJAEN_SL_CLASS_EXPORT SharedListIterator {
+
+/** \brief Normal constructor
+*/
+public: BETAJAEN_SL_INLINE SharedListIterator(FlatPtr flat)
+: _Flat(flat), _Iterator(flat->First)
+{
+}
+
+/** \brief Copy constructor
+*/
+public: BETAJAEN_SL_INLINE SharedListIterator(const SharedListIterator& other)
+: _Flat(other._Flat), _Iterator(other._Flat->First)
+{
+}
+
+/** \brief Destructor
+*/
+public: BETAJAEN_SL_INLINE ~SharedListIterator()
+{
+}
+
+/** \brief First type in the SharedList without modifying the iterator
+*/
+public: BETAJAEN_SL_INLINE TypePtr FirstType() {
+ return _Flat->First;
+}
+
+/** \brief Last type in the SharedList without modifying the iterator
+*/
+public: BETAJAEN_SL_INLINE TypePtr LastType() {
+ return _Flat->Last;
+}
+
+/** \brief Places the Iterator at the beginning of the List
+*/
+public: BETAJAEN_SL_INLINE TypePtr Begin()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+
+ _Iterator = _Flat->First;
+ return *_Iterator;
+
+}
+
+
+/** \brief Advances the Iterator forward by one, and returns the value of the list or NULL
+ \returns The next item in the list, or NULL if it has reached the end of it.
+*/
+public: BETAJAEN_SL_INLINE TypePtr Next()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+ else if (_Iterator == _Flat->Last)
+ return NULL;
+ else
+ return (*_Iterator++);
+
+}
+
+
+/** \brief Places the iterator at the end of the List
+*/
+public: BETAJAEN_SL_INLINE TypePtr End()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+
+ _Iterator = _Flat->Last - 1;
+ return *_Iterator;
+
+}
+
+
+/** \brief Advances the Iterator backwards by one, and returns the value of the list or NULL
+ \returns The previous item in the list, or NULL if it has reached the beginning of it.
+*/
+public: BETAJAEN_SL_INLINE TypePtr Previous()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+ else if (_Iterator == _Flat->First - 1)
+ return NULL;
+ else
+ return (*_Iterator--);
+
+}
+
+/** \brief Returns the numbers of Type associcated to the flat with this iterator
+*/
+public: BETAJAEN_SL_INLINE unsigned int Size()
+{
+ return _Flat->_size();
+}
+
+protected: FlatPtr _Flat;
+protected: Iterator _Iterator;
+
+};
+
+/////////////////////////////////////////////////////////////////
+
+typedef SharedListIterator SharedListIteratorType;
+
+/** \brief Constructor with optional custom allocator
+*/
+BETAJAEN_SL_INLINE SharedList(AllocatorType* _allocator = NULL, bool _auto_delete_allocator = true)
+{
+ if (_allocator == NULL)
+ _allocator = new AllocatorType();
+
+ _Flat = new FlatType(_allocator, _auto_delete_allocator);
+ _Usage = new unsigned int(1);
+
+}
+
+/** \brief Copy Constructor between SharedList's. The Flat will not be copied but referenced.
+ Any action on this list will effect all lists using the same Flat. Clean up will only
+ happen on the destruction of the last surviving list.
+
+ \example
+ <code>
+ typedef SharedList<A> AList;
+ AList a;
+ AList b(a);
+ </code>
+*/
+BETAJAEN_SL_INLINE SharedList(const SharedListType& other)
+{
+
+ _Flat = other._Flat;
+ _Usage = other._Usage;
+ ++(*_Usage);
+
+}
+
+
+/** \brief Copy Operator. Functions the same as Copy Constructor but deletes the set that this
+ may already have.
+
+ \example
+ <code>
+ typedef SharedList<A> AList;
+ AList a;
+ AList b;
+ b = a;
+ </code>
+*/
+BETAJAEN_SL_INLINE SharedListType& operator=(const SharedListType& other)
+{
+
+ if (_Flat)
+ {
+ _Flat->_delete_range(_Flat->First, _Flat->Last);
+ delete _Flat;
+ }
+
+ if (_Usage)
+ delete _Usage;
+
+ _Flat = other._Flat;
+ _Usage = other._Usage;
+ ++(*_Usage);
+
+ return *this;
+
+}
+
+
+/** \brief Destructor. If this is the last of all SharedLists sharing the same set,
+ the set will be destroyed otherwise the Flat will be ignored and this SharedList
+ dies gracefully.
+*/
+BETAJAEN_SL_INLINE ~SharedList()
+{
+
+ if (--(*_Usage) == 0)
+ {
+ if (_Flat)
+ {
+ _Flat->_delete_range(_Flat->First, _Flat->Last);
+ delete _Flat;
+ delete _Usage;
+ }
+ }
+
+}
+
+
+/** \brief Gets the pointer to the nth Type in the list. Alternate interface to operator[].
+*/
+BETAJAEN_SL_INLINE TypePtr Get(size_t pos)
+{
+ if (pos > Size())
+ return NULL;
+
+ return *(_Flat->First + pos);
+}
+
+
+/** \brief Gets the pointer to the nth TypePtr in the list.
+*/
+BETAJAEN_SL_INLINE TypePtr operator[](size_t pos)
+{
+ if (pos > Size())
+ return NULL;
+
+ return *(_Flat->First + pos);
+}
+
+
+/** \brief Where is something in the list.
+*/
+BETAJAEN_SL_INLINE unsigned int WhereIs(TypePtr ptr)
+{
+
+ if (_Flat->_size() == 0)
+ return 0;
+
+ unsigned int i=0;
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin, ++i)
+ {
+ if (ptr == (*begin))
+ return i;
+ }
+
+ return 0;
+}
+
+BETAJAEN_SL_INLINE bool Has(TypePtr ptr)
+{
+
+ if (_Flat->_size() == 0)
+ return false;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ {
+ if (ptr == (*begin))
+ return true;
+ }
+
+ return false;
+
+}
+
+/** \brief The size of the SharedList.
+*/
+BETAJAEN_SL_INLINE unsigned Size() const
+{
+ return _Flat->_size();
+}
+
+
+/** \brief Insert something into the list
+*/
+BETAJAEN_SL_INLINE void Insert(const TypePtr& val)
+{
+
+ if (_Flat->End <= _Flat->Last)
+ _Flat->_reserve( (1 + Size()) * 2);
+
+ *_Flat->Last = val;
+ _Flat->Last++;
+
+}
+
+
+/** \brief Resize the capacity of the list to size + n.
+*/
+BETAJAEN_SL_INLINE void Clean(unsigned int n = 4)
+{
+ _Flat->_clip(_Flat->_size() + n);
+}
+
+
+/** \brief Destroy something nth position into the list.
+*/
+BETAJAEN_SL_INLINE void Destroy(unsigned int n)
+{
+ if (n == 0)
+ return Destroy(First);
+
+ if (n == Size())
+ return Destroy(Last);
+
+ delete *(_Flat->First + n);
+
+ _Flat->_destroy(_Flat->First + n, _Flat->First + n + 1);
+ _Flat->_copy(_Flat->First + n + 1, _Flat->Last, _Flat->First + n);
+ _Flat->Last--;
+
+}
+
+// \brief Destroys everything
+//
+BETAJAEN_SL_INLINE void DestroyAll()
+{
+ if (Size() == 0)
+ return;
+
+ _Flat->_delete_range(_Flat->First, _Flat->Last);
+ // Could be iffy.
+ _Flat->Last = _Flat->First;
+
+}
+
+/** \brief Destroys something in the list based on the pointer in the list.
+*/
+BETAJAEN_SL_INLINE void Destroy(TypePtr val) {
+ unsigned int i = WhereIs(val);
+ Destroy(i);
+}
+
+/** \brief Deletes something from the list based on AbsolutePosition
+*/
+BETAJAEN_SL_INLINE void Destroy(AbsolutePosition position)
+{
+
+ switch(position) {
+
+ case First:
+ {
+ delete *_Flat->First;
+ _Flat->_copy(_Flat->First + 1, _Flat->Last + 1, _Flat->First);
+ _Flat->Last--;
+ }
+ break;
+
+ case Last:
+ {
+ _Flat->Last--;
+ delete *_Flat->Last;
+ }
+ break;
+
+ }
+
+}
+
+
+/** \brief Removes something from the list based on numerical position.
+*/
+BETAJAEN_SL_INLINE TypePtr Remove(unsigned int n)
+{
+
+ if (n == 0)
+ return Remove(First);
+
+ if (n == Size())
+ return Remove(Last);
+
+ TypePtr ptr = Get(n);
+ _Flat->_destroy(_Flat->First + n, _Flat->First + n + 1);
+ _Flat->_copy(_Flat->First + n + 1, _Flat->Last, _Flat->First + n);
+ _Flat->Last--;
+
+ return ptr;
+}
+
+
+/** \brief Removes something from the list based on AbsolutePosition
+*/
+BETAJAEN_SL_INLINE TypePtr Remove(AbsolutePosition position)
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+
+ switch(position) {
+
+ case First:
+ {
+ TypePtr t = *(_Flat->First);
+ _Flat->_copy(_Flat->First + 1, _Flat->Last + 1, _Flat->First);
+ _Flat->Last--;
+ return t;
+ }
+
+ break;
+
+ case Last:
+ {
+ _Flat->Last--;
+ return *(_Flat->Last);
+ }
+ break;
+ }
+
+ return NULL;
+
+}
+
+// \brief Destroys everything
+//
+BETAJAEN_SL_INLINE void RemoveAll()
+{
+ if (Size() == 0)
+ return;
+
+ _Flat->_deallocate(_Flat->First);
+
+ // Could be iffy.
+ _Flat->Last = _Flat->First = _Flat->End = NULL;
+
+}
+
+
+/** \brief Places the Iterator at the beginning of the List
+*/
+BETAJAEN_SL_INLINE TypePtr Begin()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+
+ _Iterator = _Flat->First;
+ return *_Iterator;
+
+}
+
+
+/** \brief Advances the Iterator forward by one, and returns the value of the list or NULL
+ \returns The next item in the list, or NULL if it has reached the end of it.
+*/
+BETAJAEN_SL_INLINE TypePtr Next()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+ else if (_Iterator == _Flat->Last)
+ return NULL;
+ else
+ return (*_Iterator++);
+
+}
+
+
+/** \brief Places the iterator at the end of the List
+*/
+BETAJAEN_SL_INLINE TypePtr End()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+
+ _Iterator = _Flat->Last - 1;
+ return *_Iterator;
+
+}
+
+
+/** \brief Advances the Iterator backwards by one, and returns the value of the list or NULL
+ \returns The previous item in the list, or NULL if it has reached the beginning of it.
+*/
+BETAJAEN_SL_INLINE TypePtr Previous()
+{
+
+ if (_Flat->_size() == 0)
+ return NULL;
+ else if (_Iterator == _Flat->First - 1)
+ return NULL;
+ else
+ return (*_Iterator--);
+
+}
+
+/** \brief For each item in the list call it's own method.
+*/
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)()) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin) {
+ (*begin->*MethodPtr)();
+ }
+
+}
+
+
+/** \brief For each item in the list call it's own method, with one argument.
+*/
+template <typename _A>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A), _A _1) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin) {
+ (*begin->*MethodPtr)(_1);
+ }
+
+}
+
+
+/** \brief For each item in the list call it's own method, with two arguments.
+*/
+template <typename _A, typename _B>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B), _A _1, _B _2) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2);
+
+}
+
+
+/** \brief For each item in the list call it's own method, with three arguments.
+*/
+template <typename _A, typename _B, typename _C>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B, _C), _A _1, _B _2, _C _3) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2, _3);
+
+}
+
+
+/** \brief For each item in the list call it's own method, with four arguments.
+*/
+template <typename _A, typename _B, typename _C, typename _D>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B, _C, _D), _A _1, _B _2, _C _3, _D _4) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2, _3, _4);
+
+}
+
+
+/** \brief For each item in the list call it's own method, with five arguments.
+*/
+template <typename _A, typename _B, typename _C, typename _D, typename _E>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B, _C, _D), _A _1, _B _2, _C _3, _D _4, _E _5) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2, _3, _4, _5);
+
+}
+
+
+/** \brief For each item in the list call it's own method, with six arguments.
+*/
+template <typename _A, typename _B, typename _C, typename _D, typename _E, typename _F>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B, _C, _D), _A _1, _B _2, _C _3, _D _4, _E _5, _F _6) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2, _3, _4, _5, _6);
+
+}
+
+
+/** \brief For each item in the list call it's own method, with seven arguments.
+*/
+template <typename _A, typename _B, typename _C, typename _D, typename _E, typename _F, typename _G>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B, _C, _D), _A _1, _B _2, _C _3, _D _4, _E _5, _F _6, _G _7) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2, _3, _4, _5, _6, _7);
+
+}
+
+
+/** \brief For each item in the list call it's own method, with eight arguments.
+*/
+template <typename _A, typename _B, typename _C, typename _D, typename _E, typename _F, typename _G, typename _H>
+BETAJAEN_SL_INLINE void Each(void (Type::*MethodPtr)(_A, _B, _C, _D), _A _1, _B _2, _C _3, _D _4, _E _5, _F _6, _G _7, _H _8) {
+
+ if (_Flat->_size() == 0)
+ return;
+
+ for(Iterator begin = _Flat->First; begin != _Flat->Last; ++begin)
+ (*begin->*MethodPtr)(_1, _2, _3, _4, _5, _6, _7, _8);
+
+}
+
+/** \brief Returns the pointer to the working set.
+*/
+BETAJAEN_SL_INLINE FlatPtr getFlat() const {
+ return _Flat;
+}
+
+
+/** \brief Returns the number of SharedLists using this set.
+*/
+BETAJAEN_SL_INLINE unsigned int getUsageCount() const {
+ return *_Usage;
+}
+
+
+/** \brief Get an iterator interface for this (and siblings) SharedList
+*/
+BETAJAEN_SL_INLINE SharedListIteratorType getIterator() {
+ return SharedListIteratorType(_Flat);
+}
+
+private: unsigned int* _Usage;
+private: FlatPtr _Flat;
+private: Iterator _Iterator;
+
+}; // End of SharedList<Type, AllocatorType> Class.
+
+BETAJAEN_SL_NAMESPACE_END
+
+/////////////////////////////////////////////////////////////////
+
+#endif
Added: trunk/python-ogre/ThirdParty/nxogre/BetajaenVE.h
===================================================================
--- trunk/python-ogre/ThirdParty/nxogre/BetajaenVE.h (rev 0)
+++ trunk/python-ogre/ThirdParty/nxogre/BetajaenVE.h 2008-11-14 07:22:21 UTC (rev 792)
@@ -0,0 +1,326 @@
+/*
+
+Betajaen's Vector classes
+
+Copyright (c) 2007 Robin Southern, http://www.nxogre.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+#ifndef BETAJAENS_VE_H
+#define BETAJAENS_VE_H
+
+// Configuration
+
+/** \brief Namespace to place the Containers in. Comment out if you want it in the global namespace.
+*/
+#define BETAJAEN_VE_NAMESPACE Betajaen
+
+
+/** \brief Enable debug comments. Set to zero to disable, 1 to enable
+*/
+#define BETAJAEN_VE_DEBUG_COMMENTS 1
+
+
+/** \brief Export Class Macro, replace value with your export macro
+*/
+#define BETAJAEN_VE_CLASS __declspec(dllexport)
+#define BETAJAEN_VE_CLASS_FUNCTION
+#define BETAJAEN_VE_TEMPLATE_CLASS __declspec(dllexport)
+#define BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION __forceinline
+
+//////////////////////////////////////////////////////////////////////////
+
+#if (BETAJAEN_VE_DEBUG_COMMENTS == 1)
+# include <stdio.h>
+#endif
+
+#ifdef BETAJAEN_VE_NAMESPACE
+# define BETAJAEN_VE_NAMESPACE_START namespace BETAJAEN_VE_NAMESPACE {
+# define BETAJAEN_VE_NAMESPACE_END }
+#else
+# define BETAJAEN_VE_NAMESPACE_START /**/
+# define BETAJAEN_VE_NAMESPACE_END /**/
+#endif
+
+BETAJAEN_VE_NAMESPACE_START
+
+#if (_MSC_VER>=1000)
+# define BETAJAEN_VE_INLINE __forceinline
+#else
+# define BETAJAEN_VE_INLINE inline
+#endif
+
+#ifndef BETAJAEN_VE_CLASS
+# define BETAJAEN_VE_CLASS
+#endif
+
+#ifndef BETAJAEN_VE_TEMPLATE_CLASS
+# define BETAJAEN_VE_TEMPLATE_CLASS
+#endif
+
+#ifndef BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION
+# define BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION
+#endif
+
+#ifndef BETAJAEN_VE_DELETE
+# define BETAJAEN_VE_DELETE(ptr) delete ptr;
+#endif
+
+#ifndef BETAJAEN_VE_DESTRUCTOR
+# define BETAJAEN_VE_DESTRUCTOR(ptr)
+#endif
+
+BETAJAEN_VE_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_VE_NAMESPACE_START
+
+template <typename> class Vector2;
+template <typename> class Vector3;
+template <typename> class Vector4;
+
+BETAJAEN_VE_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_VE_NAMESPACE_START
+
+/** \brief Vector with two rows.
+*/
+template <
+ typename Type
+ >
+class BETAJAEN_VE_TEMPLATE_CLASS Vector2
+{
+
+public: typedef Vector2<Type> ThisType;
+
+/* \brief First */
+public: Type i;
+
+/* \brief Second */
+public: Type j;
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION Vector2()
+{
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION Vector2(Type _i, Type _j)
+: i(_i), j(_j)
+{
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION void swap(ThisType& other)
+{
+ Type First = i, Second = j;
+ i = other.i; other.i = First;
+ j = other.j; other.j = Second;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator = (const ThisType& other)
+{
+ i = other.i; j = other.j;
+ return *this;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator = (const Type& other)
+{
+ i = other; j = other;
+ return *this;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator *= (const Type& other)
+{
+ i *= other; j *= other;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator *= (const ThisType& other)
+{
+ i *= other.i; j *= other.j;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION bool operator == (const ThisType& other) const
+{
+ return (i == other.i && j == other.j);
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION bool operator != (const ThisType& other) const
+{
+ return (i != other.i || j != other.j);
+}
+
+};
+
+BETAJAEN_VE_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_VE_NAMESPACE_START
+
+/** \brief Vector with three rows.
+*/
+template <
+ typename Type
+ >
+class BETAJAEN_VE_TEMPLATE_CLASS Vector3
+{
+
+public: typedef Vector3<Type> ThisType;
+
+/* \brief First */
+public: Type i;
+
+/* \brief Second */
+public: Type j;
+
+/* \brief Third */
+public: Type k;
+
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION Vector3()
+{
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION Vector3(Type _i, Type _j, Type _k)
+: i(_i), j(_j), k(_k)
+{
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION void swap(ThisType& other)
+{
+ Type First = i, Second = j, Third = k;
+ i = other.i; other.i = First;
+ j = other.j; other.j = Second;
+ k = other.k; other.k = Third;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator = (const ThisType& other)
+{
+ i = other.i; j = other.j; k = other.k;
+ return *this;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator = (const Type& other)
+{
+ i = other; j = other; k = other;
+ return *this;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator *= (const Type& other)
+{
+ i *= other; j *= other; k *= other;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator *= (const ThisType& other)
+{
+ i *= other.i; j *= other.j; k *= other.k;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION bool operator == (const ThisType& other) const
+{
+ return (i == other.i && j == other.j && k == other.k);
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION bool operator != (const ThisType& other) const
+{
+ return (i != other.i || j != other.j || k != other.k);
+}
+
+}; // End of Vector3<Type> class.
+
+BETAJAEN_VE_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+BETAJAEN_VE_NAMESPACE_START
+
+/** \brief Vector with four rows.
+*/
+template <
+ typename Type
+ >
+class BETAJAEN_VE_TEMPLATE_CLASS Vector4 {
+
+public: typedef Vector4<Type> ThisType;
+
+/* \brief First */
+public: Type i;
+
+/* \brief Second */
+public: Type j;
+
+/* \brief Third */
+public: Type k;
+
+/* \brief Fourth */
+public: Type l;
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION Vector4()
+{
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION Vector4(Type _i, Type _j, Type _k, Type _l)
+: i(_i), j(_j), k(_k), l(_l)
+{
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION void swap(ThisType& other)
+{
+ Type First = i, Second = j, Third = k, Fourth = l;
+ i = other.i; other.i = First;
+ j = other.j; other.j = Second;
+ k = other.k; other.k = Third;
+ l = other.l; other.l = Fourth;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator = (const ThisType& other) {
+ i = other.i; j = other.j; k = other.k; l = other.l;
+ return *this;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator *= (const Type& other)
+{
+ i *= other; j *= other; k *= other; l *= other;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION ThisType& operator *= (const ThisType& other)
+{
+ i *= other.i; j *= other.j; k *= other.k; l *= other.l;
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION bool operator == (const ThisType& other) const
+{
+ return (i == other.i && j == other.j && k == other.k && l == other.l);
+}
+
+public: BETAJAEN_VE_TEMPLATE_CLASS_FUNCTION bool operator != (const ThisType& other) const
+{
+ return (i != other.i || j != other.j || k != other.k || l != other.l);
+}
+
+};
+
+BETAJAEN_VE_NAMESPACE_END
+
+//////////////////////////////////////////////////////////////////////////
+
+#endif
\ No newline at end of file
Added: trunk/python-ogre/ThirdParty/nxogre/NxOgre.h
===================================================================
--- trunk/python-ogre/ThirdParty/nxogre/NxOgre.h (rev 0)
+++ trunk/python-ogre/ThirdParty/nxogre/NxOgre.h 2008-11-14 07:22:21 UTC (rev 792)
@@ -0,0 +1,195 @@
+/** \file NxOgre.h
+ * \brief NxOgre in all it's splendid glory.
+ * \version 1.0-21
+ *
+ * \licence NxOgre a wrapper for the PhysX physics library.
+ * Copyright (C) 2005-8 Robin Southern of NxOgre.org http://www.nxogre.org
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef BLEEDING
+#define BLEEDING
+
+#include "NxOgreActor.h"
+#include "NxOgreActors.h"
+#include "NxOgreAllocator.h"
+#include "NxOgreAnimatedRenderable.h"
+#include "NxOgreBody.h"
+#include "NxOgreCharacter.h"
+#include "NxOgreCharacterController.h"
+#include "NxOgreCharacterModel.h"
+#include "NxOgreCharacterMovementModel.h"
+#include "NxOgreCloth.h"
+#include "NxOgreClothRaycaster.h"
+#include "NxOgreCompoundActor.h"
+#include "NxOgreConfig.h"
+#include "NxOgreContactCallback.h"
+#include "NxOgreContactStream.h"
+#include "NxOgreContainer.h"
+#include "NxOgreDebugRenderer.h"
+#include "NxOgreDeletionCallback.h"
+#include "NxOgreDominanceGroup.h"
+#include "NxOgreDualIdentifier.h"
+#include "NxOgreEffectsSystem.h"
+#include "NxOgreEngine.h"
+#include "NxOgreError.h"
+#include "NxOgreExtendedTypes.h"
+#include "NxOgreFileResource.h"
+#include "NxOgreFileResourceManager.h"
+#include "NxOgreFluid.h"
+#include "NxOgreForceField.h"
+#include "NxOgreGroup.h"
+#include "NxOgreHeightfield.h"
+#include "NxOgreHelpers.h"
+#include "NxOgreIntersection.h"
+#include "NxOgreJoint.h"
+#include "NxOgreJointCallback.h"
+#include "NxOgreJointSet1.h"
+#include "NxOgreJointSet2.h"
+#include "NxOgreKinematicCharacter.h"
+#include "NxOgreKinematicCharacterSweep.h"
+#include "NxOgreLog.h"
+#include "NxOgreMachine.h"
+#include "NxOgreManualHeightfield.h"
+#include "NxOgreManualMesh.h"
+#include "NxOgreManualMeshUtil.h"
+#include "NxOgreMaterial.h"
+#include "NxOgreMaterialAlias.h"
+#include "NxOgreMemoryResource.h"
+#include "NxOgreMemoryResourceManager.h"
+#include "NxOgreMesh.h"
+#include "NxOgreMeshParams.h"
+#include "NxOgreMeshRenderable.h"
+#include "NxOgreNodeRenderable.h"
+#include "NxOgreNxActorController.h"
+#include "NxOgreOgreMeshRenderable.h"
+#include "NxOgreOgreNodeRenderable.h"
+#include "NxOgreOgreSceneRenderer.h"
+#include "NxOgreOgreTimeController.h"
+#include "NxOgreParams.h"
+#include "NxOgreParticleSystem.h"
+#include "NxOgrePerformer.h"
+#include "NxOgrePhysXDriver.h"
+#include "NxOgrePlatform.h"
+#include "NxOgrePose.h"
+#include "NxOgrePrerequisites.h"
+#include "NxOgrePrerequisitesOgre.h"
+#include "NxOgreRaycaster.h"
+#include "NxOgreRemoteDebuggerConnection.h"
+#include "NxOgreRenderable.h"
+#include "NxOgreRenderableSource.h"
+#include "NxOgreResource.h"
+#include "NxOgreResourceCallback.h"
+#include "NxOgreResourceManager.h"
+#include "NxOgreResourceSystem.h"
+#include "NxOgreScene.h"
+#include "NxOgreSceneController.h"
+#include "NxOgreSceneRenderer.h"
+#include "NxOgreSceneSource.h"
+#include "NxOgreSceneTriggerController.h"
+#include "NxOgreShape.h"
+#include "NxOgreShapeMeshes.h"
+#include "NxOgreShapePrimitives.h"
+#include "NxOgreShapeTerrain.h"
+#include "NxOgreShapeWheel.h"
+#include "NxOgreSheet.h"
+#include "NxOgreSimpleActor.h"
+#include "NxOgreSimpleShape.h"
+#include "NxOgreSkeletalRenderable.h"
+#include "NxOgreSkeleton.h"
+#include "NxOgreSleepCallback.h"
+#include "NxOgreSoftBody.h"
+#include "NxOgreSpriteRenderable.h"
+#include "NxOgreStable.h"
+#include "NxOgreTesting.h"
+#include "NxOgreTimeController.h"
+#include "NxOgreTimer.h"
+#include "NxOgreTrigger.h"
+#include "NxOgreTriggerCallback.h"
+#include "NxOgreTriggerFunction.h"
+#include "NxOgreUserAllocator.h"
+#include "NxOgreVoidPointer.h"
+#include "NxOgreVoxelRenderable.h"
+#include "NxOgreWheelSet.h"
+#include "NxOgreWhen.h"
+#include "NxOgreWorld.h"
+
+#include "BetajaenCC.h"
+
+/** \mainpage NxOgre
+ \section licence Licence
+
+ <pre>
+ NxOgre a wrapper for the PhysX (formerly Novodex) physics library and the Ogre 3D rendering engine.
+ Copyright (C) 2005 - 2007 Robin Southern and NxOgre.org http://www.nxogre.org
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ </pre>
+
+ @section whatisit What is it?
+ NxOgre is a physics connector library between the physics library PhysX and the Ogre 3D rendering system.
+ With a help of some short, fast and neat code you can have a quick physics system within your Ogre game
+ or engine within a matter of minutes.
+
+ @section installing Installing
+ @subsection Ogre
+
+ The SDK or Source versions will both work with NxOgre. You should have some knowledege with working Ogre.
+ If you can make a simple application that can show an Ogre head with a movement camera, you can work with
+ NxOgre.
+ \n\n
+ You will need to create an environmental variable called "OGRE_HOME" pointing to the ogremain directory
+ in your Ogre folder. Normally for SDK users this is automatically created by the installer, but it's work
+ checking, if you installed Ogre from the source you'll need to create one.
+
+ [1] http://www.ogre3d.org/wiki/index.php/Installing_An_SDK \n
+ [2] http://www.ogre3d.org/wiki/index.php/Building_From_Source \n
+
+ @subsection PhysX
+ The PhysX SDK can be downloaded from the Ageia Support Center, a user account is required to download the
+ SDK. Once your account has been registered (Accounts are processed by hand, so a wait of 1-2 business days
+ is common), download the PhysX SDK and the SystemSoftware.
+ \n\n
+ Install the SystemSoftware first, then the PhysX SDK. I recommend you install the PhysX SDK in the same
+ parent directory as Ogre. Once the installation is completed, create a Environmental variable called
+ "<code>PHYSX_DIR</code>" pointing to the PhysX SDK directory.
+ \n\n
+ [3] http://devsupport.ageia.com/ \n
+
+ @subsection NxOgre
+ - Create a "NxOgre" folder, it should be in the parent of your Ogre or nearby
+ - Using Tortoise SVN or another Subversion client checkout the HEAD repositry
+ - Go to the parent directory of Ogre and the PhysX SDK i.e. (c:/dev/)
+ - New Folder, name as NxOgre, and go inside
+ - File, SVN, SVN Checkout
+ - Set the URL to http://svn.nxogre.org/branches/1,0/
+ - Click okay
+ - Open up the project and compile.
+
+*/
+
+#endif
Added: trunk/python-ogre/ThirdParty/nxogre/NxOgreActor.h
===================================================================
--- trunk/python-ogre/ThirdParty/nxogre/NxOgreActor.h (rev 0)
+++ trunk/python-ogre/ThirdParty/nxogre/NxOgreActor.h 2008-11-14 07:22:21 UTC (rev 792)
@@ -0,0 +1,1404 @@
+/** \file NxOgreActor.h
+* \brief Header for the ActorParams and Actor classes.
+* \version 1.0-21
+*
+* \licence NxOgre a wrapper for the PhysX physics library.
+* Copyright (C) 2005-8 Robin Southern of NxOgre.org http://www.nxogre.org
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef __NXOGRE_ACTOR_H__
+#define __NXOGRE_ACTOR_H__
+
+#include "NxOgrePrerequisites.h"
+#include "NxOgreContainer.h" // For: mCollisionList
+#include "NxOgreParams.h"
+#include "NxOgrePose.h"
+#include "BetajaenCC.h"
+#include "NxOgreShape.h" // For: SharedList<Shape>
+
+namespace NxOgre {
+
+/** \brief ActorParams are a way to give arguments to an Actor's constructor in any order and with arguments
+ omitted. Params can be given in a string format or passed along as a class reference.
+ \example
+ Simple ActorParams are created normally, each member variable is automatically given a default value
+ and at any time can be passed onto an Actor's constructor.
+ <code>
+ ActorParams params;
+ params.mMass = 10;
+ mScene->createActor(..., params);
+ </code>
+ To make your code more readable and understandble, in most cases where the params are considered "light"
+ you can use a string variation instead.
+ <code>
+ mScene->createActor(...., "mass: 10");
+ </code>
+ To know the string param name from the member variable name; it follows a simple rule.
+ "Camel case is broken up by dashes, then lowercase and drop the "m" prefix".
+ - mMass = mass
+ - mAngularVelocity = angular-velocity
+ - mInternalThreadCount = internal-thread-count
+*/
+class NxPublicClass ActorParams : public Params {
+
+public:
+
+ /** \brief Default Actorparams constructor, which makes every "param" it's default value.
+ */
+ ActorParams();
+
+ /** \brief Alternative constructor for strings. Before the string is parsed, each param is given
+ it's default value, so every param doesn't have to be included.
+ */
+ ActorParams(const char* p);
+
+ /** \brief Alternative constructor for strings. Before the string is parsed, each param is given
+ it's default value, so every param doesn't have to be included.
+ */
+ ActorParams(NxString p);
+
+ /** \brief Set's the Params to default based on NxActorDesc, NxBodyDesc defaults and NxOgre policy.
+ \note Not necessary to use after a constructor, as the constructor already calls this.
+ */
+ void setToDefault();
+
+ /** \brief Tell's you if the Params have valid values.
+ */
+ bool isValid() const;
+
+ /** \brief ActorFlags is a simple class wrapper for the NxActorFlags enum.
+ */
+ struct NxPublicClass ActorFlags : Flags {
+
+ friend class ActorParams;
+
+ public:
+
+ /** \brief Normal constructor.
+ */
+ ActorFlags();
+
+ /** \brief Alternate way of adding a flag using the NxBodyFlag enum.
+ \example
+ params.mFlags += NX_BF_KINEMATIC;
+ */
+ void operator+=(NxActorFlag);
+
+ /** \brief Alternate way of removing a flag using the NxBodyFlag enum.
+ \example
+ params.mFlags -= NX_BF_KINEMATIC;
+ */
+ void operator-=(NxActorFlag);
+
+ /** \brief Disable collision detection
+ \default false
+ \see NX_AF_DISABLE_COLLISION
+ \example
+ String variations => +disable-collision, +ghost
+ */
+ bool mDisableCollision;
+
+ /** \brief Disable collision response
+ \default false
+ \see NX_AF_DISABLE_RESPONSE
+ \example
+ String variations => +disable-response, +silent
+ */
+ bool mDisableResponse;
+
+ /** \brief Disables COM update when computing inertial properties at creation time.
+ \default false
+ \see NX_AF_LOCK_COM
+ \example
+ String variations => +lock-com
+ */
+ bool mLockCOM;
+
+ /** \brief Disable collision with fluids.
+ \default false
+ \see NX_AF_FLUID_DISABLE_COLLISION
+ \example
+ String variations => +disable-fluid-collision, +no-fluids
+ */
+ bool mDisableFluidCollision;
+
+ /** \brief Turn on contact modification callback for the actor.
+ \default false
+ \see NX_AF_CONTACT_MODIFICATION, ContactModifier
+ \example
+ String variations => +contact-modification, +con-mod
+ */
+ bool mContactModification;
+
+ /** \brief Force cone friction to be used for this actor.
+ \default false
+ \see NX_AF_FORCE_CONE_FRICTION
+ \example
+ String variations => +force-cone-friction, +fcf
+ */
+ bool mForceConeFriction;
+
+ /** \brief Enable custom contact filtering
+ \default false
+ \see NX_AF_USER_ACTOR_PAIR_FILTERING
+ \example
+ String variations => +actor-pair-filtering, +apf
+ */
+ bool mActorPairFiltering;
+
+ /** \brief Set the flags to their default state, according to the NxBodyDesc::setToDefault method.
+ */
+ void setToDefault();
+
+ /** \internal
+ */
+ void fromNxU32(NxU32);
+
+ /** \internal
+ */
+ NxU32 toNxU32() const;
+
+ protected:
+
+ /** \internal
+ */
+ void parse(const NxString&);
+
+ };
+
+
+ struct NxPublicClass BodyFlags : Flags {
+
+ friend class ActorParams;
+
+ public:
+
+ BodyFlags();
+
+ /** \brief Alternate way of adding a flag using the NxBodyFlag enum.
+ \example
+ params.mFlags += NX_BF_KINEMATIC;
+ */
+ void operator+=(NxBodyFlag);
+
+ /** \brief Alternate way of removing a flag using the NxBodyFlag enum.
+ \example
+ params.mFlags -= NX_BF_KINEMATIC;
+ */
+ void operator-=(NxBodyFlag);
+
+ /** \brief Set if gravity should not be applied on this body
+ \default false
+ \see NX_BF_DISABLE_GRAVITY
+ \example
+ String variations => +disable-gravity, +0g
+ */
+ bool mDisableGravity;
+
+ /** \brief Enables kinematic mode for the actor.
+ \default false
+ \see NX_BF_KINEMATIC
+ \example
+ String variations => +kinematic, +km
+ */
+ bool mIsKinematic;
+
+ /** \brief Enable debug renderer for this body.
+ \default
+ \see NX_BF_VISUALIZATION
+ \example
+ String variations => +debug-visualisation, +dv
+ */
+ bool mHasDebugVisualisation;
+
+ /** \brief Filter velocities used keep body awake. The filter reduces rapid oscillations and transient spikes.
+ \default false
+ \see NX_BF_FILTER_SLEEP_VEL
+ \example
+ String variations => +filter-sleep-velocity, +fsv
+ */
+ bool mFilterSleepVelocity;
+
+ /** \brief Enables energy-based sleeping algorithm.
+ \default true
+ \see NX_BF_ENERGY_SLEEP_TEST
+ \example
+ String variations => +energy-sleep-test, +est
+ */
+ bool mEnergySleepTest;
+
+ /** \brief Set the flags to their default state, according to the NxBodyDesc::setToDefault method.
+ mDisableGravity = false;
+ mIsKinematic = false;
+ mDebugVisualisation = true;
+ mFilterSleepVelocity = false;
+ mEnergySleepTest = true;
+ */
+ void setToDefault();
+
+ /** \internal
+ */
+ void fromNxU32(NxU32);
+
+ /** \internal
+ */
+ NxU32 toNxU32() const;
+
+ protected:
+
+ /** \internal
+ */
+ void parse(const NxString&);
+
+ };
+
+ /** \brief A wrapped class to represent the NX_BF_FROZEN_* flags
+ */
+ struct NxPublicClass FreezeFlags : Flags {
+
+ friend class ActorParams;
+
+ public:
+
+ /**
+ */
+ FreezeFlags();
+
+ /** \brief Shortcut function to freeze the position of the actor in every axis.
+ */
+ void FreezePosition();
+
+ /** \brief Shortcut function to freeze the rotation of the actor in every axis.
+ */
+ void FreezeRotation();
+
+ /** \brief Shortcut function to freeze the position and rotation of the actor in every axis.
+ */
+ void FreezeAll();
+
+ /** \brief Full or partial frozen of the Actor,
+ \default false, false, false
+ \see NX_BF_FROZEN_POS_X, NX_BF_FROZEN_POS_Z, NX_BF_FROZEN_POS_Z
+ \example
+ String variations => +px +py +pz or +position-all or +all
+ */
+ struct
+ {
+ /** \brief X axis to freeze,
+ \default false
+ \see NX_BF_FROZEN_POS_X
+ \example
+ String variations => +px
+ */
+ bool x;
+
+ /** \brief Y axis to freeze,
+ \default false
+ \see NX_BF_FROZEN_POS_Y
+ \example
+ String variations => +py
+ */
+ bool y;
+
+ /** \brief Z axis to freeze,
+ \default false
+ \see NX_BF_FROZEN_POS_Z
+ \example
+ String variations => +pz
+ */
+ bool z;
+ } mPosition;
+
+
+ /** \brief Freeze some or all of the rotation that may happen in the future of the Actor.
+ \default false of x,y,z
+ \see NX_BF_FROZEN_ROT_X, NX_BF_FROZEN_ROT_Y, NX_BF_FROZEN_ROT_Z
+ \example
+ String variations => +rx +ry +rz or +rotation-all
+ */
+ struct
+ {
+ /** \brief X axis to freeze,
+ \default false
+ \see NX_BF_FROZEN_ROT_X
+ \example
+ String variations => +rotation-x, +rx
+ */
+ bool x;
+
+ /** \brief Y axis to freeze,
+ \default false
+ \see NX_BF_FROZEN_POS_Y
+ \example
+ String variations => +rotation-y, +ry
+ */
+ bool y;
+
+ /** \brief Z axis to freeze,
+ \default false
+ \see NX_BF_FROZEN_POS_Z
+ \example
+ String variations => +rotation-z, +pz
+ */
+ bool z;
+ } mRotation;
+
+
+ /** \brief Set's the flags to not frozen.
+ */
+ void setToDefault();
+
+ /** \internal
+ */
+ void fromNxU32(NxU32);
+
+ /** \internal
+ */
+ NxU32 toNxU32() const;
+
+ protected:
+
+ void parse(const NxString&);
+
+ };
+
+ /** \brief ContactFlags is a simple class wrapper for the Nx???? enum.
+ */
+ struct NxPublicClass ContactFlags : Flags {
+
+ friend class ActorParams;
+
+ public:
+
+ /** \brief Normal constructor.
+ */
+ ContactFlags();
+
+ /** \brief Alternate way of adding a flag using the NxBodyFlag enum.
+ \example
+ params.mFlags += NX_BF_KINEMATIC;
+ */
+ void operator+=(NxContactPairFlag);
+
+ /** \brief Alternate way of removing a flag using the NxBodyFlag enum.
+ \example
+ params.mFlags -= NX_BF_KINEMATIC;
+ */
+ void operator-=(NxContactPairFlag);
+
+ /** \brief Notify contacts on everything
+ \default false
+ \see NX_NOTIFY_ALL
+ \example
+ String variations => +all
+ */
+ void All();
+
+ /** \brief Disable contact generation for this pair
+ \default false
+ \see...
[truncated message content] |
