Added slightly adapted OSG 3.0.1 headers (changed std::isnan to std::fpclassify= FP_NAN)

.gitignore

@@ -6,6 +6,7 @@ tags
 build
 Info.plist
 obj
+.DS_Store
 *.log
 *~
 *~.skp
@@ -31,7 +32,6 @@ deploy/qgroundcontrol*
 controller_log*
 user_config.pri
 *.app
-
 *.ncb
 *.vcproj
 *.vcxproj*

lib/mac32-gcc40/include/.gitignore

-OpenThreads
-osg*

lib/mac32-gcc40/include/OpenThreads/Atomic

+/* -*-c++-*- OpenThreads library, Copyright (C) 2008  The Open Thread Group
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * 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
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef _OPENTHREADS_ATOMIC_
+#define _OPENTHREADS_ATOMIC_
+
+#include <OpenThreads/Config>
+#include <OpenThreads/Exports>
+
+#if defined(_OPENTHREADS_ATOMIC_USE_BSD_ATOMIC)
+# include <libkern/OSAtomic.h>
+# define _OPENTHREADS_ATOMIC_USE_LIBRARY_ROUTINES
+#elif defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS) && defined(__i386__)
+# define _OPENTHREADS_ATOMIC_USE_LIBRARY_ROUTINES
+#elif defined(_OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED)
+# define _OPENTHREADS_ATOMIC_USE_LIBRARY_ROUTINES
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+# include <atomic.h>
+# include "Mutex"
+# include "ScopedLock"
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+# include "Mutex"
+# include "ScopedLock"
+#endif
+
+#if defined(_OPENTHREADS_ATOMIC_USE_LIBRARY_ROUTINES)
+#define _OPENTHREADS_ATOMIC_INLINE
+#else
+#define _OPENTHREADS_ATOMIC_INLINE inline
+#endif
+
+namespace OpenThreads {
+
+/**
+ *  @class Atomic
+ *  @brief  This class provides an atomic increment and decrement operation.
+ */
+class OPENTHREAD_EXPORT_DIRECTIVE Atomic {
+ public:
+    Atomic(unsigned value = 0) : _value(value)
+    { }
+    _OPENTHREADS_ATOMIC_INLINE unsigned operator++();
+    _OPENTHREADS_ATOMIC_INLINE unsigned operator--();
+    _OPENTHREADS_ATOMIC_INLINE unsigned AND(unsigned value);
+    _OPENTHREADS_ATOMIC_INLINE unsigned OR(unsigned value);
+    _OPENTHREADS_ATOMIC_INLINE unsigned XOR(unsigned value);
+    _OPENTHREADS_ATOMIC_INLINE unsigned exchange(unsigned value = 0);
+    _OPENTHREADS_ATOMIC_INLINE operator unsigned() const;
+ private:
+
+    Atomic(const Atomic&);
+    Atomic& operator=(const Atomic&);
+
+#if defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    mutable Mutex _mutex;
+#endif
+#if defined(_OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED)
+    volatile long _value;
+#elif defined(_OPENTHREADS_ATOMIC_USE_BSD_ATOMIC)
+    volatile int32_t _value;
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    volatile uint_t _value;
+    mutable Mutex _mutex;  // needed for xor
+#else
+    volatile unsigned _value;
+#endif
+};
+
+/**
+ *  @class AtomicPtr
+ *  @brief  This class provides an atomic pointer assignment using cas operations.
+ */
+class OPENTHREAD_EXPORT_DIRECTIVE AtomicPtr {
+public:
+    AtomicPtr(void* ptr = 0) : _ptr(ptr)
+    { }
+    ~AtomicPtr()
+    { _ptr = 0; }
+
+    // assigns a new pointer
+    _OPENTHREADS_ATOMIC_INLINE bool assign(void* ptrNew, const void* const ptrOld);
+    _OPENTHREADS_ATOMIC_INLINE void* get() const;
+
+private:
+    AtomicPtr(const AtomicPtr&);
+    AtomicPtr& operator=(const AtomicPtr&);
+
+#if defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    mutable Mutex _mutex;
+#endif
+    void* volatile _ptr;
+};
+
+#if !defined(_OPENTHREADS_ATOMIC_USE_LIBRARY_ROUTINES)
+
+_OPENTHREADS_ATOMIC_INLINE unsigned
+Atomic::operator++()
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_add_and_fetch(&_value, 1);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __add_and_fetch(&_value, 1);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    return atomic_inc_uint_nv(&_value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    return ++_value;
+#else
+    return ++_value;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE unsigned
+Atomic::operator--()
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_sub_and_fetch(&_value, 1);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __sub_and_fetch(&_value, 1);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    return atomic_dec_uint_nv(&_value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    return --_value;
+#else
+    return --_value;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE unsigned
+Atomic::AND(unsigned value)
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_fetch_and_and(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __and_and_fetch(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    return atomic_and_uint_nv(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    _value &= value;
+    return _value;
+#else
+    _value &= value;
+    return _value;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE unsigned
+Atomic::OR(unsigned value)
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_fetch_and_or(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __or_and_fetch(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    return atomic_or_uint_nv(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    _value |= value;
+    return _value;
+#else
+    _value |= value;
+    return _value;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE unsigned
+Atomic::XOR(unsigned value)
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_fetch_and_xor(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __xor_and_fetch(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    ScopedLock<Mutex> lock(_mutex);
+    _value ^= value;
+    return _value;
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    _value ^= value;
+    return _value;
+#else
+    _value ^= value;
+    return _value;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE unsigned
+Atomic::exchange(unsigned value)
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_lock_test_and_set(&_value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __compare_and_swap(&_value, _value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    return atomic_cas_uint(&_value, _value, value);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    unsigned oldval = _value;
+    _value = value;
+    return oldval;
+#else
+    unsigned oldval = _value;
+    _value = value;
+    return oldval;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE
+Atomic::operator unsigned() const
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    __sync_synchronize();
+    return _value;
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    __synchronize();
+    return _value;
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    membar_consumer(); // Hmm, do we need???
+    return _value;
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    return _value;
+#else
+    return _value;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE bool
+AtomicPtr::assign(void* ptrNew, const void* const ptrOld)
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    return __sync_bool_compare_and_swap(&_ptr, ptrOld, ptrNew);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    return __compare_and_swap((unsigned long*)&_ptr, (unsigned long)ptrOld, (unsigned long)ptrNew);
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    return ptrOld == atomic_cas_ptr(&_ptr, const_cast<void*>(ptrOld), ptrNew);
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    if (_ptr != ptrOld)
+        return false;
+    _ptr = ptrNew;
+    return true;
+#else
+    if (_ptr != ptrOld)
+        return false;
+    _ptr = ptrNew;
+    return true;
+#endif
+}
+
+_OPENTHREADS_ATOMIC_INLINE void*
+AtomicPtr::get() const
+{
+#if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)
+    __sync_synchronize();
+    return _ptr;
+#elif defined(_OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)
+    __synchronize();
+    return _ptr;
+#elif defined(_OPENTHREADS_ATOMIC_USE_SUN)
+    membar_consumer(); // Hmm, do we need???
+    return _ptr;
+#elif defined(_OPENTHREADS_ATOMIC_USE_MUTEX)
+    ScopedLock<Mutex> lock(_mutex);
+    return _ptr;
+#else
+    return _ptr;
+#endif
+}
+
+#endif // !defined(_OPENTHREADS_ATOMIC_USE_LIBRARY_ROUTINES)
+
+}
+
+#endif // _OPENTHREADS_ATOMIC_

lib/mac32-gcc40/include/OpenThreads/Barrier

+/* -*-c++-*- OpenThreads library, Copyright (C) 2002 - 2007  The Open Thread Group
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * 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 
+ * OpenSceneGraph Public License for more details.
+*/
+
+
+//
+// Barrier - C++ barrier class
+// ~~~~~~~
+// 
+
+#ifndef _OPENTHREADS_BARRIER_
+#define _OPENTHREADS_BARRIER_
+
+#include <OpenThreads/Exports>
+
+namespace OpenThreads {
+
+
+/**
+ *  @class Barrier
+ *  @brief This class provides an object-oriented thread barrier interface
+ *
+ *  @warning It is unwise to use the construct "Barrier barrier" in the
+ *           global namespace on sgi's.  The object "barrier"
+ *           will confilict with the c-library sproc function "barrier" and
+ *           unpredictable results may occur. You have been warned.
+ */
+class OPENTHREAD_EXPORT_DIRECTIVE Barrier {
+
+public:
+
+    /**
+     *  Constructor
+     */
+    Barrier(int numThreads=0);
+
+    /**
+     *  Destructor
+     */
+    virtual ~Barrier();
+
+    /**
+     *  Reset the barrier to it's original state.
+     */
+    virtual void reset();
+
+    /**
+     *  Block until numThreads threads have entered the barrier.
+     */
+    virtual void block(unsigned int numThreads=0);
+
+    /**
+     *  Release the barrier, now.
+     */
+    virtual void release();
+
+    /**
+     *  Return the number of threads currently blocked in the barrier,
+     *  Return -1 if error.
+     */ 
+    virtual int numThreadsCurrentlyBlocked();
+
+
+    void invalidate();
+    
+private:
+
+    /**
+     *  Private copy constructor, to prevent tampering.
+     */
+    Barrier(const Barrier &/*b*/) {};
+
+    /**
+     *  Private copy assignment, to prevent tampering.
+     */
+    Barrier &operator=(const Barrier &/*b*/) {return *(this);};
+
+    /**
+     *  Implementation-specific private data.
+     */
+    void *_prvData;
+
+
+    bool _valid;
+
+};
+
+}
+
+#endif // !_OPENTHREADS_BARRIER_
+

lib/mac32-gcc40/include/OpenThreads/Block

+/* -*-c++-*- OpenThreads - Copyright (C) 1998-2007 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * 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
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef _OPENTHREADS_BLOCK_
+#define _OPENTHREADS_BLOCK_
+
+#include <OpenThreads/Thread>
+#include <OpenThreads/Barrier>
+#include <OpenThreads/Condition>
+#include <OpenThreads/ScopedLock>
+
+namespace OpenThreads {
+
+/** Block is a block that can be used to halt a thread that is waiting another thread to release it.*/
+class Block 
+{
+    public:
+    
+        Block():
+            _released(false) {}
+
+        ~Block()
+        {
+            release();
+        }
+
+        inline bool block()
+        {
+            ScopedLock<OpenThreads::Mutex> mutlock(_mut);
+            if( !_released )
+            {
+                return _cond.wait(&_mut)==0;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        inline bool block(unsigned long timeout)
+        {
+            ScopedLock<OpenThreads::Mutex> mutlock(_mut);
+            if( !_released )
+            {
+                return _cond.wait(&_mut, timeout)==0;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        inline void release()
+        {
+            ScopedLock<OpenThreads::Mutex> mutlock(_mut);
+            if (!_released)
+            {
+                _released = true;