rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathNamespace.h

@@ -0,0 +1,115 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMATHNAMESPACE_H
+#define INCLUDED_IMATHNAMESPACE_H
+
+//
+// The purpose of this file is to make it possible to specify an
+// IMATH_INTERNAL_NAMESPACE as a preprocessor definition and have all of the
+// Imath symbols defined within that namespace rather than the standard
+// Imath namespace.  Those symbols are made available to client code through
+// the IMATH_NAMESPACE in addition to the IMATH_INTERNAL_NAMESPACE.
+//
+// To ensure source code compatibility, the IMATH_NAMESPACE defaults to Imath
+// and then "using namespace IMATH_INTERNAL_NAMESPACE;" brings all of the
+// declarations from the IMATH_INTERNAL_NAMESPACE into the IMATH_NAMESPACE.
+// This means that client code can continue to use syntax like Imath::V3f,
+// but at link time it will resolve to a mangled symbol based on the
+// IMATH_INTERNAL_NAMESPACE.
+//
+// As an example, if one needed to build against a newer version of Imath and
+// have it run alongside an older version in the same application, it is now
+// possible to use an internal namespace to prevent collisions between the
+// older versions of Imath symbols and the newer ones.  To do this, the
+// following could be defined at build time:
+//
+// IMATH_INTERNAL_NAMESPACE = Imath_v2
+//
+// This means that declarations inside Imath headers look like this (after
+// the preprocessor has done its work):
+//
+// namespace Imath_v2 {
+//     ...
+//     class declarations
+//     ...
+// }
+//
+// namespace Imath {
+//     using namespace Imath_v2;
+// }
+//
+
+//
+// Open Source version of this file pulls in the IlmBaseConfig.h file
+// for the configure time options.
+//
+#include "IlmBaseConfig.h"
+
+
+#ifndef IMATH_NAMESPACE
+#define IMATH_NAMESPACE Imath
+#endif
+
+#ifndef IMATH_INTERNAL_NAMESPACE
+#define IMATH_INTERNAL_NAMESPACE IMATH_NAMESPACE
+#endif
+
+//
+// We need to be sure that we import the internal namespace into the public one.
+// To do this, we use the small bit of code below which initially defines
+// IMATH_INTERNAL_NAMESPACE (so it can be referenced) and then defines
+// IMATH_NAMESPACE and pulls the internal symbols into the public
+// namespace.
+//
+
+namespace IMATH_INTERNAL_NAMESPACE {}
+namespace IMATH_NAMESPACE {
+     using namespace IMATH_INTERNAL_NAMESPACE;
+}
+
+//
+// There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that
+// future extension to the namespace mechanism is possible without changing
+// project source code.
+//
+
+#define IMATH_INTERNAL_NAMESPACE_HEADER_ENTER namespace IMATH_INTERNAL_NAMESPACE {
+#define IMATH_INTERNAL_NAMESPACE_HEADER_EXIT }
+
+#define IMATH_INTERNAL_NAMESPACE_SOURCE_ENTER namespace IMATH_INTERNAL_NAMESPACE {
+#define IMATH_INTERNAL_NAMESPACE_SOURCE_EXIT }
+
+
+#endif /* INCLUDED_IMATHNAMESPACE_H */

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathPlane.h

@@ -0,0 +1,257 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IMATHPLANE_H
+#define INCLUDED_IMATHPLANE_H
+
+//----------------------------------------------------------------------
+//
+//	template class Plane3
+//
+//	The Imath::Plane3<> class represents a half space, so the
+//	normal may point either towards or away from origin.  The
+//	plane P can be represented by Imath::Plane3 as either p or -p
+//	corresponding to the two half-spaces on either side of the
+//	plane. Any function which computes a distance will return
+//	either negative or positive values for the distance indicating
+//	which half-space the point is in. Note that reflection, and
+//	intersection functions will operate as expected.
+//
+//----------------------------------------------------------------------
+
+#include "ImathVec.h"
+#include "ImathLine.h"
+#include "ImathNamespace.h"
+
+IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+template <class T>
+class Plane3
+{
+  public:
+
+    Vec3<T>			normal;
+    T				distance;
+
+    Plane3() {}
+    Plane3(const Vec3<T> &normal, T distance);
+    Plane3(const Vec3<T> &point, const Vec3<T> &normal);
+    Plane3(const Vec3<T> &point1,
+	   const Vec3<T> &point2,
+	   const Vec3<T> &point3);
+
+    //----------------------
+    //	Various set methods
+    //----------------------
+
+    void                        set(const Vec3<T> &normal,
+				    T distance);
+
+    void                        set(const Vec3<T> &point,
+				    const Vec3<T> &normal);
+
+    void                        set(const Vec3<T> &point1,
+				    const Vec3<T> &point2,
+				    const Vec3<T> &point3 );
+
+    //----------------------
+    //	Utilities
+    //----------------------
+
+    bool                        intersect(const Line3<T> &line,
+                                          Vec3<T> &intersection) const;
+
+    bool                        intersectT(const Line3<T> &line,
+					   T &parameter) const;
+
+    T				distanceTo(const Vec3<T> &) const;
+
+    Vec3<T>                     reflectPoint(const Vec3<T> &) const;
+    Vec3<T>                     reflectVector(const Vec3<T> &) const;
+};
+
+
+//--------------------
+// Convenient typedefs
+//--------------------
+
+typedef Plane3<float> Plane3f;
+typedef Plane3<double> Plane3d;
+
+
+//---------------
+// Implementation
+//---------------
+
+template <class T>
+inline Plane3<T>::Plane3(const Vec3<T> &p0,
+			 const Vec3<T> &p1,
+			 const Vec3<T> &p2)
+{
+    set(p0,p1,p2);
+}
+
+template <class T>
+inline Plane3<T>::Plane3(const Vec3<T> &n, T d)
+{
+    set(n, d);
+}
+
+template <class T>
+inline Plane3<T>::Plane3(const Vec3<T> &p, const Vec3<T> &n)
+{
+    set(p, n);
+}
+
+template <class T>
+inline void Plane3<T>::set(const Vec3<T>& point1,
+			   const Vec3<T>& point2,
+			   const Vec3<T>& point3)
+{
+    normal = (point2 - point1) % (point3 - point1);
+    normal.normalize();
+    distance = normal ^ point1;
+}
+
+template <class T>
+inline void Plane3<T>::set(const Vec3<T>& point, const Vec3<T>& n)
+{
+    normal = n;
+    normal.normalize();
+    distance = normal ^ point;
+}
+
+template <class T>
+inline void Plane3<T>::set(const Vec3<T>& n, T d)
+{
+    normal = n;
+    normal.normalize();
+    distance = d;
+}
+
+template <class T>
+inline T Plane3<T>::distanceTo(const Vec3<T> &point) const
+{
+    return (point ^ normal) - distance;
+}
+
+template <class T>
+inline Vec3<T> Plane3<T>::reflectPoint(const Vec3<T> &point) const
+{
+    return normal * distanceTo(point) * -2.0 + point;
+}
+
+
+template <class T>
+inline Vec3<T> Plane3<T>::reflectVector(const Vec3<T> &v) const
+{
+    return normal * (normal ^ v)  * 2.0 - v;
+}
+
+
+template <class T>
+inline bool Plane3<T>::intersect(const Line3<T>& line, Vec3<T>& point) const
+{
+    T d = normal ^ line.dir;
+    if ( d == 0.0 ) return false;
+    T t = - ((normal ^ line.pos) - distance) /  d;
+    point = line(t);
+    return true;
+}
+
+template <class T>
+inline bool Plane3<T>::intersectT(const Line3<T>& line, T &t) const
+{
+    T d = normal ^ line.dir;
+    if ( d == 0.0 ) return false;
+    t = - ((normal ^ line.pos) - distance) /  d;
+    return true;
+}
+
+template<class T>
+std::ostream &operator<< (std::ostream &o, const Plane3<T> &plane)
+{
+    return o << "(" << plane.normal << ", " << plane.distance
+	     << ")";
+}
+
+template<class T>
+Plane3<T> operator* (const Plane3<T> &plane, const Matrix44<T> &M)
+{
+    //                        T
+    //	                    -1
+    //	Could also compute M    but that would suck.
+    //
+
+    Vec3<T> dir1   = Vec3<T> (1, 0, 0) % plane.normal;
+    T dir1Len      = dir1 ^ dir1;
+
+    Vec3<T> tmp    = Vec3<T> (0, 1, 0) % plane.normal;
+    T tmpLen       = tmp ^ tmp;
+
+    if (tmpLen > dir1Len)
+    {
+	dir1      = tmp;
+	dir1Len   = tmpLen;
+    }
+
+    tmp            = Vec3<T> (0, 0, 1) % plane.normal;
+    tmpLen         = tmp ^ tmp;
+
+    if (tmpLen > dir1Len)
+    {
+	dir1      = tmp;
+    }
+
+    Vec3<T> dir2   = dir1 % plane.normal;
+    Vec3<T> point  = plane.distance * plane.normal;
+
+    return Plane3<T> ( point         * M,
+		      (point + dir2) * M,
+		      (point + dir1) * M );
+}
+
+template<class T>
+Plane3<T> operator- (const Plane3<T> &plane)
+{
+    return Plane3<T>(-plane.normal,-plane.distance);
+}
+
+
+IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IMATHPLANE_H

data/vendor/FreeImage/Source/OpenEXR/Imath/ImathPlatform.h

@@ -0,0 +1,112 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMATHPLATFORM_H
+#define INCLUDED_IMATHPLATFORM_H
+
+//----------------------------------------------------------------------------
+//
+//	ImathPlatform.h
+//
+//	This file contains functions and constants which aren't 
+//	provided by the system libraries, compilers, or includes on 
+//	certain platforms.
+//
+//----------------------------------------------------------------------------
+
+#include <math.h>
+
+#ifndef M_PI
+    #define M_PI    3.14159265358979323846
+#endif
+
+#ifndef M_PI_2
+    #define M_PI_2  1.57079632679489661923 // pi/2
+#endif
+
+
+//-----------------------------------------------------------------------------
+//
+//    Some, but not all, C++ compilers support the C99 restrict
+//    keyword or some variant of it, for example, __restrict.
+//
+//-----------------------------------------------------------------------------
+
+#if defined __GNUC__
+
+    //
+    // supports __restrict
+    //
+
+    #define IMATH_RESTRICT __restrict
+
+#elif defined (__INTEL_COMPILER) || \
+      defined(__ICL) || \
+      defined(__ICC) || \
+      defined(__ECC)
+
+    //
+    // supports restrict
+    //
+
+    #define IMATH_RESTRICT restrict
+
+#elif defined __sgi
+
+    //
+    // supports restrict
+    //
+
+    #define IMATH_RESTRICT restrict
+
+#elif defined _MSC_VER
+
+    //
+    // supports __restrict
+    //
+
+//    #define IMATH_RESTRICT __restrict
+    #define IMATH_RESTRICT
+
+#else
+
+    //
+    // restrict / __restrict not supported
+    //
+
+    #define IMATH_RESTRICT
+
+#endif
+
+#endif // INCLUDED_IMATHPLATFORM_H